For example:

<target name="deploy" depends="release">
	<copy file="${out.dir}/android_rules-release.apk" tofile="${out.dir}/${appname}.apk" overwrite="true"/>
</target>

Now from command prompt run:

ant deploy -Dappname=MyApp


And on successful build it will generate MyApp.APK in bin/ folder

Below code snippet changes the String data type (notice $type : 2, where 2 indicates the category fields containing data of type String) to an array of String:

db.collection.find( { "category" : { $type : 2 } } ).forEach( function (x) {
    x.category = [ x.category];
    db.collection.save(x);
});

Although, the error description is very clear and straight forward but it took me some good amount of time to discover the actual cause. In my case, I was using wrong key store alias for generating the key, resulting in key mismatch when application is executed. So if you also have forgotten the key alias then there this command which returns details of a key in key store:

C:\Users\Waqas>keytool -list -v -keystore c:\path-to-keystore\key.store

enter the password if required and if all goes well you get’ll something like this:

Keystore type: JKS
Keystore provider: SUN

*******************************************
*******************************************


But after couple of days when i resumed from where I stopped last time, did some changes in my webserver to make it more useful rather printing ‘Welcome’ message, when I tried running following command

node my_server.js

It always ended up with following exception:

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
Error: listen EACCES
    at errnoException (net.js:642:11)
    at Array.0 (net.js:728:28)
    at EventEmitter._tickCallback (node.js:192:40)

I banged my head quite a while, try changes bits here and there but nothing worked out- so i decided to google it and as always found a similar post and solution posted on StackOverflow- so basically it turned out that Error: listen EACCES occurs when user doesn’t have enough rights to start web server on certain ports- and obviously my ec2-user doesn’t have permission to start server on port ’80′. So for solving this all i did was gave the appropiate rights to logged-in user and … happy ending…

Anyways to get started first step is to send HTTP POST request to http://www.reddit.com/api/login along with required parameters ‘user’ and ‘passwd’ for username and password. If username and password combination matches reddit server will return authentication cookie containing reddit_session along with other different stuff like domain, path etc…

Code here show how to make an HTTP POST request using Apache HttpClient, read and store cookie for further use:

public class RedditClient {

    private List<Cookie> cookies = null;

    public boolean Login() throws ClientProtocolException, IOException {
		List<NameValuePair> loginParams = new ArrayList<NameValuePair>();
		loginParams.add(new BasicNameValuePair("api_type", "json"));

        //Set values of form fields
		loginParams.add(new BasicNameValuePair("user", userName));
		loginParams.add(new BasicNameValuePair("passwd", password));

		UrlEncodedFormEntity entity = new UrlEncodedFormEntity(loginParams, "UTF-8");

		HttpPost httpPost = new HttpPost("https://ssl.reddit.com/api/login");
		httpPost.setEntity(entity);

		DefaultHttpClient httpClient = new DefaultHttpClient();

		HttpResponse httpResponse = httpClient.execute(httpPost);				

        //Save cookie in List of Cookies so we can use it later
		cookies = httpClient.getCookieStore().getCookies();						

		httpClient.getConnectionManager().shutdown();

		return false;
	}
}

Now in order to make a subsequent request which require authentication for example submitting a new post or posting a comment we have to pass attach this cookie with the request; Otherwise server will respond with an error.
Below is how to make a subsequent request, in this case a request to retrieve top 100 post from funny category, along with cookie.

public class RedditClient {
    ....
    public void readListing() {
         URI feedUrl = new URI("http://www.reddit.com/r/funny/top/?sort=top&t=month");
         DefaultHttpClient httpClient = new DefaultHttpClient();

         HttpGet httpGet = new HttpGet(feedUrl);

         //Check if cookie list is not empty
         //attach it with current request
         if(this.cookies != null) {
             for(Cookie c : this.cookies)
	         httpClient.getCookieStore().addCookie(c);
         }

         HttpResponse response = httpClient.execute(httpGet);

         String strResponse = "";

         BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
         String line = "";
         while ((line = rd.readLine()) != null) {
	    strResponse += line;
         }

         httpClient.getConnectionManager().shutdown();
    }
}

In order to check if our request was treated as a trusted request look for the value of ‘modhash’ in response it should be a long encrypted string, for unauthenticated requests it’s always empty.

