com.octo.android.robospice.persistence.ormlite.RoboSpiceDatabaseHelper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of robospice-ormlite Show documentation
The newest version!
package com.octo.android.robospice.persistence.ormlite;

import java.io.File;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import roboguice.util.temp.Ln;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils;

/**
 * Helper class which creates/updates our database and provides the DAOs.
 */
public class RoboSpiceDatabaseHelper extends OrmLiteSqliteOpenHelper {

    public static String getCacheKeyForId(String id, Class clazz) {
        return clazz.getSimpleName() + "_" + id.toString();
    }

    public static String getIdForCacheKey(String cacheKey) {
        return cacheKey.substring(cacheKey.indexOf('_') + 1);
    }

    public RoboSpiceDatabaseHelper(Context context, String databaseName, int databaseVersion) {
        super(context, databaseName, null, databaseVersion);
    }

    public RoboSpiceDatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion) {
        super(context, databaseName, factory, databaseVersion);
    }

    public RoboSpiceDatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion, int configFileId) {
        super(context, databaseName, factory, databaseVersion, configFileId);
    }

    public RoboSpiceDatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion, File configFile) {
        super(context, databaseName, factory, databaseVersion, configFile);
    }

    public RoboSpiceDatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion, InputStream stream) {
        super(context, databaseName, factory, databaseVersion, stream);
    }

    public  void updateObjectInDatabase(T modelObject, Class modelObjectClass) throws SQLException {
        if (modelObject != null) {
            Dao dao = getDao(modelObjectClass);
            dao.update(modelObject);
        }
    }

    public  void refreshFromDatabase(T modelObject, Class modelObjectClass) throws SQLException {
        if (modelObject != null) {
            Dao dao = getDao(modelObjectClass);
            dao.refresh(modelObject);
        }
    }

    public  void createOrUpdateInDatabase(T modelObject, Class modelObjectClass) throws SQLException {
        if (modelObject != null) {
            Dao dao = getDao(modelObjectClass);
            dao.createOrUpdate(modelObject);
        }
    }

    public void createOrUpdateCacheEntryInDatabase(CacheEntry cacheEntry) throws SQLException {
        if (cacheEntry != null) {
            Dao dao = getDao(CacheEntry.class);
            dao.createOrUpdate(cacheEntry);
        }
    }

    public  List queryForAllFromDatabase(Class modelObjectClass) throws SQLException {
        List allObjectsInTable = new ArrayList();
        Dao dao = getDao(modelObjectClass);
        allObjectsInTable.addAll(dao.queryForAll());
        return allObjectsInTable;
    }

    public  T queryForIdFromDatabase(ID id, Class modelObjectClass) throws SQLException {
        Dao dao = getDao(modelObjectClass);
        T result = dao.queryForId(id);

        return result;
    }

    public CacheEntry queryCacheKeyForIdFromDatabase(String id) throws SQLException {
        Dao dao = getDao(CacheEntry.class);
        return dao.queryForId(id);
    }

    public  void deleteByIdFromDataBase(ID id, Class modelObjectClass) throws SQLException {
        Dao dao = getDao(modelObjectClass);
        dao.deleteById(id);
    }

    public  void clearTableFromDataBase(Class modelObjectClass) throws SQLException {
        try {
            clearTable(modelObjectClass);
        } catch (Exception ex) {
            Ln.d(ex, "An exception occurred when cleaning table");
        }
    }

    private  void clearTable(Class clazz) throws SQLException {
        for (Field field : clazz.getDeclaredFields()) {
            ForeignCollectionField annotation = field.getAnnotation(ForeignCollectionField.class);
            if (annotation != null) {
                ParameterizedType stringListType = (ParameterizedType) field.getGenericType();
                Class itemInListClass = (Class) stringListType.getActualTypeArguments()[0];
                clearTable(itemInListClass);
            }
        }
        TableUtils.dropTable(getConnectionSource(), clazz, true);
        TableUtils.createTableIfNotExists(getConnectionSource(), clazz);
    }

    public  void deleteFromDataBase(Collection objectList, Class modelObjectClass) throws SQLException {
        if (objectList != null && !objectList.isEmpty()) {
            Dao dao = getDao(modelObjectClass);
            dao.delete(objectList);
        }
    }

    public  void createInDatabaseIfNotExist(T modelObject, Class modelObjectClass) throws SQLException {
        if (modelObject != null) {
            Dao dao = getDao(modelObjectClass);
            dao.createIfNotExists(modelObject);
        }
    }

    public  void deleteFromDataBase(T modelObject, Class modelObjectClass) throws SQLException {
        if (modelObject != null) {
            Dao dao = getDao(modelObjectClass);
            dao.delete(modelObject);
        }
    }

    public  void deleteFromDataBase(ForeignCollection modelObjectCollection, Class modelObjectClass) throws SQLException {
        if (modelObjectCollection != null) {
            Dao dao = getDao(modelObjectClass);
            dao.delete(modelObjectCollection);
        }
    }

    public  long countOfAllObjectsOfTable(Class modelObjectClass) throws SQLException {
        Dao dao = getDao(modelObjectClass);
        return dao.countOf();
    }

    public  ForeignCollection getNewEmptyForeignCollection(String foreignKeyColumnName, Class modelObjectClass, Class foreignObjectClass) throws SQLException {
        Dao dao = getDao(modelObjectClass);
        return dao.getEmptyForeignCollection(foreignKeyColumnName);
    }

    @Override
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
        // override if needed
    }

    @Override
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
        // override if needed
    }
}