For etohum admin application we used gae/j and it has been almost two years and gae/j has been improved a lot, but still, it has some really annoying features (bugs — I am not sure how to named them).

This time, it is the Datastore Indexes. Some of the pages requires indexes like

which turns out to be confusing for the auto generation tool. If, let’s say, you change the order of the last two fields,

like this

you will not get it automatically.

Even if you explicitly define it in your  datastore-indexes.xml file

<datastore-index kind="Application" ancestor="false" source="manual">
 <property name="applciationIsFinished" direction="asc"/>
 <property name="isSpam" direction="asc"/>
 <property name="sezonId" direction="asc"/>
 <property name="bitisTarihi" direction="desc"/>
 <property name="basvuruTarihi" direction="desc"/>
 </datastore-index>

And the workaround for the problem is stated in the last paragraph of Using Automatic Index Configuration documentation

It’s a good idea to occasionally move index configuration from datastore-indexes-auto.xml to datastore-indexes.xml, then disable automatic index configuration and test your app in the development server. This makes it easy to maintain indexes without having to manage two files, and ensures that your testing will reproduce errors caused by missing index configuration.

So change the datastore-indexes.xml file and add manually the all required indexes and upload the application.

<datastore-indexes autoGenerate="false">

You can change it back to auto generate after make sure the desired indexes are created.

ps. A tip about gae/j is that it is considerable faster when it is 4AM-7AM at the west coast of North America.

Since Burak hoca asks for an enhancements recently, we go through the app engine documentation and see this new feature query cursors which is excellent for paging.

The idea behind query cursors is pretty simple, make a query for the first page, pass the cursor data to the client. When you need the second page,  instead of  making a query from scracth, use the cursor data to get the next page’s data.

In our case the RPC call  getApplications(String cursor) is called. For the first page, cursor data is passed as null, so we make the query as follows:

if (cursorString == null)
{
	//
	Query query = pm.newQuery(Application.class);
	query.setOrdering("basvuruTarihi desc");
	query.setRange(0, 15);

	results = (List) query.execute();

	Cursor cursor = JDOCursorHelper.getCursor(results);
	resultWrapper.setCursorData(cursor.toWebSafeString());

	for (Iterator iterator = results.iterator(); iterator.hasNext();)
	{
		Application applicationFromDatabase = (Application) iterator.next();
		app = DunyaTurkOlsunUtil.createApplicationDTO(applicationFromDatabase);
		resultAppList.add(app);
	}
	resultWrapper.setResultAppList(resultAppList);
}

So this code above fetch the first page and cursor string. On the client side, inside GWT, we hold the cursor string for each page in an arraylist, so that we can handle going back and forth between the pages.

When the user asks for the second pages, the following code block executes

else
{
	Cursor cursor = Cursor.fromWebSafeString(cursorString);
	Map extensionMap = new HashMap();
	extensionMap.put(JDOCursorHelper.CURSOR_EXTENSION, cursor);
	Query query = pm.newQuery(Application.class);
	query.setOrdering("basvuruTarihi desc");

	query.setExtensions(extensionMap);
	query.setRange(0, 15);

	results = (List) query.execute();
	resultWrapper.setCursorData(JDOCursorHelper.getCursor(results).toWebSafeString());

	for (Iterator iterator = results.iterator(); iterator.hasNext();)
	{
		Application applicationFromDatabase = (Application) iterator.next();
		app = DunyaTurkOlsunUtil.createApplicationDTO(applicationFromDatabase);
		//
		resultAppList.add(app);
	}
	resultWrapper.setResultAppList(resultAppList);
}

//
This works even faster than memcached version of ours. 

ps. By the way, there is still no way of passing JDO objects through RPC calls which is sad for GWT apps on GAE/J/

Step 1. Get a Twitter account and create a Twitter application from http://twitter.com/apps (don’t forget to check in browser and enter a  valid callback url.

Step 2.  Download twitter4J add the library (in my case twitter4j-core-2.1.1-SNAPSHOT.jar) to project and update classpath

Step 3. Create a web application (I assume you have the Google plugin for Eclipse )

Step 4. Add the following servlets and update your web.xml. First servlet will handle login part. It will create a RequestToken which will create the magical aggrements between the consumer(your application) and provider(twitter). First servlet save the  token and secret token since we will need them later.

String token = requestToken.getToken();
String tokenSecret = requestToken.getTokenSecret();

• Home servlet
• Login Servlet

Step 5. You forget to update web.xml didn’t you, update the web.xml

Step 6.  Enable session by adding

    <sessions-enabled>true</sessions-enabled>

to appengine-web.xml.

You can see my version from http://90.latest.denemekaya.appspot.com/login

ps. don’t forget to set the callback in Twittter to the url of the servlet for callback.

Links:

• http://www.pakzilla.com/2009/10/03/tutorial-java-based-twitter-app-on-google-app-engine/
• Explain the same procedure with Grails — http://blogs.bytecode.com.au/glen/2009/12/08/log-into-your-grails-app-using-your-twitter-credentials.html

Memcache provides convenience to store a frequent query in memory, so that you don’t have to make the same execution over and over again. For the iPhone application I build (Fragman), I build a GAE/J backend for managing movie names, IMDB URLs, thumb images, video files, etc. It interacts with the Obj-c code via calls encoded in JSON.

Since the categories are updated so frequently (new trailer, top 250 , soap opera trailers), every time the user starts the application from her iPhone, the corresponding categories Id(key) lists are  created which includes all the aspects mentioned above,

what I see, after people start to use the application that, most of the time, the application got stuck with the time constraint of GAE and this causes inconvenience, so I decided to hold the category lists’s JSON in memory. Following is the code ,

this is the servlet for creating the JSON which is called after say upcoming movie list is changed. This servlet updates the memcached list

        List keyList = new ArrayList();
	static Cache cache;
	static
	{
		try
		{
			CacheFactory cacheFactory =

CacheManager.getInstance().getCacheFactory();
			cache = cacheFactory.createCache(

Collections.emptyMap());
		}
		catch (CacheException e)
		{
			// ...
		}
		//.....
                public void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException

	        {
                       //................
                       if(cache.containsKey(mode))
		       {
			     cache.remove(mode);
		       }
		       cache.put(mode, keyList);
	        }

                //........

          }

And this is the servlet that fetch the Fragman beans from the datastore with the given keys (key list is got from the memecached list)

          keyList = (List)cache.get(mode);

By doing this, I reduce the time that the servlet that creates the JSON takes.