{"kind": "Listing", "data": {"modhash": "bjxvddjbxaac5b494bc70000000000000000000000",........ }

And finally putting it all together:

public class RedditClient {
    private List<Cookie> cookies = null;

    public boolean Login() throws ClientProtocolException, IOException {
		List<NameValuePair> loginParams = new ArrayList<NameValuePair>();
		loginParams.add(new BasicNameValuePair("api_type", "json"));

        //Set values of form fields
		loginParams.add(new BasicNameValuePair("user", userName));
		loginParams.add(new BasicNameValuePair("passwd", password));

		UrlEncodedFormEntity entity = new UrlEncodedFormEntity(loginParams, "UTF-8");

		HttpPost httpPost = new HttpPost("https://ssl.reddit.com/api/login");
		httpPost.setEntity(entity);

		DefaultHttpClient httpClient = new DefaultHttpClient();

		HttpResponse httpResponse = httpClient.execute(httpPost);				

        //Save cookie in List of Cookies so we can use it later
		cookies = httpClient.getCookieStore().getCookies();						

		httpClient.getConnectionManager().shutdown();

		return false;
	}

    public void readListing() {
         URI feedUrl = new URI("http://www.reddit.com/r/funny/top/?sort=top&t=month");
         DefaultHttpClient httpClient = new DefaultHttpClient();

         HttpGet httpGet = new HttpGet(feedUrl);

         //Check if cookie list is not empty
         //attach it with current request
         if(this.cookies != null) {
             for(Cookie c : this.cookies)
	         httpClient.getCookieStore().addCookie(c);
         }

         HttpResponse response = httpClient.execute(httpGet);

         String strResponse = "";

         BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
         String line = "";
         while ((line = rd.readLine()) != null) {
	    strResponse += line;
         }

         httpClient.getConnectionManager().shutdown();
    }
}

One of them is tag and @JsonSerialize annotation. The former is used to tell Spring what to use as sensible defaults based on entries in classpath, so if Jackson jars are in classpath, Jackson JSON Processor will be used to read/write JSON.

Whereas @JsonSerialize annotation can be used to override the default formatting strategy uses by Jackson during json serialization. This can be very handy when one is dealing with date time fields, lets take an example – I have a controller ‘subscription’ with an action name ‘getSubscriber(String subcriberId)’ and it returns an object of subscriber class as shown below:

//Controller - SubscriptionController.java
@Controller
@RequestMapping("/subsciption")
public class SubscriptionController {

	@RequestMapping(value = "/getSubcriber", method = RequestMethod.GET)
	public @ResponseBody
	Subscriber getSubscriber(@RequestParam String subscriberId) {
        return subscriberRepo.getSubscriber(subscriberId);
    }
}

//Subscriber POJO - Subscriber.java
public class Subscriber {
	private String subscriberId;
	private Date subscriptionExpiryDate;

	public Subscriber() { }

	public String getSubscriberId() {
		return this.subscriberId;
	}

	public void setSubscriberId(String subscriberId) {
		this.subscriberId = subscriberId;
	}

	public Date getSubscriptionExpiryDate() {
		return this.subscriptionExpiryDate;
	}

	public void setSubscriptionExpiryDate(Date subscriptionExpiryDate) {
		this.subscriptionExpiryDate = subscriptionExpiryDate;
	}
}

By default the serialized json output to this action will be:

{"subscriberId":"UFCC09211","subscriptionExpiryDate":1328866365808}

Notice the value of subscriptionExpiryDate field – it doesn’t look like a date or time, also what if one wants date time in particular format like yyyy-mm-dd? This is where @JsonSerialize comes in a picture. In order to override the default date formatting one has to extend JsonSerializer class provided by Jackson and override the serialize(Date value, JsonGenerator gen, SerializerProvider prov) method.

For our example CustomDateSerializer class looks like this:

public class CustomDateSerializer extends JsonSerializer<Date> {

	@Override
	public void serialize(Date value, JsonGenerator gen, SerializerProvider prov)
			throws IOException, JsonProcessingException {

		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String formattedDate = formatter.format(value);

        gen.writeString(formattedDate);
	}
}

and to tell Jackson to use this class to format date while serializing is to use the @JsonSerialize on get method of date field like this:

@JsonSerialize(using = CustomDateSerializer.class)
public Date getSubscriptionExpiryDate() {
	return this.subscriptionExpiryDate;
}

that’s it, the output date will now be in ‘yyyy-mm-dd’ format:

{"subscriberId":"UFCC09211","subscriptionExpiryDate":"2012-02-10"}

<security:form-login login-page="/login"</pre>
 authentication-failure-url="/login/failure"
 default-target-url="/"/>

What it says is: where the login page resides (login-page), after logging in redirect user to “/” (default-target-url) given that user wasn’t landed here while trying to access any page that required authentication and what page to serve in case of failed login attept (authentication-failure-url).

OK, it’s pretty straight forward but what if instead of using values specified in config one has to specify these values dynamically – with dynamically I mean on authentication failure instead of redirecting to “/login/failure” (value of authentication-failure-url), redirect to /signup or some other url depending on some checks/conditions?

Luckily for this spring has:

If you haven’t noticed yet RedirectStrategy is the interface we are most interested in, since it’s the one that will be one incorporating the strategy of forward requests. So for this we simply need to write a custom class that implements RedirectStrategy and override sendRedirect(HttpServletRequest request, HttpServletResponse response, String url) method.

Let’s show you what I mean:

//Custom redirection strategy for handling successful handling
public class CustomSuccessRedirection implements RedirectStrategy {

	@Override
	public void sendRedirect(HttpServletRequest request, HttpServletResponse response,
			String url) throws IOException {

		//redirect based on some condition
		if(someCondition) {
			response.sendRedirect("/home/a");
		} else {
			response.sendRedirect("/home/b");
		}
	}
}

Similarly a strategy for failed authentication can also be written in the same way.

Now to override the default url redirection strategy we need to add following to config:

<!-- Custom Redirection Strategy bean -->
<bean id="customSuccessRedirStrategy" class="net.waqassiddiqi.spring.CustomSuccessRedirection" />
<bean id="customFailedRedirStrategy" class="net.waqassiddiqi.spring.CustomFailedRedirection" />

<bean id="customRedirSuccessHandler" class="org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler">
	<property name="redirectStrategy" ref="customSuccessRedirStrategy" />
</bean>

<bean id="customRedirFailedHandler" class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
	<property name="defaultFailureUrl" value="/login/failure" />
	<property name="redirectStrategy" ref="customFailedRedirStrategy" />
</bean>

...
Calendar startDate = getStartDate();
Calendar endDate = getEndDate();

//Calculate time elapsed in HH:MM:SS
long totalMilliSec = endDate.getTimeInMillis() - startDate.getTimeInMillis();
int seconds = (int) (totalMilliSec / 1000) % 60;
int minutes =  ((int)(totalMilliSec / 1000) / 60) % 60;
int hours = (int)(totalMilliSec / 1000) / 3600;

System.out.format("%02d:%02d:%02d", hours, minutes, seconds);
....
Sample output will be something like: 24:01:34
....

For comparison find below the C# code which does exact the same:

DateTime dtStart = getStartDate();
DateTime dtEnd = getEndDate();

TimeSpan ts = dtEnd.Subtract(dtStart);
Console.WriteLine("{0}:{1}:{2}", ts.Hours.ToString("D2"),
      ts.Minutes.ToString("D2"), ts.Seconds.ToString("D2"));
.....
Sample output will be something like: 24:01:34
.....

Between, for java, there exists an easy to use library to work with date time ‘Joda Time’. One can say that it provide almost all the functionality C#’s DateTime provide. Here you can find more: http://joda-time.sourceforge.net/

ResultSet.getDate() returns date without time i.e. If table column has date time value say 2011-01-01 12:05:01 then the output of ResultSet.getDate() will be 2011-01-01.

And if in case complete date time value is required use ResultSet.getTimestamp() instead. The output will be complete date with time 2011-01-01 12:05:01

ResultSet rs = ...;
rs.getDate("columnName"); //value will be date without time
rs.getTimestamp("columnName"); //value will be date *with* time

By default flexjson uses the POJO property names as the field name in serialized json output, so the output of this POJO:

//Person.java
public class Person {
	String firstName;

    public String getName() { return firstName;}
    public void setName(String firstName) { this.firstName = firstName; }
}

will be:

{"firstName":"Abdul Kareem"}

But what if I can’t change POJOs but still would like the serialized output to be something like this:

{"first_name":"Abdul Kareem"}

This was the problem which I ran into today, overriding the default flexjson behaviour and provide the field names manually. It wasn’t that difficult as I thought, few minutes into mailing list search led me to official flexjson tutorial page on sourceforge. There they have written about using Custom Transformer in great detail using example.

So in short, in order to play with field name’s during serialization flexjson has provided an abstract class AbstractTransformer, writting custom transformer is as easy as extending this class and overriding void transform(Object object) method.

Pasted below is the code of FieldNameTransformer class which I wrote for solving the problem I mentioned earlier. It allows user to specify the field name rather then using default POJO property names in json serialized output.

public class FieldNameTransformer extends AbstractTransformer {
	private String transformedFieldName;

	public FieldNameTransformer(String transformedFieldName) {
		this.transformedFieldName = transformedFieldName;
	}

	/***
	 * Use this method to override the default functionality
	 * of handling field names and their values
	 */
	public void transform(Object object) {
		boolean setContext = false;

		TypeContext typeContext = getContext().peekTypeContext();

		//Write comma before starting to write field name if this
		//isn't first property that is being transformed
		if (!typeContext.isFirst())
			getContext().writeComma();

		typeContext.setFirst(false);

		getContext().writeName(getTransformedFieldName());
		getContext().writeQuoted((String) object);

		if (setContext) {
            getContext().writeCloseObject();
        }
	}

	/***
	 * TRUE tells the JSONContext that this class will be handling
	 * the writing of our property name by itself.
	 */
	@Override
    public Boolean isInline() {
        return Boolean.TRUE;
    }

	public String getTransformedFieldName() {
		return this.transformedFieldName;
	}
}

And this is how to use it:

Person person = new Person();
person.setFirstName("Abdul Kareem");

JSONSerializer serializer = new JSONSerializer().exclude("class")
                .transform(new StringTransformer("first_name"), "firstName");
String jsonString = serializer.serialize(person);

And here is the desired output:

{"first_name":"Abdul Kareem"}