Initial Commit

.gitignore

+#built application files
+app/*.apk
+app/*.ap_
+
+# files for the dex VM
+*.dex
+
+# Java class files
+*.class
+
+# generated files
+bin/
+gen/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Windows thumbnail db
+Thumbs.db
+
+# OSX files
+.DS_Store
+
+# Eclipse project files
+.classpath
+.project
+
+# Android Studio
+*.iml
+.idea
+#.idea/workspace.xml - remove # and delete .idea if it better suit your needs.
+.gradle
+build/
+
+*~
+._*
+

app/.gitignore

+/build

app/build.gradle

+apply plugin: 'com.android.application'
+apply plugin: 'android-apt'
+
+android {
+    signingConfigs {
+        config {
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+            storeFile file('/home/chaukadev/.android/debug.keystore')
+            storePassword 'android'
+        }
+    }
+
+    compileSdkVersion 24
+    buildToolsVersion "24.0.1"
+
+    defaultConfig {
+        applicationId "com.vsoft.uofl_catalogue"
+        minSdkVersion 9
+        targetSdkVersion 24
+        versionCode 1
+        versionName "1.0"
+        multiDexEnabled true
+    }
+    buildTypes {
+        debug {
+            applicationIdSuffix ".debug"
+            buildConfigField "int", "BUILD_TYPE_INT", "1"
+        }
+
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            buildConfigField "int", "BUILD_TYPE_INT", "2"
+            signingConfig signingConfigs.config
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    testCompile 'junit:junit:4.12'
+    compile 'com.android.support:appcompat-v7:24.1.1'
+    compile 'com.squareup.retrofit2:retrofit:2.0.1'
+    compile 'com.squareup.retrofit2:converter-gson:2.0.1'
+    compile 'com.squareup.okhttp3:logging-interceptor:3.0.1'
+    compile 'com.jakewharton:butterknife:8.2.1'
+    apt 'com.jakewharton:butterknife-compiler:8.2.1'
+}

app/proguard-rules.pro

+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /home/chaukadev/Android/Sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

app/src/main/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.vsoft.uofl_catalogue">
+
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+
+    <application
+        android:name=".CatalogueApplication"
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+        <activity
+            android:name=".ui.LoginScreen"
+            android:label="@string/app_name"
+            android:screenOrientation="portrait"
+            android:windowSoftInputMode="stateHidden|adjustResize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ui.HomeScreen"
+            android:screenOrientation="portrait"/>
+        <activity
+            android:name=".ui.CatalogueScreen"
+            android:screenOrientation="portrait"/>
+        <activity
+            android:name=".ui.CatalogueItemScreen"
+            android:screenOrientation="portrait"/>
+        <activity
+            android:name=".ui.CatalogueVariableScreen"
+            android:screenOrientation="portrait"
+            android:windowSoftInputMode="stateHidden|adjustResize"/>
+    </application>
+
+</manifest>

app/src/main/java/com/vsoft/uofl_catalogue/CatalogueApplication.java

+package com.vsoft.uofl_catalogue;
+
+import android.app.Application;
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+
+import com.vsoft.uofl_catalogue.db.DBManager;
+
+public class CatalogueApplication extends Application {
+
+	private static DBManager sDBManager;
+	private ConnectivityManager mConMgr;
+	private static Context mContext;
+
+	@Override
+	public void onCreate() {
+		super.onCreate();
+
+		mContext = getApplicationContext();
+
+		/*Database is created*/
+		initializeDatabase();
+	}
+
+	public static Context getContext() {
+		return mContext;
+	}
+
+	/*DataBase is created*/
+	public void initializeDatabase() {
+		if(sDBManager == null) {
+			sDBManager = new DBManager(this);
+			sDBManager.getWritableDatabase();
+		}
+	}
+
+	public static SQLiteDatabase getDatabase() {
+		if(sDBManager != null) {
+			return sDBManager.getWritableDatabase();
+		}
+		return null;
+	}
+
+	public boolean isNetConnected() {
+		if(mConMgr==null)
+			mConMgr = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
+		NetworkInfo netInfo = mConMgr.getActiveNetworkInfo();
+		return netInfo != null && netInfo.isConnected();
+	}
+}

app/src/main/java/com/vsoft/uofl_catalogue/adapters/CatalogueCategoryAdapter.java

+package com.vsoft.uofl_catalogue.adapters;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by kunj on 11/8/16.
+ */
+public class CatalogueCategoryAdapter extends BaseAdapter {
+    private Context mContext;
+    private final List<Catalogue> mCatalogueList = new ArrayList<>(0);
+    private LayoutInflater mInflater;
+
+    public CatalogueCategoryAdapter(Context context) {
+        mContext = context;
+        mInflater = (LayoutInflater) mContext
+                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    public void setCatalogueList(List<Catalogue> catalogueList) {
+        mCatalogueList.clear();
+        if(catalogueList!=null)
+            mCatalogueList.addAll(catalogueList);
+        notifyDataSetChanged();
+    }
+
+    @Override
+    public int getCount() {
+        // TODO Auto-generated method stub
+        return mCatalogueList.size();
+    }
+
+    @Override
+    public Catalogue getItem(int position) {
+        // TODO Auto-generated method stub
+        return mCatalogueList.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+        // TODO Auto-generated method stub
+        return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        // TODO Auto-generated method stub
+
+        ViewHolder holder;
+
+        if (convertView == null) {
+            convertView = mInflater.inflate(R.layout.catalogue_category_adapter, parent, false);
+            holder = new ViewHolder();
+            holder.titleTextView = (TextView) convertView.findViewById(R.id.catalogue_category_adapter_title_tv);
+            holder.desTextView = (TextView) convertView.findViewById(R.id.catalogue_category_adapter_des_tv);
+            convertView.setTag(holder);
+        } else {
+            holder = (ViewHolder) convertView.getTag();
+        }
+
+        Catalogue catalogue = mCatalogueList.get(position);
+        holder.titleTextView.setText(catalogue.getTitle());
+        holder.desTextView.setText(catalogue.getDescription());
+
+        return convertView;
+    }
+
+    static class ViewHolder {
+        private TextView titleTextView;
+        private TextView desTextView;
+        private ImageView imageView;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/adapters/CatalogueCategoryItemAdapter.java

+package com.vsoft.uofl_catalogue.adapters;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by kunj on 11/8/16.
+ */
+public class CatalogueCategoryItemAdapter extends BaseAdapter {
+    private Context mContext;
+    private final List<CatalogueItem> mCatalogueItemList = new ArrayList<>(0);
+    private LayoutInflater mInflater;
+
+    public CatalogueCategoryItemAdapter(Context context) {
+        mContext = context;
+        mInflater = (LayoutInflater) mContext
+                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    public void setCatalogueList(List<CatalogueItem> catalogueList) {
+        mCatalogueItemList.clear();
+        if(catalogueList!=null)
+            mCatalogueItemList.addAll(catalogueList);
+        notifyDataSetChanged();
+    }
+
+    @Override
+    public int getCount() {
+        // TODO Auto-generated method stub
+        return mCatalogueItemList.size();
+    }
+
+    @Override
+    public CatalogueItem getItem(int position) {
+        // TODO Auto-generated method stub
+        return mCatalogueItemList.get(position);
+    }
+
+    @Override
+    public long getItemId(int position) {
+        // TODO Auto-generated method stub
+        return position;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        // TODO Auto-generated method stub
+
+        ViewHolder holder;
+
+        if (convertView == null) {
+            convertView = mInflater.inflate(R.layout.catalogue_category_item_adapter, parent, false);
+            holder = new ViewHolder();
+            holder.nameTextView = (TextView) convertView.findViewById(R.id.catalogue_category_item_adapter_name_tv);
+            holder.desTextView = (TextView) convertView.findViewById(R.id.catalogue_category_item_adapter_des_tv);
+            convertView.setTag(holder);
+        } else {
+            holder = (ViewHolder) convertView.getTag();
+        }
+
+        CatalogueItem catalogueItem = mCatalogueItemList.get(position);
+        holder.nameTextView.setText(catalogueItem.getName());
+        holder.desTextView.setText(catalogueItem.getShortDescription());
+
+        return convertView;
+    }
+
+    static class ViewHolder {
+        private TextView nameTextView;
+        private TextView desTextView;
+        private ImageView imageView;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/adapters/HomeScreenAdapter.java

+package com.vsoft.uofl_catalogue.adapters;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.R;
+
+/**
+ * Created by kunj on 18/8/16.
+ */
+public class HomeScreenAdapter extends BaseAdapter {
+
+    private final LayoutInflater mInflater;
+    private final String[] mGridValues;
+
+    //Constructor to initialize values
+    public HomeScreenAdapter(Context mContext, String[ ] mGridValues) {
+        this.mGridValues = mGridValues;
+        mInflater = (LayoutInflater) mContext
+                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    @Override
+    public int getCount() {
+        // Number of times getView method call depends upon mGridValues.length
+        return mGridValues.length;
+    }
+
+    @Override
+    public String getItem(int position) {
+        return mGridValues[position];
+    }
+
+    @Override
+    public long getItemId(int position) {
+        return position;
+    }
+
+    // Number of times getView method call depends upon mGridValues.length
+    public View getView(int position, View convertView, ViewGroup parent) {
+        ViewHolder holder;
+
+        if (convertView == null) {
+            convertView = mInflater.inflate(R.layout.home_screen_adapter, parent, false);
+            holder = new ViewHolder();
+            holder.textview = (TextView) convertView.findViewById(R.id.home_screen_adapter_text_view);
+            convertView.setTag(holder);
+        } else {
+            holder = (ViewHolder) convertView.getTag();
+        }
+
+        String value = mGridValues[position];
+        holder.textview.setText(value);
+
+        return convertView;
+    }
+
+    static class ViewHolder {
+        private TextView textview;
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/GsonStringConverterFactory.java

+package com.vsoft.uofl_catalogue.api;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+import retrofit2.Converter;
+import retrofit2.Retrofit;
+
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+
+public class GsonStringConverterFactory extends Converter.Factory {
+    private static final MediaType MEDIA_TYPE = MediaType.parse("application/json");
+
+    @Override
+    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
+        if(String.class.equals(type)) {
+            return new Converter<String, RequestBody>() {
+                @Override
+                public RequestBody convert(String value) throws IOException {
+                    return RequestBody.create(MEDIA_TYPE, value);
+                }
+            };
+        }
+
+        return super.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit);
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/api/RestClient.java

+package com.vsoft.uofl_catalogue.api;
+
+import android.text.TextUtils;
+import android.util.Base64;
+import com.vsoft.uofl_catalogue.utils.Constants;
+import java.io.IOException;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.logging.HttpLoggingInterceptor;
+import retrofit2.Retrofit;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+
+public class RestClient {
+    public static Retrofit getInitializedRestAdapter(final String accessToken) {
+        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
+
+        Interceptor interceptor = new Interceptor() {
+            @Override
+            public Response intercept(Chain chain) {
+                Request original = chain.request();
+                Request.Builder requestBuilder = original.newBuilder();
+                if(!TextUtils.isEmpty(accessToken)) {
+                    final String bearer = "Bearer " + accessToken;
+                    requestBuilder.header(Constants.API_HEADER_PARAM_AUTHORIZATION, bearer);
+                }
+
+                requestBuilder.header("Accept", "application/json");
+                requestBuilder.header("Content-Type", "application/json");
+                requestBuilder.method(original.method(), original.body());
+
+                Request request = requestBuilder.build();
+                try {
+                    return chain.proceed(request);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return null;
+            }
+        };
+
+        httpClient.interceptors().add(interceptor);
+
+        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
+        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
+        httpClient.interceptors().add(logging);
+
+        Retrofit.Builder builder = new Retrofit.Builder()
+                .baseUrl(Constants.DOMAIN)
+                .client(httpClient.build())
+                .addConverterFactory(new GsonStringConverterFactory())
+                .addConverterFactory(GsonConverterFactory.create());
+        return builder.build();
+    }
+
+    public static Retrofit getInitializedRestAdapter(String username, String password) {
+
+        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
+        // set your desired log level
+        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
+        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
+        String credentials = username + ":" + password;
+        final String basic =
+                "Basic " + Base64.encodeToString(credentials.getBytes(), Base64.NO_WRAP);
+        // add your other interceptors
+        Interceptor interceptor = new Interceptor() {
+            @Override
+            public Response intercept(Chain chain) {
+                Request original = chain.request();
+
+                Request.Builder requestBuilder = original.newBuilder()
+                        .header(Constants.API_HEADER_PARAM_AUTHORIZATION, basic);
+                requestBuilder.header("Accept", "application/json");
+                requestBuilder.header("Content-Type", "application/json");
+                requestBuilder.method(original.method(), original.body());
+                Request request = requestBuilder.build();
+                try {
+                    return chain.proceed(request);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return null;
+            }
+        };
+
+        httpClient.interceptors().add(interceptor);
+
+        // add logging as last interceptor
+        httpClient.interceptors().add(logging);  // <-- this is the important line!
+        Retrofit.Builder builder = new Retrofit.Builder()
+                .baseUrl(Constants.DOMAIN)
+                .client(httpClient.build())
+                .addConverterFactory(new GsonStringConverterFactory())
+                .addConverterFactory(GsonConverterFactory.create());
+        return builder.build();
+    }
+
+    public static Retrofit getInitializedRestAdapterWithOutHeader(String username, String password) {
+
+        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
+        // set your desired log level
+        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
+        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
+        String credentials = username + ":" + password;
+        final String basic =
+                "Basic " + Base64.encodeToString(credentials.getBytes(), Base64.NO_WRAP);
+        // add your other interceptors
+        Interceptor interceptor = new Interceptor() {
+            @Override
+            public Response intercept(Chain chain) {
+                Request original = chain.request();
+
+                Request.Builder requestBuilder = original.newBuilder()
+                        .header(Constants.API_HEADER_PARAM_AUTHORIZATION, basic);
+                requestBuilder.method(original.method(), original.body());
+                Request request = requestBuilder.build();
+                try {
+                    return chain.proceed(request);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return null;
+            }
+        };
+
+        httpClient.interceptors().add(interceptor);
+
+        // add logging as last interceptor
+        httpClient.interceptors().add(logging);  // <-- this is the important line!
+        Retrofit.Builder builder = new Retrofit.Builder()
+                .baseUrl(Constants.DOMAIN)
+                .client(httpClient.build())
+                .addConverterFactory(new GsonStringConverterFactory())
+                .addConverterFactory(GsonConverterFactory.create());
+        return builder.build();
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/interfaces/CatalogueApi.java

+package com.vsoft.uofl_catalogue.api.interfaces;
+
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.db.models.Reference;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import okhttp3.ResponseBody;
+import retrofit2.Call;
+import retrofit2.http.Body;
+import retrofit2.http.GET;
+import retrofit2.http.POST;
+import retrofit2.http.Query;
+import retrofit2.http.Url;
+
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16.
+ *
+ */
+public interface CatalogueApi {
+    // Get Catalogue API
+    @GET(Constants.URL_GET_CATALOGUE)
+    Call<ResponseBody> getCatalogue(@Query(Constants.URL_PARAM_SYSPRM_QUERY) String sysparmQuery,
+                                    @Query(Constants.URL_PARAM_SYSPRM_FIELDS) String sysParmFields);
+
+    // Get Catalogue Item API
+    @GET(Constants.URL_GET_CATALOGUE_ITEM)
+    Call<ResponseBody> getCatalogueItem(@Query(Constants.URL_PARAM_SYSPRM_QUERY) String sysparmQuery,
+                                        @Query(Constants.URL_PARAM_SYSPRM_FIELDS) String sysParmFields);
+
+    // Get Variable API
+    @GET(Constants.URL_GET_VARIABLE)
+    Call<ResponseBody> getVariable(@Query(CatalogueVariable.Json.SYS_ID) String sysId);
+
+    // Get Variable Choices API
+    @GET(Constants.URL_GET_VARIABLE_CHOICE)
+    Call<ResponseBody> getVariableChoice(@Query(Constants.URL_PARAM_SYSPRM_QUERY) String sysparmQuery,
+                                         @Query(Constants.URL_PARAM_SYSPRM_FIELDS) String sysParmFields);
+
+    // Post catalogue item API
+    @POST(Constants.URL_POST_CATALOGUE_ITEM)
+    Call<ResponseBody> postCatalogueItem(@Query(CatalogueItem.Json.SYS_ID) String sysId,
+                                         @Body String catalogueItemJson);
+
+    // Get Reference API
+    @GET
+    Call<ResponseBody> getReference(@Url String url, @Query(Reference.Json.FIRST_NAME) String firstName);
+
+ }
+
+

app/src/main/java/com/vsoft/uofl_catalogue/api/listeners/get/GetCatalogueApiListener.java

+package com.vsoft.uofl_catalogue.api.listeners.get;
+
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+
+import java.util.List;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16
+ *
+ */
+public interface GetCatalogueApiListener {
+    void onDoneApiCall(List<Catalogue> catalogueList);
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/listeners/get/GetCatalogueItemApiListener.java

+package com.vsoft.uofl_catalogue.api.listeners.get;
+
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+
+import java.util.List;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16
+ *
+ */
+public interface GetCatalogueItemApiListener {
+    void onDoneApiCall(List<CatalogueItem> catalogueItemList);
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/listeners/get/GetCatalogueVariableApiListener.java

+package com.vsoft.uofl_catalogue.api.listeners.get;
+
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+
+import java.util.List;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16
+ *
+ */
+public interface GetCatalogueVariableApiListener {
+    void onDoneApiCall(List<CatalogueVariable> catalogueVariableList);
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/listeners/get/GetReferenceApiListener.java

+package com.vsoft.uofl_catalogue.api.listeners.get;
+
+import com.vsoft.uofl_catalogue.db.models.Reference;
+
+import java.util.List;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16
+ *
+ */
+public interface GetReferenceApiListener {
+    void onDoneApiCall(List<Reference> referenceList);
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/listeners/get/GetVariableChoiceApiListener.java

+package com.vsoft.uofl_catalogue.api.listeners.get;
+
+import com.vsoft.uofl_catalogue.db.models.VariableChoice;
+
+import java.util.List;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16
+ *
+ */
+public interface GetVariableChoiceApiListener {
+    void onDoneApiCall(List<VariableChoice> variableChoiceList);
+}

app/src/main/java/com/vsoft/uofl_catalogue/api/managers/CatalogueApiManager.java

+package com.vsoft.uofl_catalogue.api.managers;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.vsoft.uofl_catalogue.api.RestClient;
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+import com.vsoft.uofl_catalogue.api.interfaces.CatalogueApi;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueApiListener;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import okhttp3.ResponseBody;
+import retrofit2.Call;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+public class CatalogueApiManager {
+
+    public static SyncStatus getCatalogues(GetCatalogueApiListener listener) {
+        CatalogueLog.d("CatalogueApiManager: getCatalogues: ");
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(Catalogue.Json.URL_PARAM_CATALOGUE_SYSPRM_QUERY_VALUE);
+        stringBuilder.append("=e0d08b13c3330100c8b837659bba8fb4");
+        stringBuilder.append("^active=true");
+        CatalogueLog.d("CatalogueApiManager: getCatalogues: request parameter: "+stringBuilder.toString());
+
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).getCatalogue(stringBuilder.toString(), "sys_id,title,description");
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                try {
+                    JSONObject jsonObject = new JSONObject(response.body().string());
+                    JSONObject error = jsonObject.optJSONObject(Constants.RESPONSE_ERROR_OBJECT_NAME);
+                    if (error == null) {
+                        JSONArray catalogueJsonArray = jsonObject.getJSONArray(Constants.RESPONSE_RESULT_OBJECT_NAME);
+                        if(catalogueJsonArray.length() > 0) {
+                            Gson gson = new GsonBuilder()
+                                    .excludeFieldsWithoutExposeAnnotation()
+                                    .registerTypeAdapter(long.class, new JsonDeserializer<Long>() {
+                                        @Override
+                                        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            long value = 0;
+                                            try {
+                                                value = json.getAsLong();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueApiManager: getCatalogues: deserialize: long.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
+                                        @Override
+                                        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            int value = 0;
+                                            try {
+                                                value = json.getAsInt();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueApiManager: getCatalogues: deserialize: int.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(float.class, new JsonDeserializer<Float>() {
+                                        @Override
+                                        public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            float value = 0;
+                                            try {
+                                                value = json.getAsFloat();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.e("CatalogueApiManager: getCatalogues: deserialize: float.class: NumberFormatException: ", e);
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .create();
+
+                            List<Catalogue> catalogueList = new ArrayList<>(catalogueJsonArray.length());
+                            for (int i = 0; i < catalogueJsonArray.length(); i++) {
+                                JSONObject expenseJsonObject = catalogueJsonArray.getJSONObject(i);
+                                Catalogue catalogue = gson.fromJson(expenseJsonObject.toString(), Catalogue.class);
+                                catalogueList.add(catalogue);
+                            }
+                            listener.onDoneApiCall(catalogueList);
+                        } else {
+                            listener.onDoneApiCall(new ArrayList<Catalogue>(0));
+                        }
+                    return SyncStatus.SUCCESS;
+                } else
+                    return SyncStatus.FAIL;
+                } catch (JSONException e) {
+                    CatalogueLog.e("CatalogueApiManager: getCatalogues: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                } catch (IOException e) {
+                    CatalogueLog.e("CatalogueApiManager: getCatalogues: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                }
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("CatalogueApiManager: getCatalogues: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e) {
+            CatalogueLog.e("CatalogueApiManager: getCatalogues: NullPointerException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/api/managers/CatalogueItemApiManager.java

+package com.vsoft.uofl_catalogue.api.managers;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.vsoft.uofl_catalogue.api.RestClient;
+import com.vsoft.uofl_catalogue.api.interfaces.CatalogueApi;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueItemApiListener;
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import okhttp3.ResponseBody;
+import retrofit2.Call;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+public class CatalogueItemApiManager {
+
+    public static SyncStatus getCatalogueItems(String catalogueSysId, GetCatalogueItemApiListener listener) {
+        CatalogueLog.d("CatalogueItemApiManager: getCatalogueItems: ");
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(CatalogueItem.Json.URL_PARAM_CATALOGUE_SYSPRM_QUERY_VALUE);
+        stringBuilder.append("=");
+        stringBuilder.append(catalogueSysId);
+        CatalogueLog.d("CatalogueItemApiManager: getCatalogueItems: request parameter: "+stringBuilder.toString());
+
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).getCatalogueItem(stringBuilder.toString(), "sys_id,short_description,name,description");
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                try {
+                    JSONObject jsonObject = new JSONObject(response.body().string());
+                    JSONObject error = jsonObject.optJSONObject(Constants.RESPONSE_ERROR_OBJECT_NAME);
+                    if (error == null) {
+                        JSONArray catalogueItemJsonArray = jsonObject.getJSONArray(Constants.RESPONSE_RESULT_OBJECT_NAME);
+                        if(catalogueItemJsonArray.length() > 0) {
+                            Gson gson = new GsonBuilder()
+                                    .excludeFieldsWithoutExposeAnnotation()
+                                    .registerTypeAdapter(long.class, new JsonDeserializer<Long>() {
+                                        @Override
+                                        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            long value = 0;
+                                            try {
+                                                value = json.getAsLong();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueItemApiManager: getCatalogueItems: deserialize: long.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
+                                        @Override
+                                        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            int value = 0;
+                                            try {
+                                                value = json.getAsInt();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueItemApiManager: getCatalogueItems: deserialize: int.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(float.class, new JsonDeserializer<Float>() {
+                                        @Override
+                                        public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            float value = 0;
+                                            try {
+                                                value = json.getAsFloat();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.e("CatalogueItemApiManager: getCatalogueItems: deserialize: float.class: NumberFormatException: ", e);
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .create();
+
+                            List<CatalogueItem> catalogueItemList = new ArrayList<>(catalogueItemJsonArray.length());
+                            for (int i = 0; i < catalogueItemJsonArray.length(); i++) {
+                                JSONObject expenseJsonObject = catalogueItemJsonArray.getJSONObject(i);
+                                CatalogueItem catalogueItem = gson.fromJson(expenseJsonObject.toString(), CatalogueItem.class);
+                                catalogueItemList.add(catalogueItem);
+                            }
+                            listener.onDoneApiCall(catalogueItemList);
+                        } else {
+                            listener.onDoneApiCall(new ArrayList<CatalogueItem>(0));
+                        }
+                    return SyncStatus.SUCCESS;
+                } else
+                    return SyncStatus.FAIL;
+                } catch (JSONException e) {
+                    CatalogueLog.e("CatalogueItemApiManager: getCatalogueItems: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                } catch (IOException e) {
+                    CatalogueLog.e("CatalogueItemApiManager: getCatalogueItems: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                }
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("CatalogueItemApiManager: getCatalogueItems: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e) {
+            CatalogueLog.e("CatalogueItemApiManager: getCatalogueItems: NullPointerException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+
+    public static SyncStatus submitCatalogueItem(String catalogueItemSysId, JSONArray catalogueJsonArray) {
+        CatalogueLog.d("submitCatalogueItem: " + catalogueJsonArray);
+        String expenseJsonString = catalogueJsonArray.toString();
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).postCatalogueItem(catalogueItemSysId, expenseJsonString);
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                return SyncStatus.SUCCESS;
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("CatalogueItemApiManager: submitCatalogueItem: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e){
+            CatalogueLog.e("CatalogueItemApiManager: submitCatalogueItem: IOException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/api/managers/CatalogueVariableApiManager.java

+package com.vsoft.uofl_catalogue.api.managers;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.vsoft.uofl_catalogue.api.RestClient;
+import com.vsoft.uofl_catalogue.api.interfaces.CatalogueApi;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueVariableApiListener;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import okhttp3.ResponseBody;
+import retrofit2.Call;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+public class CatalogueVariableApiManager {
+
+    public static SyncStatus getCatalogueVariable(String catalogueItemSysId, GetCatalogueVariableApiListener listener) {
+        CatalogueLog.d("CatalogueVariableApiManager: getCatalogueVariable: ");
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).getVariable(catalogueItemSysId);
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                try {
+                    JSONObject jsonObject = new JSONObject(response.body().string());
+                    JSONObject error = jsonObject.optJSONObject(Constants.RESPONSE_ERROR_OBJECT_NAME);
+                    if (error == null) {
+                        JSONArray catalogueVariableJsonArray = jsonObject.getJSONArray(Constants.RESPONSE_RESULT_OBJECT_NAME);
+                        if(catalogueVariableJsonArray.length() > 0) {
+                            Gson gson = new GsonBuilder()
+                                    .excludeFieldsWithoutExposeAnnotation()
+                                    .registerTypeAdapter(long.class, new JsonDeserializer<Long>() {
+                                        @Override
+                                        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            long value = 0;
+                                            try {
+                                                value = json.getAsLong();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueVariableApiManager: getCatalogueVariable: deserialize: long.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
+                                        @Override
+                                        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            int value = 0;
+                                            try {
+                                                value = json.getAsInt();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("CatalogueVariableApiManager: getCatalogueVariable: deserialize: int.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(float.class, new JsonDeserializer<Float>() {
+                                        @Override
+                                        public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            float value = 0;
+                                            try {
+                                                value = json.getAsFloat();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.e("CatalogueVariableApiManager: getCatalogueVariable: deserialize: float.class: NumberFormatException: ", e);
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .create();
+
+                            List<CatalogueVariable> catalogueVariableList = new ArrayList<>(catalogueVariableJsonArray.length());
+                            for (int i = 0; i < catalogueVariableJsonArray.length(); i++) {
+                                JSONObject variableJsonObject = catalogueVariableJsonArray.getJSONObject(i);
+                                CatalogueVariable catalogueVariable = gson.fromJson(variableJsonObject.toString(), CatalogueVariable.class);
+                                catalogueVariable.parseJson(variableJsonObject);
+//                                if(catalogueVariable.getName()!=null)
+                                    catalogueVariableList.add(catalogueVariable);
+                            }
+                            listener.onDoneApiCall(catalogueVariableList);
+                        } else {
+                            listener.onDoneApiCall(new ArrayList<CatalogueVariable>(0));
+                        }
+                    return SyncStatus.SUCCESS;
+                } else
+                    return SyncStatus.FAIL;
+                } catch (JSONException e) {
+                    CatalogueLog.e("CatalogueVariableApiManager: getCatalogueVariable: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                } catch (IOException e) {
+                    CatalogueLog.e("CatalogueVariableApiManager: getCatalogueVariable: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                }
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("CatalogueVariableApiManager: getCatalogueVariable: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e) {
+            CatalogueLog.e("CatalogueVariableApiManager: getCatalogueVariable: NullPointerException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/api/managers/VariableChoiceApiManager.java

+package com.vsoft.uofl_catalogue.api.managers;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.vsoft.uofl_catalogue.api.RestClient;
+import com.vsoft.uofl_catalogue.api.interfaces.CatalogueApi;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetReferenceApiListener;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetVariableChoiceApiListener;
+import com.vsoft.uofl_catalogue.db.models.Reference;
+import com.vsoft.uofl_catalogue.db.models.VariableChoice;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import okhttp3.ResponseBody;
+import retrofit2.Call;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+/**
+ * @author Kunj on 11/8/16.
+ *
+ */
+public class VariableChoiceApiManager {
+
+    public static SyncStatus getVariableChoice(String variableSysId, GetVariableChoiceApiListener listener) {
+        CatalogueLog.d("VariableChoiceApiManager: getVariableChoice: ");
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(VariableChoice.Json.URL_PARAM_VARIABLE_CHOICE_SYSPRM_QUERY_VALUE);
+        stringBuilder.append("=");
+        stringBuilder.append(variableSysId);
+        CatalogueLog.d("VariableChoiceApiManager: getVariableChoice: request parameter: "+stringBuilder.toString());
+
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).getVariableChoice(stringBuilder.toString(), "text,value,order,misc");
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                try {
+                    JSONObject jsonObject = new JSONObject(response.body().string());
+                    JSONObject error = jsonObject.optJSONObject(Constants.RESPONSE_ERROR_OBJECT_NAME);
+                    if (error == null) {
+                        JSONArray variableChoiceJsonArray = jsonObject.getJSONArray(Constants.RESPONSE_RESULT_OBJECT_NAME);
+                        if(variableChoiceJsonArray.length() > 0) {
+                            Gson gson = new GsonBuilder()
+                                    .excludeFieldsWithoutExposeAnnotation()
+                                    .registerTypeAdapter(long.class, new JsonDeserializer<Long>() {
+                                        @Override
+                                        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            long value = 0;
+                                            try {
+                                                value = json.getAsLong();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("VariableChoiceApiManager: getVariableChoice: deserialize: long.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
+                                        @Override
+                                        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            int value = 0;
+                                            try {
+                                                value = json.getAsInt();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("VariableChoiceApiManager: getVariableChoice: deserialize: int.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(float.class, new JsonDeserializer<Float>() {
+                                        @Override
+                                        public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            float value = 0;
+                                            try {
+                                                value = json.getAsFloat();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.e("VariableChoiceApiManager: getVariableChoice: deserialize: float.class: NumberFormatException: ", e);
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .create();
+
+                            List<VariableChoice> variableChoiceItemList = new ArrayList<>(variableChoiceJsonArray.length());
+                            for (int i = 0; i < variableChoiceJsonArray.length(); i++) {
+                                JSONObject variableChoiceJsonObject = variableChoiceJsonArray.getJSONObject(i);
+                                VariableChoice variableChoice = gson.fromJson(variableChoiceJsonObject.toString(), VariableChoice.class);
+                                variableChoiceItemList.add(variableChoice);
+                            }
+                            listener.onDoneApiCall(variableChoiceItemList);
+                        } else {
+                            listener.onDoneApiCall(new ArrayList<VariableChoice>(0));
+                        }
+                    return SyncStatus.SUCCESS;
+                } else
+                    return SyncStatus.FAIL;
+                } catch (JSONException e) {
+                    CatalogueLog.e("VariableChoiceApiManager: getVariableChoice: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                } catch (IOException e) {
+                    CatalogueLog.e("VariableChoiceApiManager: getVariableChoice: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                }
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("VariableChoiceApiManager: getVariableChoice: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e) {
+            CatalogueLog.e("VariableChoiceApiManager: getVariableChoice: NullPointerException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+
+    public static SyncStatus getReference(String tableName, String firstName, GetReferenceApiListener listener) {
+        CatalogueLog.d("VariableChoiceApiManager: getReference: tableName: "+tableName);
+
+        final Retrofit retrofit = RestClient.getInitializedRestAdapter(Constants.API_AUTH_PARAM_USER_NAME, Constants.API_AUTH_PARAM_PASSWORD);
+        Call<ResponseBody> call = retrofit.create(CatalogueApi.class).getReference(Constants.URL_GET_REFERENCE + tableName, firstName);
+        try {
+            //Retrofit synchronous call
+            Response<ResponseBody> response = call.execute();
+            if (response.isSuccessful()) {
+                try {
+                    JSONObject jsonObject = new JSONObject(response.body().string());
+                    JSONObject error = jsonObject.optJSONObject(Constants.RESPONSE_ERROR_OBJECT_NAME);
+                    if (error == null) {
+                        JSONArray referenceJsonArray = jsonObject.getJSONArray(Constants.RESPONSE_RESULT_OBJECT_NAME);
+                        if(referenceJsonArray.length() > 0) {
+                            Gson gson = new GsonBuilder()
+                                    .excludeFieldsWithoutExposeAnnotation()
+                                    .registerTypeAdapter(long.class, new JsonDeserializer<Long>() {
+                                        @Override
+                                        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            long value = 0;
+                                            try {
+                                                value = json.getAsLong();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("VariableChoiceApiManager: getReference: deserialize: long.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
+                                        @Override
+                                        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            int value = 0;
+                                            try {
+                                                value = json.getAsInt();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.d("VariableChoiceApiManager: getReference: deserialize: int.class: NumberFormatException: ");
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .registerTypeAdapter(float.class, new JsonDeserializer<Float>() {
+                                        @Override
+                                        public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+                                            float value = 0;
+                                            try {
+                                                value = json.getAsFloat();
+                                            } catch (NumberFormatException e) {
+                                                CatalogueLog.e("VariableChoiceApiManager: getReference: deserialize: float.class: NumberFormatException: ", e);
+                                            }
+                                            return value;
+                                        }
+                                    })
+                                    .create();
+
+                            List<Reference> referenceList = new ArrayList<>(referenceJsonArray.length());
+                            for (int i = 0; i < referenceJsonArray.length(); i++) {
+                                JSONObject referenceJsonObject = referenceJsonArray.getJSONObject(i);
+                                Reference reference = gson.fromJson(referenceJsonObject.toString(), Reference.class);
+                                referenceList.add(reference);
+                            }
+                            listener.onDoneApiCall(referenceList);
+                        } else {
+                            listener.onDoneApiCall(new ArrayList<Reference>(0));
+                        }
+                        return SyncStatus.SUCCESS;
+                    } else
+                        return SyncStatus.FAIL;
+                } catch (JSONException e) {
+                    CatalogueLog.e("VariableChoiceApiManager: getReference: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                } catch (IOException e) {
+                    CatalogueLog.e("VariableChoiceApiManager: getReference: onResponse: ", e);
+                    return SyncStatus.FAIL;
+                }
+            } else {
+                return SyncStatus.FAIL;
+            }
+        } catch (IOException e) {
+            CatalogueLog.e("VariableChoiceApiManager: getReference: IOException: ", e);
+            return SyncStatus.FAIL;
+        } catch (NullPointerException e) {
+            CatalogueLog.e("VariableChoiceApiManager: getReference: NullPointerException: ", e);
+            return SyncStatus.FAIL;
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/DBManager.java

+package com.vsoft.uofl_catalogue.db;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.preference.PreferenceManager;
+
+import com.vsoft.uofl_catalogue.utils.Constants;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+/**
+ *
+ * @author Kunj on 11-08-2016.
+ */
+public class DBManager extends SQLiteOpenHelper implements DBConstants {
+
+    private static final String DATABASE_NAME = "uofl.db";
+    private static final int DATABASE_VERSION = 1;
+    private Context mContext;
+
+    public DBManager(Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+        mContext = context;
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        createCatalogueTable(db);
+        createCatalogueItemsTable(db);
+        createVariableTable(db);
+        createVariableChoiceTable(db);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
+        editor.putInt(Constants.PREFS_OLD_VERSION_NUMBER, oldVersion);
+        editor.putInt(Constants.PREFS_NEW_VERSION_NUMBER, newVersion);
+        editor.apply();
+
+        onCreate(db);
+    }
+
+    private void createCatalogueTable(SQLiteDatabase db) {
+        db.execSQL("create table " + TABLE_CATALOGUE + "("
+                + CATALOGUE_ID + " integer primary key autoincrement, "
+                + CATALOGUE_TITLE + " text, "
+                + CATALOGUE_DESCRIPTION + " text, "
+                + CATALOGUE_SYS_ID + " text, "
+                + CATALOGUE_SYNC_DIRTY + " integer default " + SYNC_FLAG_NONE
+                + ");");
+    }
+
+    private void createCatalogueItemsTable(SQLiteDatabase db) {
+        db.execSQL("create table " + TABLE_CATALOGUE_ITEM + "("
+                + CATALOGUE_ITEM_ID + " integer primary key autoincrement, "
+                + CATALOGUE_ITEM_CATALOGUE_ID + " integer default -1, "
+                + CATALOGUE_ITEM_NAME + " integer, "
+                + CATALOGUE_ITEM_SHORT_DESCRIPTION + " text, "
+                + CATALOGUE_ITEM_DESCRIPTION + " text, "
+                + CATALOGUE_ITEM_SYS_ID + " text, "
+                + CATALOGUE_ITEM_SYNC_DIRTY + " integer default " + SYNC_FLAG_NONE
+                + ");");
+    }
+
+    private void createVariableTable(SQLiteDatabase db) {
+        db.execSQL("create table " + TABLE_CATALOGUE_VARIABLES + "("
+                + CATALOGUE_VARIABLE_ID + " integer primary key autoincrement, "
+                + CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID + " integer default -1, "
+                + CATALOGUE_VARIABLE_NAME + " text, "
+                + CATALOGUE_VARIABLE_QUESTION_TEXT + " text, "
+                + CATALOGUE_VARIABLE_TYPE + " integer, "
+                + CATALOGUE_VARIABLE_MANDATORY + " integer, "
+                + CATALOGUE_VARIABLE_NONE_REQUIRED + " integer, "
+                + CATALOGUE_VARIABLE_REFERENCE_TABLE + " text, "
+                + CATALOGUE_VARIABLE_SYS_ID + " text, "
+                + CATALOGUE_VARIABLE_SYNC_DIRTY + " integer default " + SYNC_FLAG_NONE
+                + ");");
+    }
+
+    private void createVariableChoiceTable(SQLiteDatabase db) {
+        db.execSQL("create table " + TABLE_VARIABLE_CHOICES + "("
+                + VARIABLE_CHOICE_ID + " integer primary key autoincrement, "
+                + VARIABLE_CHOICE_VARIABLE_ID + " integer default -1, "
+                + VARIABLE_CHOICE_TEXT + " text, "
+                + VARIABLE_CHOICE_VALUE + " integer, "
+                + VARIABLE_CHOICE_ORDER + " integer, "
+                + VARIABLE_CHOICE_MISC + " real);");
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/db/managers/CatalogueItemManager.java

+package com.vsoft.uofl_catalogue.db.managers;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+
+/**
+ * @author Kunj on 11-08-2016.
+ */
+public class CatalogueItemManager implements DBConstants {
+
+    public static long save(CatalogueItem catalogueItem, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogueItem.setSyncDirty(syncDirty);
+            long id = db.insert(TABLE_CATALOGUE_ITEM, null, getContentValues(catalogueItem));
+            catalogueItem.setId(id);
+            return id;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int delete(CatalogueItem catalogueItem) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            if (catalogueItem.getSysId() == null || catalogueItem.getSysId().isEmpty()) {
+                return db.delete(TABLE_CATALOGUE_ITEM, CATALOGUE_ITEM_ID + "=" + catalogueItem.getId(), null);
+            } else {
+                return update(catalogueItem, SYNC_FLAG_DELETE);
+            }
+        }
+        return -1;
+    }
+
+    public static int update(CatalogueItem catalogueItem, int syncDirty) {
+        return update(catalogueItem, null, syncDirty);
+    }
+
+    public static int update(CatalogueItem catalogueItem, List<String> column, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogueItem.setSyncDirty(syncDirty);
+            if (column == null || column.size() == 0) {
+                return db.update(TABLE_CATALOGUE_ITEM, getContentValues(catalogueItem), CATALOGUE_ITEM_ID + "=" + catalogueItem.getId(), null);
+            } else {
+                ContentValues contentValues = new ContentValues(column.size());
+                contentValues.put(CATALOGUE_SYNC_DIRTY, catalogueItem.getSyncDirty());
+                for (int i = 0; i < column.size(); i++) {
+                    String columnName = column.get(i);
+                    if (CATALOGUE_ITEM_NAME.equals(columnName)) {
+                        contentValues.put(CATALOGUE_ITEM_NAME, catalogueItem.getName());
+                    } else if (CATALOGUE_ITEM_CATALOGUE_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_ITEM_CATALOGUE_ID, catalogueItem.getCatalogueId());
+                    } else if (CATALOGUE_ITEM_SHORT_DESCRIPTION.equals(columnName)) {
+                        contentValues.put(CATALOGUE_ITEM_SHORT_DESCRIPTION, catalogueItem.getShortDescription());
+                    } else if (CATALOGUE_ITEM_DESCRIPTION.equals(columnName)) {
+                        contentValues.put(CATALOGUE_ITEM_DESCRIPTION, catalogueItem.getDescription());
+                    } else if (CATALOGUE_ITEM_SYS_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_ITEM_SYS_ID, catalogueItem.getSysId());
+                    }
+                }
+                return db.update(TABLE_CATALOGUE_ITEM, contentValues, CATALOGUE_ITEM_ID + "=" + catalogueItem.getId(), null);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    public static void handleGetCatalogueItem(long catalogueId, List<CatalogueItem> serverCatalogueItemList) {
+        if(serverCatalogueItemList != null && !serverCatalogueItemList.isEmpty()) {
+            /*catalogueItemSysIdMap contain all server response catalogueItem Sys Id*/
+            HashMap<String, Integer> catalogueItemSysIdMap = new HashMap<>(0);
+            Integer intObj = Integer.valueOf(1);
+            for (int i = 0; i < serverCatalogueItemList.size(); i++) {
+                String sysId = serverCatalogueItemList.get(i).getSysId();
+                catalogueItemSysIdMap.put(sysId, intObj);
+            }
+
+            /*localCatalogueItemList is contain all local Catalogues */
+            List<CatalogueItem> localCatalogueItemList = getAllCatalogueItems(catalogueId);
+            if (localCatalogueItemList != null && !localCatalogueItemList.isEmpty()) {
+                for (int i = 0; i < localCatalogueItemList.size(); i++) {
+                    CatalogueItem localCatalogueItem = localCatalogueItemList.get(i);
+                    String localCatalogueItemSysId = localCatalogueItem.getSysId();
+
+                    if (localCatalogueItemSysId != null
+                            && !localCatalogueItemSysId.isEmpty()
+                            && !catalogueItemSysIdMap.containsKey(localCatalogueItemSysId)) {
+                        //Update sys_id with empty string because required to delete locally
+                        localCatalogueItem.setSysId("");
+                        delete(localCatalogueItem);
+                    }
+                }
+            }
+
+            /*Check this catalogue is exist in local DB or not
+            * If doesn't exist in local, save it
+            * If exist in local, update the local item with data from server item.
+            * */
+            for (int i = 0; i < serverCatalogueItemList.size(); i++) {
+                CatalogueItem catalogueItem = serverCatalogueItemList.get(i);
+
+                CatalogueItem localCatalogueItem = getCatalogueItemFromSysId(catalogueItem.getSysId());
+                if (localCatalogueItem == null) {
+                    catalogueItem.setCatalogueId(catalogueId);
+                    save(catalogueItem, DBConstants.SYNC_FLAG_NONE);
+                } else {
+                    /*Update complete local Expense object with response Expense object*/
+                    catalogueItem.setCatalogueId(catalogueId);
+                    catalogueItem.setId(localCatalogueItem.getId());
+                    update(catalogueItem, DBConstants.SYNC_FLAG_NONE);
+                }
+            }
+        } else {
+            /*That means there is no CatalogueItem category in server response, then all local items should be deleted those are contain sys_id*/
+            /*localCatalogueItemList is contain all local Catalogues */
+            List<CatalogueItem> localCatalogueItemList = getAllCatalogueItems(catalogueId);
+            if (localCatalogueItemList != null && !localCatalogueItemList.isEmpty()) {
+                for (int i = 0; i < localCatalogueItemList.size(); i++) {
+                    CatalogueItem localCatalogueItem = localCatalogueItemList.get(i);
+                    String localCatalogueSysId = localCatalogueItem.getSysId();
+
+                    if (localCatalogueSysId != null
+                            && !localCatalogueSysId.isEmpty()) {
+                        //Update sys_id with empty string because required to delete locally
+                        localCatalogueItem.setSysId("");
+                        delete(localCatalogueItem);
+                    }
+                }
+            }
+        }
+    }
+
+    public static List<CatalogueItem> getAllCatalogueItems(long catalogueId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_ITEM
+                    + " where " + CATALOGUE_ITEM_CATALOGUE_ID + "=" + catalogueId
+                    + " and " + CATALOGUE_ITEM_SYNC_DIRTY + "!=" + DBConstants.SYNC_FLAG_DELETE, null);
+            ArrayList<CatalogueItem> catalogueItemList;
+            if (c.getCount() > 0) {
+                catalogueItemList = new ArrayList<>(c.getCount());
+                while (c.moveToNext()) {
+                    CatalogueItem.CatalogueItemBuilder builder = CatalogueItem.CatalogueItemBuilder.aCatalogueItem();
+                    fillAllCatalogueDetails(c, builder);
+                    catalogueItemList.add(builder.build());
+                }
+            } else {
+                catalogueItemList = new ArrayList<>(0);
+            }
+            c.close();
+            return catalogueItemList;
+        } else {
+            return new ArrayList<>(0);
+        }
+    }
+
+    public static CatalogueItem get(long catalogueItemId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueItem catalogueItem = null;
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_ITEM + " where " + CATALOGUE_ITEM_ID + "=" + catalogueItemId, null);
+            if (c.moveToFirst()) {
+                CatalogueItem.CatalogueItemBuilder builder = CatalogueItem.CatalogueItemBuilder.aCatalogueItem();
+                fillAllCatalogueDetails(c, builder);
+                catalogueItem = builder.build();
+            }
+            c.close();
+        }
+        return catalogueItem;
+    }
+
+    public static CatalogueItem getCatalogueItemFromSysId(String sysId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueItem catalogueItem = null;
+        if(db!=null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_ITEM + " where " + CATALOGUE_SYS_ID + "='" + sysId + "'", null);
+            if (c.moveToFirst()) {
+                CatalogueItem.CatalogueItemBuilder builder = CatalogueItem.CatalogueItemBuilder.aCatalogueItem();
+                fillAllCatalogueDetails(c, builder);
+                catalogueItem = builder.build();
+            }
+            c.close();
+        }
+        return catalogueItem;
+    }
+
+    private static void fillAllCatalogueDetails(Cursor c, CatalogueItem.CatalogueItemBuilder builder) {
+        builder.setId(c.getLong(INDEX_CATALOGUE_ITEM_ID));
+        builder.setCatalogueId(c.getLong(INDEX_CATALOGUE_ITEM_CATALOGUE_ID));
+        builder.setName(c.getString(INDEX_CATALOGUE_ITEM_NAME));
+        builder.setShortDescription(c.getString(INDEX_CATALOGUE_ITEM_SHORT_DESCRIPTION));
+        builder.setDescription(c.getString(INDEX_CATALOGUE_ITEM_DESCRIPTION));
+        builder.setSysId(c.getString(INDEX_CATALOGUE_ITEM_SYS_ID));
+        builder.setSyncDirty(c.getInt(INDEX_CATALOGUE_ITEM_SYNC_DIRTY));
+    }
+
+    private static ContentValues getContentValues(CatalogueItem catalogueItem) {
+        ContentValues cv = new ContentValues(CATALOGUE_ITEM_COLUMN_COUNT - 1);
+        cv.put(CATALOGUE_ITEM_CATALOGUE_ID, catalogueItem.getCatalogueId());
+        cv.put(CATALOGUE_ITEM_NAME, catalogueItem.getName());
+        cv.put(CATALOGUE_ITEM_SHORT_DESCRIPTION, catalogueItem.getShortDescription());
+        cv.put(CATALOGUE_ITEM_DESCRIPTION, catalogueItem.getDescription());
+        cv.put(CATALOGUE_ITEM_SYS_ID, catalogueItem.getSysId());
+        cv.put(CATALOGUE_ITEM_SYNC_DIRTY, catalogueItem.getSyncDirty());
+        return cv;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/managers/CatalogueManager.java

+package com.vsoft.uofl_catalogue.db.managers;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ *
+ * @author Kunj on 11-08-2016.
+ */
+public class CatalogueManager implements DBConstants {
+
+    public static long save(Catalogue catalogue, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogue.setSyncDirty(syncDirty);
+            long id = db.insert(TABLE_CATALOGUE, null, getContentValues(catalogue));
+            catalogue.setId(id);
+            return id;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int delete(Catalogue catalogue) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            if (catalogue.getSysId() == null || catalogue.getSysId().isEmpty()) {
+                return db.delete(TABLE_CATALOGUE, CATALOGUE_ID + "=" + catalogue.getId(), null);
+            } else {
+                return update(catalogue, SYNC_FLAG_DELETE);
+            }
+        }
+        return -1;
+    }
+
+    public static int update(Catalogue catalogue, int syncDirty) {
+        return update(catalogue, null, syncDirty);
+    }
+
+    public static int update(Catalogue catalogue, List<String> column, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogue.setSyncDirty(syncDirty);
+            if (column == null || column.size() == 0) {
+                return db.update(TABLE_CATALOGUE, getContentValues(catalogue), CATALOGUE_ID + "=" + catalogue.getId(), null);
+            } else {
+                ContentValues contentValues = new ContentValues(column.size());
+                contentValues.put(CATALOGUE_SYNC_DIRTY, catalogue.getSyncDirty());
+                for (int i = 0; i < column.size(); i++) {
+                    String columnName = column.get(i);
+                    if (CATALOGUE_TITLE.equals(columnName)) {
+                        contentValues.put(CATALOGUE_TITLE, catalogue.getTitle());
+                    } else if (CATALOGUE_DESCRIPTION.equals(columnName)) {
+                        contentValues.put(CATALOGUE_DESCRIPTION, catalogue.getDescription());
+                    } else if (CATALOGUE_SYS_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_SYS_ID, catalogue.getSysId());
+                    }
+                }
+                return db.update(TABLE_CATALOGUE, contentValues, CATALOGUE_ID + "=" + catalogue.getId(), null);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    public static void handleGetCatalogue(List<Catalogue> serverCatalogueList) {
+        if(serverCatalogueList != null && !serverCatalogueList.isEmpty()) {
+            /*catalogueSysIdMap contain all server response catalogues Sys Id*/
+            HashMap<String, Integer> catalogueSysIdMap = new HashMap<>(0);
+            Integer intObj = Integer.valueOf(1);
+            for (int i = 0; i < serverCatalogueList.size(); i++) {
+                String sysId = serverCatalogueList.get(i).getSysId();
+                catalogueSysIdMap.put(sysId, intObj);
+            }
+
+            /*localCatalogueList is contain all local Catalogues */
+            List<Catalogue> localCatalogueList = getAllCatalogues();
+            if (localCatalogueList != null && !localCatalogueList.isEmpty()) {
+                for (int i = 0; i < localCatalogueList.size(); i++) {
+                    Catalogue localCatalogue = localCatalogueList.get(i);
+                    String localCatalogueSysId = localCatalogue.getSysId();
+
+                    if (localCatalogueSysId != null
+                            && !localCatalogueSysId.isEmpty()
+                            && !catalogueSysIdMap.containsKey(localCatalogueSysId)) {
+                        //Update sys_id with empty string because required to delete locally
+                        localCatalogue.setSysId("");
+                        delete(localCatalogue);
+                    }
+                }
+            }
+
+            /*Check this catalogue is exist in local DB or not
+            * If doesn't exist in local, save it
+            * If exist in local, update the local item with data from server item.
+            * */
+            for (int i = 0; i < serverCatalogueList.size(); i++) {
+                Catalogue catalogue = serverCatalogueList.get(i);
+
+                Catalogue localCatalogue = getCatalogueFromSysId(catalogue.getSysId());
+                if (localCatalogue == null) {
+                    save(catalogue, DBConstants.SYNC_FLAG_NONE);
+                } else {
+                    /*Update complete local Catalogue object with response Catalogue object*/
+                    catalogue.setId(localCatalogue.getId());
+                    update(catalogue, DBConstants.SYNC_FLAG_NONE);
+                }
+            }
+        } else {
+            /*That means there is no Catalogue category in server response, then all local items should be deleted those are contain sys_id*/
+            /*localCatalogueList is contain all local Catalogues */
+            List<Catalogue> localCatalogueList = getAllCatalogues();
+            if (localCatalogueList != null && !localCatalogueList.isEmpty()) {
+                for (int i = 0; i < localCatalogueList.size(); i++) {
+                    Catalogue localCatalogue = localCatalogueList.get(i);
+                    String localCatalogueSysId = localCatalogue.getSysId();
+
+                    if (localCatalogueSysId != null
+                            && !localCatalogueSysId.isEmpty()) {
+                        //Update sys_id with empty string because required to delete locally
+                        localCatalogue.setSysId("");
+                        delete(localCatalogue);
+                    }
+                }
+            }
+        }
+    }
+
+    public static List<Catalogue> getAllCatalogues() {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE
+                                   + " where " + CATALOGUE_SYNC_DIRTY
+                                   + "!=" + DBConstants.SYNC_FLAG_DELETE, null);
+            ArrayList<Catalogue> catalogueList;
+            if (c.getCount() > 0) {
+                catalogueList = new ArrayList<>(c.getCount());
+                while (c.moveToNext()) {
+                    Catalogue.CatalogueBuilder builder = Catalogue.CatalogueBuilder.aCatalogue();
+                    fillAllCatalogueDetails(c, builder);
+                    catalogueList.add(builder.build());
+                }
+            } else {
+                catalogueList = new ArrayList<>(0);
+            }
+            c.close();
+            return catalogueList;
+        } else {
+            return new ArrayList<>(0);
+        }
+    }
+
+    public static Catalogue get(long catalogueId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        Catalogue catalogue = null;
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE + " where " + CATALOGUE_ID + "=" + catalogueId, null);
+            if (c.moveToFirst()) {
+                Catalogue.CatalogueBuilder builder = Catalogue.CatalogueBuilder.aCatalogue();
+                fillAllCatalogueDetails(c, builder);
+                catalogue = builder.build();
+            }
+            c.close();
+        }
+        return catalogue;
+    }
+
+    public static Catalogue getCatalogueFromSysId(String sysId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        Catalogue catalogue = null;
+        if(db!=null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE + " where " + CATALOGUE_SYS_ID + "='" + sysId + "'", null);
+            if (c.moveToFirst()) {
+                Catalogue.CatalogueBuilder builder = Catalogue.CatalogueBuilder.aCatalogue();
+                fillAllCatalogueDetails(c, builder);
+                catalogue = builder.build();
+            }
+            c.close();
+        }
+        return catalogue;
+    }
+
+    private static void fillAllCatalogueDetails(Cursor c, Catalogue.CatalogueBuilder builder) {
+        builder.setId(c.getLong(INDEX_CATALOGUE_ID));
+        builder.setTitle(c.getString(INDEX_CATALOGUE_TITLE));
+        builder.setDescription(c.getString(INDEX_CATALOGUE_DESCRIPTION));
+        builder.setSysId(c.getString(INDEX_CATALOGUE_SYS_ID));
+        builder.setSyncDirty(c.getInt(INDEX_CATALOGUE_SYNC_DIRTY));
+     }
+
+    private static ContentValues getContentValues(Catalogue catalogue) {
+        ContentValues cv = new ContentValues(CATALOGUE_COLUMN_COUNT - 1);
+        cv.put(CATALOGUE_TITLE, catalogue.getTitle());
+        cv.put(CATALOGUE_DESCRIPTION, catalogue.getDescription());
+        cv.put(CATALOGUE_SYS_ID, catalogue.getSysId());
+        cv.put(CATALOGUE_SYNC_DIRTY, catalogue.getSyncDirty());
+        return cv;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/managers/CatalogueVariableManager.java

+package com.vsoft.uofl_catalogue.db.managers;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.enums.ViewType;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ *
+ * @author Kunj on 11-08-2016.
+ */
+public class CatalogueVariableManager implements DBConstants {
+
+    public static long save(CatalogueVariable catalogueVariable, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogueVariable.setSyncDirty(syncDirty);
+            long id = db.insert(TABLE_CATALOGUE_VARIABLES, null, getContentValues(catalogueVariable));
+            catalogueVariable.setId(id);
+            return id;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int delete(CatalogueVariable catalogueVariable) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            if (catalogueVariable.getSysId() == null || catalogueVariable.getSysId().isEmpty()) {
+                return db.delete(TABLE_CATALOGUE_VARIABLES, CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            } else {
+                return update(catalogueVariable, SYNC_FLAG_DELETE);
+            }
+        }
+        return -1;
+    }
+
+    public static int update(CatalogueVariable catalogueVariable, int syncDirty) {
+        return update(catalogueVariable, null, syncDirty);
+    }
+
+    public static int update(CatalogueVariable catalogueVariable, List<String> column, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogueVariable.setSyncDirty(syncDirty);
+            if (column == null || column.size() == 0) {
+                return db.update(TABLE_CATALOGUE_VARIABLES, getContentValues(catalogueVariable), CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            } else {
+                ContentValues contentValues = new ContentValues(column.size());
+                contentValues.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+                for (int i = 0; i < column.size(); i++) {
+                    String columnName = column.get(i);
+                    if (CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID, catalogueVariable.getCatalogueItemId());
+                    } else if (CATALOGUE_VARIABLE_NAME.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_NAME, catalogueVariable.getName());
+                    } else if (CATALOGUE_VARIABLE_QUESTION_TEXT.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_QUESTION_TEXT, catalogueVariable.getQuestionText());
+                    } else if (CATALOGUE_VARIABLE_TYPE.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_TYPE, ViewType.getId(catalogueVariable.getType()));
+                    } else if (CATALOGUE_VARIABLE_MANDATORY.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_MANDATORY, catalogueVariable.isMandatory() ? 1 : 0);
+                    } else if (CATALOGUE_VARIABLE_NONE_REQUIRED.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_NONE_REQUIRED, catalogueVariable.isNoneRequired() ? 1 : 0);
+                    } else if (CATALOGUE_VARIABLE_REFERENCE_TABLE.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_REFERENCE_TABLE, catalogueVariable.getReferenceTable());
+                    } else if (CATALOGUE_VARIABLE_SYS_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_SYS_ID, catalogueVariable.getSysId());
+                    } else if (CATALOGUE_VARIABLE_SYNC_DIRTY.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+                    }
+                }
+                return db.update(TABLE_CATALOGUE_VARIABLES, contentValues, CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    public static void handleGetVariable(long catalogueItemId, List<CatalogueVariable> serverVariableList) {
+        if(serverVariableList != null && !serverVariableList.isEmpty()) {
+            /*variableSysIdMap contain all server response catalogues Sys Id*/
+            HashMap<String, Integer> variableSysIdMap = new HashMap<>(0);
+            Integer intObj = Integer.valueOf(1);
+            for (int i = 0; i < serverVariableList.size(); i++) {
+                String sysId = serverVariableList.get(i).getSysId();
+                variableSysIdMap.put(sysId, intObj);
+            }
+
+            /*localVariableList is contain all local Catalogues */
+            List<CatalogueVariable> localVariableList = getAllVariable(catalogueItemId);
+            if (localVariableList != null && !localVariableList.isEmpty()) {
+                for (int i = 0; i < localVariableList.size(); i++) {
+                    CatalogueVariable localVariable = localVariableList.get(i);
+                    String localVariableSysId = localVariable.getSysId();
+
+                    if (localVariableSysId != null
+                            && !localVariableSysId.isEmpty()
+                            && !variableSysIdMap.containsKey(localVariableSysId)) {
+                        //Update sys_id with empty string because required to delete locally
+                        localVariable.setSysId("");
+                        delete(localVariable);
+                    }
+                }
+            }
+
+            /*Check this catalogueVariable is exist in local DB or not
+            * If doesn't exist in local, save it
+            * If exist in local, update the local item with data from server item.
+            * */
+            for (int i = 0; i < serverVariableList.size(); i++) {
+                CatalogueVariable catalogueVariable = serverVariableList.get(i);
+
+                CatalogueVariable localVariable = getVariableFromSysId(catalogueVariable.getSysId());
+                if (localVariable == null) {
+                    catalogueVariable.setCatalogueItemId(catalogueItemId);
+                    save(catalogueVariable, DBConstants.SYNC_FLAG_NONE);
+                } else {
+                    /*Update complete local CatalogueVariable object with response CatalogueVariable object*/
+                    catalogueVariable.setId(localVariable.getId());
+                    catalogueVariable.setCatalogueItemId(catalogueItemId);
+                    update(catalogueVariable, DBConstants.SYNC_FLAG_NONE);
+                }
+            }
+        } else {
+            /*That means there is no CatalogueVariable in server response, then all local items should be deleted those are contain sys_id*/
+            /*localVariableList is contain all local Catalogues */
+            List<CatalogueVariable> localVariableList = getAllVariable(catalogueItemId);
+            if (localVariableList != null && !localVariableList.isEmpty()) {
+                for (int i = 0; i < localVariableList.size(); i++) {
+                    CatalogueVariable localVariable = localVariableList.get(i);
+                    String localVariableSysId = localVariable.getSysId();
+
+                    if (localVariableSysId != null
+                            && !localVariableSysId.isEmpty()) {
+                        //Update sys_id with empty string because required to delete locally
+                        localVariable.setSysId("");
+                        delete(localVariable);
+                    }
+                }
+            }
+        }
+    }
+
+    public static List<CatalogueVariable> getAllVariable(long catalogueItemId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES
+                    + " where " + CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID + "=" + catalogueItemId
+                    + " and " + CATALOGUE_VARIABLE_SYNC_DIRTY + "!=" + DBConstants.SYNC_FLAG_DELETE, null);
+            ArrayList<CatalogueVariable> variableList;
+            if (c.getCount() > 0) {
+                variableList = new ArrayList<>(c.getCount());
+                while (c.moveToNext()) {
+                    CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                    fillAllVariableDetails(c, builder);
+                    variableList.add(builder.build());
+                }
+            } else {
+                variableList = new ArrayList<>(0);
+            }
+            c.close();
+            return variableList;
+        } else {
+            return new ArrayList<>(0);
+        }
+    }
+
+    public static CatalogueVariable get(long catalogueId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueVariable catalogueVariable = null;
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES + " where " + CATALOGUE_VARIABLE_ID + "=" + catalogueId, null);
+            if (c.moveToFirst()) {
+                CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                fillAllVariableDetails(c, builder);
+                catalogueVariable = builder.build();
+            }
+            c.close();
+        }
+        return catalogueVariable;
+    }
+
+    public static CatalogueVariable getVariableFromSysId(String sysId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueVariable catalogueVariable = null;
+        if(db!=null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES + " where " + CATALOGUE_VARIABLE_SYS_ID + "='" + sysId + "'", null);
+            if (c.moveToFirst()) {
+                CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                fillAllVariableDetails(c, builder);
+                catalogueVariable = builder.build();
+            }
+            c.close();
+        }
+        return catalogueVariable;
+    }
+
+    private static void fillAllVariableDetails(Cursor c, CatalogueVariable.CatalogueVariableBuilder builder) {
+        builder.setId(c.getLong(INDEX_CATALOGUE_VARIABLE_ID));
+        builder.setCatalogueItemId(c.getLong(INDEX_CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID));
+        builder.setName(c.getString(INDEX_CATALOGUE_VARIABLE_NAME));
+        builder.setQuestionText(c.getString(INDEX_CATALOGUE_VARIABLE_QUESTION_TEXT));
+        builder.setType(ViewType.from(c.getInt(INDEX_CATALOGUE_VARIABLE_TYPE)));
+        builder.setMandatory(c.getInt(INDEX_CATALOGUE_VARIABLE_MANDATORY) == 1);
+        builder.setNoneRequired(c.getInt(INDEX_CATALOGUE_VARIABLE_NONE_REQUIRED) == 1);
+        builder.setReferenceTable(c.getString(INDEX_CATALOGUE_VARIABLE_REFERENCE));
+        builder.setSysId(c.getString(INDEX_CATALOGUE_VARIABLE_SYS_ID));
+        builder.setSyncDirty(c.getInt(INDEX_CATALOGUE_VARIABLE_SYNC_DIRTY));
+     }
+
+    private static ContentValues getContentValues(CatalogueVariable catalogueVariable) {
+        ContentValues cv = new ContentValues(CATALOGUE_VARIABLE_COLUMN_COUNT - 1);
+        cv.put(CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID, catalogueVariable.getCatalogueItemId());
+        cv.put(CATALOGUE_VARIABLE_NAME, catalogueVariable.getName());
+        cv.put(CATALOGUE_VARIABLE_QUESTION_TEXT, catalogueVariable.getQuestionText());
+        cv.put(CATALOGUE_VARIABLE_TYPE, catalogueVariable.getType().getId());
+        cv.put(CATALOGUE_VARIABLE_MANDATORY, catalogueVariable.isMandatory() ? 1 : 0);
+        cv.put(CATALOGUE_VARIABLE_NONE_REQUIRED, catalogueVariable.isNoneRequired() ? 1 : 0);
+        cv.put(CATALOGUE_VARIABLE_REFERENCE_TABLE, catalogueVariable.getReferenceTable());
+        cv.put(CATALOGUE_VARIABLE_SYS_ID, catalogueVariable.getSysId());
+        cv.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+        return cv;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/managers/CatalogueVariableValueManager.java

+package com.vsoft.uofl_catalogue.db.managers;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.enums.ViewType;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author Kunj on 11-08-2016.
+ */
+public class CatalogueVariableValueManager implements DBConstants {
+
+    public static long save(String tableName, List<String> columnNameList, List<String> valueList, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            ContentValues contentValues = new ContentValues(columnNameList.size());
+            contentValues.put(CATALOGUE_VARIABLE_SYNC_DIRTY, syncDirty);
+            for (int i = 0; i < columnNameList.size(); i++) {
+                String columnName = columnNameList.get(i);
+                String value = valueList.get(i);
+                if(columnName!=null && value!=null)
+                contentValues.put(columnName, value);
+            }
+            long id = db.insert(tableName, null, contentValues);
+            return id;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int delete(CatalogueVariable catalogueVariable) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            if (catalogueVariable.getSysId() == null || catalogueVariable.getSysId().isEmpty()) {
+                return db.delete(TABLE_CATALOGUE_VARIABLES, CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            } else {
+                return update(catalogueVariable, SYNC_FLAG_DELETE);
+            }
+        }
+        return -1;
+    }
+
+    public static int update(CatalogueVariable catalogueVariable, int syncDirty) {
+        return update(catalogueVariable, null, syncDirty);
+    }
+
+    public static int update(CatalogueVariable catalogueVariable, List<String> column, int syncDirty) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            catalogueVariable.setSyncDirty(syncDirty);
+            if (column == null || column.size() == 0) {
+                return db.update(TABLE_CATALOGUE_VARIABLES, getContentValues(catalogueVariable), CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            } else {
+                ContentValues contentValues = new ContentValues(column.size());
+                contentValues.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+                for (int i = 0; i < column.size(); i++) {
+                    String columnName = column.get(i);
+                    if (CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID, catalogueVariable.getCatalogueItemId());
+                    } else if (CATALOGUE_VARIABLE_NAME.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_NAME, catalogueVariable.getName());
+                    } else if (CATALOGUE_VARIABLE_QUESTION_TEXT.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_QUESTION_TEXT, catalogueVariable.getQuestionText());
+                    } else if (CATALOGUE_VARIABLE_TYPE.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_TYPE, ViewType.getId(catalogueVariable.getType()));
+                    } else if (CATALOGUE_VARIABLE_SYS_ID.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_SYS_ID, catalogueVariable.getSysId());
+                    } else if (CATALOGUE_VARIABLE_SYNC_DIRTY.equals(columnName)) {
+                        contentValues.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+                    }
+                }
+                return db.update(TABLE_CATALOGUE_VARIABLES, contentValues, CATALOGUE_VARIABLE_ID + "=" + catalogueVariable.getId(), null);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    public static List<CatalogueVariable> getAllVariable(long catalogueItemId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES
+                    + " where " + CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID + "=" + catalogueItemId
+                    + " and " + CATALOGUE_VARIABLE_SYNC_DIRTY + "!=" + DBConstants.SYNC_FLAG_DELETE, null);
+            ArrayList<CatalogueVariable> variableList;
+            if (c.getCount() > 0) {
+                variableList = new ArrayList<>(c.getCount());
+                while (c.moveToNext()) {
+                    CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                    fillAllVariableDetails(c, builder);
+                    variableList.add(builder.build());
+                }
+            } else {
+                variableList = new ArrayList<>(0);
+            }
+            c.close();
+            return variableList;
+        } else {
+            return new ArrayList<>(0);
+        }
+    }
+
+    public static CatalogueVariable get(long catalogueId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueVariable catalogueVariable = null;
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES + " where " + CATALOGUE_VARIABLE_ID + "=" + catalogueId, null);
+            if (c.moveToFirst()) {
+                CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                fillAllVariableDetails(c, builder);
+                catalogueVariable = builder.build();
+            }
+            c.close();
+        }
+        return catalogueVariable;
+    }
+
+    public static CatalogueVariable getVariableFromSysId(String sysId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        CatalogueVariable catalogueVariable = null;
+        if(db!=null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_CATALOGUE_VARIABLES + " where " + CATALOGUE_VARIABLE_SYS_ID + "='" + sysId + "'", null);
+            if (c.moveToFirst()) {
+                CatalogueVariable.CatalogueVariableBuilder builder = CatalogueVariable.CatalogueVariableBuilder.aCatalogueVariable();
+                fillAllVariableDetails(c, builder);
+                catalogueVariable = builder.build();
+            }
+            c.close();
+        }
+        return catalogueVariable;
+    }
+
+    private static void fillAllVariableDetails(Cursor c, CatalogueVariable.CatalogueVariableBuilder builder) {
+        builder.setId(c.getLong(INDEX_CATALOGUE_VARIABLE_ID));
+        builder.setCatalogueItemId(c.getLong(INDEX_CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID));
+        builder.setName(c.getString(INDEX_CATALOGUE_VARIABLE_NAME));
+        builder.setQuestionText(c.getString(INDEX_CATALOGUE_VARIABLE_QUESTION_TEXT));
+        builder.setType(ViewType.from(c.getInt(INDEX_CATALOGUE_VARIABLE_TYPE)));
+        builder.setSysId(c.getString(INDEX_CATALOGUE_VARIABLE_SYS_ID));
+        builder.setSyncDirty(c.getInt(INDEX_CATALOGUE_VARIABLE_SYNC_DIRTY));
+     }
+
+    private static ContentValues getContentValues(CatalogueVariable catalogueVariable) {
+        ContentValues cv = new ContentValues(CATALOGUE_VARIABLE_COLUMN_COUNT - 1);
+        cv.put(CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID, catalogueVariable.getCatalogueItemId());
+        cv.put(CATALOGUE_VARIABLE_NAME, catalogueVariable.getName());
+        cv.put(CATALOGUE_VARIABLE_QUESTION_TEXT, catalogueVariable.getQuestionText());
+        cv.put(CATALOGUE_VARIABLE_TYPE, catalogueVariable.getType().getId());
+        cv.put(CATALOGUE_VARIABLE_SYS_ID, catalogueVariable.getSysId());
+        cv.put(CATALOGUE_VARIABLE_SYNC_DIRTY, catalogueVariable.getSyncDirty());
+        return cv;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/managers/VariableChoiceManager.java

+package com.vsoft.uofl_catalogue.db.managers;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.db.models.VariableChoice;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * @author Kunj on 11-08-2016.
+ */
+public class VariableChoiceManager implements DBConstants {
+
+    public static long save(VariableChoice variableChoice) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            long id = db.insert(TABLE_VARIABLE_CHOICES, null, getContentValues(variableChoice));
+            variableChoice.setId(id);
+            return id;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int delete(VariableChoice variableChoice) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            return db.delete(TABLE_VARIABLE_CHOICES, VARIABLE_CHOICE_ID + "=" + variableChoice.getId(), null);
+        }
+        return -1;
+    }
+
+    public static void deleteAll(long variableId) {
+        List<VariableChoice> localVariableChoiceList = getAllVariableChoices(variableId);
+        if(!localVariableChoiceList.isEmpty()) {
+            SQLiteDatabase db = CatalogueApplication.getDatabase();
+            if (db != null) {
+                for (int i = 0; i < localVariableChoiceList.size(); i++) {
+                    delete(localVariableChoiceList.get(i));
+                }
+            }
+        }
+    }
+
+    public static void handleGetVariableChoice(long variableId, List<VariableChoice> serverVariableChoiceList) {
+        if(serverVariableChoiceList != null && !serverVariableChoiceList.isEmpty()) {
+            /*First delete all existing variable choice for particular variable then we will save*/
+            deleteAll(variableId);
+
+            for (int i = 0; i < serverVariableChoiceList.size(); i++) {
+                VariableChoice variableChoice = serverVariableChoiceList.get(i);
+
+                variableChoice.setVariableId(variableId);
+                save(variableChoice);
+            }
+        } else {
+            /*That means there is no VariableChoice in server response,
+             *then all local items should be deleted those are contain that variable id*/
+            /*localVariableChoiceList is contain all local Catalogues */
+            deleteAll(variableId);
+        }
+    }
+
+    public static List<VariableChoice> getAllVariableChoices(long variableId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_VARIABLE_CHOICES
+                    + " where " + VARIABLE_CHOICE_VARIABLE_ID + "=" + variableId
+                    + " ORDER BY " + VARIABLE_CHOICE_ORDER + " ASC", null);
+            ArrayList<VariableChoice> variableChoiceList;
+            if (c.getCount() > 0) {
+                variableChoiceList = new ArrayList<>(c.getCount());
+                while (c.moveToNext()) {
+                    VariableChoice.VariableChoiceBuilder builder = VariableChoice.VariableChoiceBuilder.aVariableChoice();
+                    fillAllVariableChoiceDetails(c, builder);
+                    variableChoiceList.add(builder.build());
+                }
+            } else {
+                variableChoiceList = new ArrayList<>(0);
+            }
+            c.close();
+            return variableChoiceList;
+        } else {
+            return new ArrayList<>(0);
+        }
+    }
+
+    public static VariableChoice get(long variableChoiceId) {
+        SQLiteDatabase db = CatalogueApplication.getDatabase();
+
+        VariableChoice variableChoice = null;
+        if (db != null) {
+            Cursor c = db.rawQuery("select * from " + TABLE_VARIABLE_CHOICES + " where " + VARIABLE_CHOICE_ID + "=" + variableChoiceId, null);
+            if (c.moveToFirst()) {
+                VariableChoice.VariableChoiceBuilder builder = VariableChoice.VariableChoiceBuilder.aVariableChoice();
+                fillAllVariableChoiceDetails(c, builder);
+                variableChoice = builder.build();
+            }
+            c.close();
+        }
+        return variableChoice;
+    }
+
+    private static void fillAllVariableChoiceDetails(Cursor c, VariableChoice.VariableChoiceBuilder builder) {
+        builder.setId(c.getLong(INDEX_VARIABLE_CHOICE_ID));
+        builder.setVariableId((c.getLong(INDEX_VARIABLE_CHOICE_VARIABLE_ID)));
+        builder.setText(c.getString(INDEX_VARIABLE_CHOICE_TEXT));
+        builder.setValue(c.getString(INDEX_VARIABLE_CHOICE_VALUE));
+        builder.setOrder(c.getInt(INDEX_VARIABLE_CHOICE_ORDER));
+        builder.setMisc(c.getFloat(INDEX_VARIABLE_CHOICE_MISC));
+    }
+
+    private static ContentValues getContentValues(VariableChoice variableChoice) {
+        ContentValues cv = new ContentValues(VARIABLE_CHOICE_COLUMN_COUNT - 1);
+        cv.put(VARIABLE_CHOICE_VARIABLE_ID, variableChoice.getVariableId());
+        cv.put(VARIABLE_CHOICE_TEXT, variableChoice.getText());
+        cv.put(VARIABLE_CHOICE_VALUE, variableChoice.getValue());
+        cv.put(VARIABLE_CHOICE_ORDER, variableChoice.getOrder());
+        cv.put(VARIABLE_CHOICE_MISC, variableChoice.getMisc());
+        return cv;
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/db/models/Catalogue.java

+package com.vsoft.uofl_catalogue.db.models;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class Catalogue {
+
+    private long id = -1;
+
+    @SerializedName("title")
+    @Expose
+    private String title;
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("sys_id")
+    @Expose
+    private String sysId;
+
+    private int syncDirty;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    /**
+     *
+     * @return
+     *     The title
+     */
+    public String getTitle() {
+        return title;
+    }
+
+    /**
+     *
+     * @param title
+     *     The title
+     */
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    /**
+     *
+     * @return
+     *     The description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     *
+     * @param description
+     *     The description
+     */
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    /**
+     *
+     * @return
+     *     The sysId
+     */
+    public String getSysId() {
+        return sysId;
+    }
+
+    /**
+     *
+     * @param sysId
+     *     The sys_id
+     */
+    public void setSysId(String sysId) {
+        this.sysId = sysId;
+    }
+
+    public int getSyncDirty() {
+        return syncDirty;
+    }
+
+    public void setSyncDirty(int syncDirty) {
+        this.syncDirty = syncDirty;
+    }
+
+    public static final class CatalogueBuilder {
+        private long id = -1;
+        private String title;
+        private String description;
+        private String sysId;
+        private int syncDirty;
+
+        private CatalogueBuilder() {
+        }
+
+        public static CatalogueBuilder aCatalogue() {
+            return new CatalogueBuilder();
+        }
+
+        public CatalogueBuilder setId(long id) {
+            this.id = id;
+            return this;
+        }
+
+        public CatalogueBuilder setTitle(String title) {
+            this.title = title;
+            return this;
+        }
+
+        public CatalogueBuilder setDescription(String description) {
+            this.description = description;
+            return this;
+        }
+
+        public CatalogueBuilder setSysId(String sysId) {
+            this.sysId = sysId;
+            return this;
+        }
+
+        public CatalogueBuilder setSyncDirty(int syncDirty) {
+            this.syncDirty = syncDirty;
+            return this;
+        }
+
+        public CatalogueBuilder but() {
+            return aCatalogue().setId(id).setTitle(title).setDescription(description).setSysId(sysId).setSyncDirty(syncDirty);
+        }
+
+        public Catalogue build() {
+            Catalogue catalogue = new Catalogue();
+            catalogue.setId(id);
+            catalogue.setTitle(title);
+            catalogue.setDescription(description);
+            catalogue.setSysId(sysId);
+            catalogue.setSyncDirty(syncDirty);
+            return catalogue;
+        }
+    }
+
+    public static class Json {
+        public static final String URL_PARAM_CATALOGUE_SYSPRM_QUERY_VALUE = "sc_catalog";
+    }
+
+    @Override
+    public String toString() {
+        return "Catalogue{" +
+                "id=" + id +
+                ", title='" + title + '\'' +
+                ", description='" + description + '\'' +
+                ", sysId='" + sysId + '\'' +
+                ", syncDirty=" + syncDirty +
+                '}';
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/db/models/CatalogueItem.java

+package com.vsoft.uofl_catalogue.db.models;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class CatalogueItem {
+
+    private long id = -1;
+    private long catalogue_id = -1;
+
+    @SerializedName("short_description")
+    @Expose
+    private String shortDescription;
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("name")
+    @Expose
+    private String name;
+    @SerializedName("sys_id")
+    @Expose
+    private String sysId;
+    private int syncDirty;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public long getCatalogueId() {
+        return catalogue_id;
+    }
+
+    public void setCatalogueId(long catalogueId) {
+        this.catalogue_id = catalogueId;
+    }
+
+    /**
+     *
+     * @return
+     *     The shortDescription
+     */
+    public String getShortDescription() {
+        return shortDescription;
+    }
+
+    /**
+     *
+     * @param shortDescription
+     *     The short_description
+     */
+    public void setShortDescription(String shortDescription) {
+        this.shortDescription = shortDescription;
+    }
+
+    /**
+     *
+     * @return
+     *     The description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     *
+     * @param description
+     *     The description
+     */
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    /**
+     *
+     * @return
+     *     The name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     *
+     * @param name
+     *     The name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     *
+     * @return
+     *     The sysId
+     */
+    public String getSysId() {
+        return sysId;
+    }
+
+    /**
+     *
+     * @param sysId
+     *     The sys_id
+     */
+    public void setSysId(String sysId) {
+        this.sysId = sysId;
+    }
+
+    public int getSyncDirty() {
+        return syncDirty;
+    }
+
+    public void setSyncDirty(int syncDirty) {
+        this.syncDirty = syncDirty;
+    }
+
+
+    public static final class CatalogueItemBuilder {
+        private long id = -1;
+        private long catalogue_id = -1;
+        private String shortDescription;
+        private String description;
+        private String name;
+        private String sysId;
+        private int syncDirty;
+
+        private CatalogueItemBuilder() {
+        }
+
+        public static CatalogueItemBuilder aCatalogueItem() {
+            return new CatalogueItemBuilder();
+        }
+
+        public CatalogueItemBuilder setId(long id) {
+            this.id = id;
+            return this;
+        }
+
+        public CatalogueItemBuilder setCatalogueId(long catalogueId) {
+            this.catalogue_id = catalogueId;
+            return this;
+        }
+
+        public CatalogueItemBuilder setShortDescription(String shortDescription) {
+            this.shortDescription = shortDescription;
+            return this;
+        }
+
+        public CatalogueItemBuilder setDescription(String description) {
+            this.description = description;
+            return this;
+        }
+
+        public CatalogueItemBuilder setName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public CatalogueItemBuilder setSysId(String sysId) {
+            this.sysId = sysId;
+            return this;
+        }
+
+        public CatalogueItemBuilder setSyncDirty(int syncDirty) {
+            this.syncDirty = syncDirty;
+            return this;
+        }
+
+        public CatalogueItemBuilder but() {
+            return aCatalogueItem().setId(id).setCatalogueId(catalogue_id).setShortDescription(shortDescription).setDescription(description).setName(name).setSysId(sysId).setSyncDirty(syncDirty);
+        }
+
+        public CatalogueItem build() {
+            CatalogueItem catalogueItem = new CatalogueItem();
+            catalogueItem.setId(id);
+            catalogueItem.setCatalogueId(catalogue_id);
+            catalogueItem.setShortDescription(shortDescription);
+            catalogueItem.setDescription(description);
+            catalogueItem.setName(name);
+            catalogueItem.setSysId(sysId);
+            catalogueItem.setSyncDirty(syncDirty);
+            return catalogueItem;
+        }
+    }
+
+    public static class Json {
+        public static final String URL_PARAM_CATALOGUE_SYSPRM_QUERY_VALUE = "category";
+        public static final String SYS_ID = "sys_id";
+    }
+
+    @Override
+    public String toString() {
+        return "CatalogueItem{" +
+                "id=" + id +
+                ", catalogue_id=" + catalogue_id +
+                ", shortDescription='" + shortDescription + '\'' +
+                ", description='" + description + '\'' +
+                ", name='" + name + '\'' +
+                ", sysId='" + sysId + '\'' +
+                ", syncDirty=" + syncDirty +
+                '}';
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/db/models/CatalogueVariable.java

+package com.vsoft.uofl_catalogue.db.models;
+
+import android.content.Context;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.enums.ViewType;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.List;
+
+
+/**
+ * Created by Kunj on 12/8/16.
+ */
+public class CatalogueVariable {
+    private long id = -1;
+    private long catalogue_item_id = -1;
+
+    @SerializedName("name")
+    @Expose
+    private String name;
+    @SerializedName("question_text")
+    @Expose
+    private String questionText;
+    @SerializedName("sys_id")
+    @Expose
+    private String sysId;
+    @SerializedName("mandatory")
+    @Expose
+    private boolean mandatory;
+    @SerializedName("none_required")
+    @Expose
+    private boolean isNoneRequired;
+    @SerializedName("reference_table")
+    @Expose
+    private String referenceTable;
+
+//    @SerializedName("type")
+//    @Expose
+    private ViewType type;
+
+    private int syncDirty;
+    private List<VariableChoice> mVariableChoiceList;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public long getCatalogueItemId() {
+        return catalogue_item_id;
+    }
+
+    public void setCatalogueItemId(long catalogue_item_id) {
+        this.catalogue_item_id = catalogue_item_id;
+    }
+
+    /**
+     *
+     * @return
+     *     The name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     *
+     * @param name
+     *     The name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     *
+     * @return
+     *     The questionText
+     */
+    public String getQuestionText() {
+        return questionText;
+    }
+
+    /**
+     *
+     * @param questionText
+     *     The question_text
+     */
+    public void setQuestionText(String questionText) {
+        this.questionText = questionText;
+    }
+
+    /**
+     *
+     * @return
+     *     The sysId
+     */
+    public String getSysId() {
+        return sysId;
+    }
+
+    /**
+     *
+     * @param sysId
+     *     The sys_id
+     */
+    public void setSysId(String sysId) {
+        this.sysId = sysId;
+    }
+
+    /**
+     *
+     * @return
+     *     The type
+     */
+    public ViewType getType() {
+        return type;
+    }
+
+    /**
+     *
+     * @param type
+     *     The type
+     */
+    public void setType(ViewType type) {
+        this.type = type;
+    }
+
+    public boolean isMandatory() {
+        return mandatory;
+    }
+
+    public void setMandatory(boolean mandatory) {
+        this.mandatory = mandatory;
+    }
+
+    public boolean isNoneRequired() {
+        return isNoneRequired;
+    }
+
+    public void setNoneRequired(boolean noneRequired) {
+        isNoneRequired = noneRequired;
+    }
+
+    public String getReferenceTable() {
+        return referenceTable;
+    }
+
+    public void setReferenceTable(String referenceTable) {
+        this.referenceTable = referenceTable;
+    }
+
+    public int getSyncDirty() {
+        return syncDirty;
+    }
+
+    public void setSyncDirty(int syncDirty) {
+        this.syncDirty = syncDirty;
+    }
+
+    public List<VariableChoice> getVariableChoiceList() {
+        return mVariableChoiceList;
+    }
+
+    public void setVariableChoiceList(List<VariableChoice> mVariableChoiceList) {
+        this.mVariableChoiceList = mVariableChoiceList;
+    }
+
+    public String[] getDisplayChoiceText(Context context, boolean isNoneRequired) {
+        String[] choiceText;
+        if(isNoneRequired) {
+            choiceText = new String[mVariableChoiceList.size() + 1];
+            choiceText[0] = context.getString(R.string.none_string);
+            for (int i = 0; i < mVariableChoiceList.size(); i++) {
+                VariableChoice variableChoice = mVariableChoiceList.get(i);
+                /*(i+1) for add None text as a first Element*/
+                if(variableChoice.getMisc() > 0) {
+                    choiceText[i + 1] = String.format(context.getString(R.string.variable_form_misc_info_string),
+                            variableChoice.getText(),
+                            variableChoice.getMisc());
+                } else {
+                    choiceText[i + 1] = variableChoice.getText();
+                }
+            }
+        } else {
+            choiceText = new String[mVariableChoiceList.size()];
+            for (int i = 0; i < mVariableChoiceList.size(); i++) {
+                VariableChoice variableChoice = mVariableChoiceList.get(i);
+                if(variableChoice.getMisc() > 0) {
+                    choiceText[i] = String.format(context.getString(R.string.variable_form_misc_info_string),
+                            variableChoice.getText(),
+                            variableChoice.getMisc());
+                } else {
+                    choiceText[i] = variableChoice.getText();
+                }
+            }
+        }
+        return choiceText;
+    }
+
+    public void parseJson(JSONObject jsonObject) {
+        String viewType = null;
+        try {
+            viewType = jsonObject.getString(Json.TYPE);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+
+        this.setType(ViewType.from(viewType));
+    }
+
+    public static final class CatalogueVariableBuilder {
+        private long id = -1;
+        private long catalogue_item_id = -1;
+        private String name;
+        private String questionText;
+        private String sysId;
+        private boolean mandatory;
+        private boolean isNoneRequired;
+        private String referenceTable;
+        private ViewType type;
+        private int syncDirty;
+
+        private CatalogueVariableBuilder() {
+        }
+
+        public static CatalogueVariableBuilder aCatalogueVariable() {
+            return new CatalogueVariableBuilder();
+        }
+
+        public CatalogueVariableBuilder setId(long id) {
+            this.id = id;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setCatalogueItemId(long catalogue_item_id) {
+            this.catalogue_item_id = catalogue_item_id;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setQuestionText(String questionText) {
+            this.questionText = questionText;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setSysId(String sysId) {
+            this.sysId = sysId;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setMandatory(boolean mandatory) {
+            this.mandatory = mandatory;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setNoneRequired(boolean isNoneRequired) {
+            this.isNoneRequired = isNoneRequired;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setReferenceTable(String referenceTable) {
+            this.referenceTable = referenceTable;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setType(ViewType type) {
+            this.type = type;
+            return this;
+        }
+
+        public CatalogueVariableBuilder setSyncDirty(int syncDirty) {
+            this.syncDirty = syncDirty;
+            return this;
+        }
+
+        public CatalogueVariableBuilder but() {
+            return aCatalogueVariable().setId(id).setCatalogueItemId(catalogue_item_id).setName(name).setQuestionText(questionText).setSysId(sysId).setMandatory(mandatory).setNoneRequired(isNoneRequired).setReferenceTable(referenceTable).setType(type).setSyncDirty(syncDirty);
+        }
+
+        public CatalogueVariable build() {
+            CatalogueVariable catalogueVariable = new CatalogueVariable();
+            catalogueVariable.setId(id);
+            catalogueVariable.setCatalogueItemId(catalogue_item_id);
+            catalogueVariable.setName(name);
+            catalogueVariable.setQuestionText(questionText);
+            catalogueVariable.setSysId(sysId);
+            catalogueVariable.setMandatory(mandatory);
+            catalogueVariable.setNoneRequired(isNoneRequired);
+            catalogueVariable.setReferenceTable(referenceTable);
+            catalogueVariable.setType(type);
+            catalogueVariable.setSyncDirty(syncDirty);
+            return catalogueVariable;
+        }
+    }
+
+    public static class Json {
+        public static final String SYS_ID = "sys_id";
+        public static final String TYPE = "type";
+    }
+
+    @Override
+    public String toString() {
+        return "CatalogueVariable{" +
+                "id=" + id +
+                ", catalogue_item_id=" + catalogue_item_id +
+                ", name='" + name + '\'' +
+                ", questionText='" + questionText + '\'' +
+                ", sysId='" + sysId + '\'' +
+                ", mandatory=" + mandatory +
+                ", isNoneRequired=" + isNoneRequired +
+                ", referenceTable='" + referenceTable + '\'' +
+                ", type=" + type +
+                ", syncDirty=" + syncDirty +
+                ", mVariableChoiceList=" + mVariableChoiceList +
+                '}';
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/db/models/Reference.java

+package com.vsoft.uofl_catalogue.db.models;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * Created by Kunj on 9/8/16.
+ */
+public class Reference {
+    @SerializedName("name")
+    @Expose
+    private String name;
+
+    @SerializedName("sys_id")
+    @Expose
+    private String sysId;
+
+    /**
+     *
+     * @return
+     *     The name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     *
+     * @param name
+     *     The name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     *
+     * @return
+     *     The sysId
+     */
+    public String getSysId() {
+        return sysId;
+    }
+
+    /**
+     *
+     * @param sysId
+     *     The name
+     */
+    public void setSysID(String sysId) {
+        this.sysId = sysId;
+    }
+
+    public static class Json {
+        public static final String FIRST_NAME = "first_name";
+    }
+}
+

app/src/main/java/com/vsoft/uofl_catalogue/db/models/VariableChoice.java

+
+package com.vsoft.uofl_catalogue.db.models;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class VariableChoice {
+
+    private long id;
+    private long variable_id;
+
+    @SerializedName("text")
+    @Expose
+    private String text;
+    @SerializedName("value")
+    @Expose
+    private String value;
+    @SerializedName("order")
+    @Expose
+    private int order;
+    @SerializedName("misc")
+    @Expose
+    private float misc;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public long getVariableId() {
+        return variable_id;
+    }
+
+    public void setVariableId(long variable_id) {
+        this.variable_id = variable_id;
+    }
+
+    /**
+     * 
+     * @return
+     *     The text
+     */
+    public String getText() {
+        return text;
+    }
+
+    /**
+     * 
+     * @param text
+     *     The text
+     */
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    /**
+     * 
+     * @return
+     *     The value
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * 
+     * @param value
+     *     The value
+     */
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     *
+     * @return
+     *     The order
+     */
+    public int getOrder() {
+        return order;
+    }
+
+    /**
+     *
+     * @param order
+     *     The order
+     */
+    public void setOrder(int order) {
+        this.order = order;
+    }
+
+    public float getMisc() {
+        return misc;
+    }
+
+    public void setMisc(float misc) {
+        this.misc = misc;
+    }
+
+    public static class Json {
+        public static final String URL_PARAM_VARIABLE_CHOICE_SYSPRM_QUERY_VALUE = "question";
+    }
+
+
+    public static final class VariableChoiceBuilder {
+        private long id;
+        private long variable_id;
+        private String text;
+        private String value;
+        private int order;
+        private float misc;
+
+        private VariableChoiceBuilder() {
+        }
+
+        public static VariableChoiceBuilder aVariableChoice() {
+            return new VariableChoiceBuilder();
+        }
+
+        public VariableChoiceBuilder setId(long id) {
+            this.id = id;
+            return this;
+        }
+
+        public VariableChoiceBuilder setVariableId(long variable_id) {
+            this.variable_id = variable_id;
+            return this;
+        }
+
+        public VariableChoiceBuilder setText(String text) {
+            this.text = text;
+            return this;
+        }
+
+        public VariableChoiceBuilder setValue(String value) {
+            this.value = value;
+            return this;
+        }
+
+        public VariableChoiceBuilder setOrder(int order) {
+            this.order = order;
+            return this;
+        }
+
+        public VariableChoiceBuilder setMisc(float misc) {
+            this.misc = misc;
+            return this;
+        }
+
+        public VariableChoiceBuilder but() {
+            return aVariableChoice().setId(id).setVariableId(variable_id).setText(text).setValue(value).setOrder(order).setMisc(misc);
+        }
+
+        public VariableChoice build() {
+            VariableChoice variableChoice = new VariableChoice();
+            variableChoice.setId(id);
+            variableChoice.setVariableId(variable_id);
+            variableChoice.setText(text);
+            variableChoice.setValue(value);
+            variableChoice.setOrder(order);
+            variableChoice.setMisc(misc);
+            return variableChoice;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "VariableChoice{" +
+                "id=" + id +
+                ", variable_id=" + variable_id +
+                ", text='" + text + '\'' +
+                ", value='" + value + '\'' +
+                ", order=" + order +
+                ", misc=" + misc +
+                '}';
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/dialog/SelectReferenceDialog.java

+package com.vsoft.uofl_catalogue.dialog;
+
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.inputmethod.EditorInfo;
+import android.widget.ArrayAdapter;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetReferenceApiListener;
+import com.vsoft.uofl_catalogue.api.managers.VariableChoiceApiManager;
+import com.vsoft.uofl_catalogue.db.models.Reference;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.listeners.ReferenceListener;
+import com.vsoft.uofl_catalogue.utils.Constants;
+import com.vsoft.uofl_catalogue.utils.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import butterknife.OnClick;
+import butterknife.OnEditorAction;
+import butterknife.OnItemClick;
+import butterknife.OnTouch;
+import butterknife.Unbinder;
+
+/**
+ * Created by Kunj on 25/2/16.
+ */
+public class SelectReferenceDialog extends DialogFragment {
+
+    @BindView(R.id.dialog_list_view) ListView mListView;
+    @BindView(R.id.dialog_title) TextView mTitleTextView;
+    @BindView(R.id.dialog_edit_text) EditText mEditText;
+
+    private ArrayAdapter<String> mAdapter;
+    private ReferenceListener mListener;
+    private Unbinder mUnbinder;
+    private List<Reference> mReferenceList;
+    private String mReferenceTableName;
+
+    public SelectReferenceDialog() {
+
+    }
+
+    public void setListener(ReferenceListener listener) {
+        mListener = listener;
+    }
+
+    public static SelectReferenceDialog newInstance(String tableName) {
+        SelectReferenceDialog selectReferenceDialog = new SelectReferenceDialog();
+
+        Bundle bundle = new Bundle();
+        bundle.putString(Constants.DATA_KEY_REFERENCE_TABLE_NAME, tableName);
+        selectReferenceDialog.setArguments(bundle);
+
+        return selectReferenceDialog;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setStyle(STYLE_NO_TITLE, R.style.CustomDialog);
+
+        mReferenceTableName = getArguments().getString(Constants.DATA_KEY_REFERENCE_TABLE_NAME);
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        Dialog dialog = getDialog();
+        if (dialog != null) {
+            int width = 4 * (getResources().getDisplayMetrics().widthPixels/5);
+            int height = 3 * (getResources().getDisplayMetrics().heightPixels/4);
+            dialog.getWindow().setLayout(width, height);
+        }
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View rootView = inflater.inflate(R.layout.custom_dialog, container, false);
+        mUnbinder = ButterKnife.bind(this, rootView);
+
+        return rootView;
+    }
+
+    @OnTouch(R.id.dialog_edit_text)
+    boolean onTouch(View v, MotionEvent event) {
+        final int DRAWABLE_RIGHT = 2;
+        Drawable drawable = mEditText.getCompoundDrawables()[DRAWABLE_RIGHT];
+        Rect bounds = drawable.getBounds();
+        if(event.getAction() == MotionEvent.ACTION_UP) {
+            if(event.getRawX() >= (mEditText.getRight() + mEditText.getLeft() - (bounds.width() / getResources().getDisplayMetrics().density))) {
+                mEditText.setText("");
+                return true;
+            } else {
+                return mEditText.onTouchEvent(event);
+            }
+        }
+        return true;
+    }
+
+    @OnClick(R.id.dialog_cancel_layout)
+    void cancelLayout() {
+        getDialog().dismiss();
+    }
+
+    @OnItemClick(R.id.dialog_list_view)
+    void listViewItemClick(int position) {
+        Reference reference = mReferenceList.get(position);
+        if(reference != null)
+            mListener.positiveButtonClick(reference);
+        else
+            mListener.negativeButtonClick();
+        getDialog().dismiss();
+    }
+
+    @OnEditorAction(R.id.dialog_edit_text) boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+        if(actionId == EditorInfo.IME_ACTION_SEARCH) {
+            Util.hideSoftKeyboard(getActivity(), v);
+            if(!mEditText.getText().toString().isEmpty()) {
+                new FetchReference().execute(mEditText.getText().toString());
+            }
+            return false;
+        }
+        return true;
+    }
+
+    class FetchReference extends AsyncTask<String, Void, SyncStatus> {
+        private ProgressDialog progressDialog;
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+            progressDialog = new ProgressDialog(getActivity());
+            progressDialog.setMessage(getString(R.string.loading_string));
+            progressDialog.show();
+            progressDialog.setCancelable(false);
+        }
+
+        @Override
+        protected SyncStatus doInBackground(String... params) {
+            return VariableChoiceApiManager.getReference(mReferenceTableName, params[0], new GetReferenceApiListener() {
+                @Override
+                public void onDoneApiCall(List<Reference> referenceList) {
+                    mReferenceList = referenceList;
+                }
+            });
+        }
+
+        @Override
+        protected void onPostExecute(SyncStatus syncStatus) {
+            super.onPostExecute(syncStatus);
+            if(progressDialog != null && progressDialog.isShowing()) {
+                progressDialog.dismiss();
+            }
+            mAdapter =  new ArrayAdapter(getActivity(),
+                                         android.R.layout.simple_list_item_1,
+                                         android.R.id.text1,
+                                         getReferenceForDisplay());
+            mListView.setAdapter(mAdapter);
+         }
+    }
+
+    private List<String> getReferenceForDisplay() {
+        List<String> stringList = new ArrayList<>(mReferenceList.size());
+        for (int i = 0; i < mReferenceList.size(); i++) {
+            stringList.add(mReferenceList.get(i).getName());
+        }
+        return stringList;
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+       mUnbinder.unbind();
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/enums/SyncStatus.java

+package com.vsoft.uofl_catalogue.enums;
+
+/**
+ * @since 1.0
+ * @author Kunj on 11/8/16.
+ *
+ */
+public enum SyncStatus {
+	SUCCESS (1),
+	FAIL (2);
+
+	int id;
+
+	SyncStatus(int id) {
+		this.id = id;
+	}
+	
+	public static int getSyncStatus(SyncStatus status) {
+		return status.id;
+	}
+	
+	public int getId() {
+		return this.id;
+	}
+}

app/src/main/java/com/vsoft/uofl_catalogue/enums/ViewType.java

+package com.vsoft.uofl_catalogue.enums;
+
+public enum ViewType {
+	UNKNOWN (-1, "unknown"),
+	YES_NO (0, "Yes / No"),
+	MULTI_LINE_TEXT (1, "Multi Line Text"),
+	MULTIPLE_CHOICE (2, "Multiple Choice"),
+	NUMERIC_SCALE (3, "Numeric Scale"),
+	SELECT_BOX (4, "Select Box"),
+	SINGLE_LINE_TEXT (5, "Single Line Text"),
+	CHECK_BOX(6, "CheckBox"),
+	REFERENCE(7, "Reference"),
+	DATE(8, "Date"),
+	DATE_AND_TIME(9, "Date/Time"),
+	LABEL (10, "Label"),
+	BREAK (11, "Break"),
+	MACRO (12, "Macro"),
+	UI_PAGE (13, "UI Page"),
+	WIDE_SINGLE_LINE_TEXT (14, "Wide Single Line Text"),
+	MACRO_WITH_LABEL (15, "Macro with Label"),
+	LOOKUP_SELECT_BOX (16, "Lookup Select Box"),
+	CONTAINER_START (17, "Container Start"),
+	CONTAINER_END(18, "Container End"),
+	LIST_COLLECTOR (19, "List Collector"),
+	LOOKUP_MULTIPLE_CHOICE (20, "Lookup Multiple Choice"),
+	HTML (21, "HTML"),
+	CONTAINER_SPLIT (22, "Container Split"),
+	MASKED (23, "Masked");
+
+	private int id;
+	private String displayString;
+
+	/* construct */
+	ViewType(int id, String displayString) {
+		this.id = id;
+		this.displayString = displayString;
+	}
+	
+	/* getters */
+	public static int getId(ViewType expenseType) {
+		return expenseType.id;
+	}
+	
+	public int getId() {
+		return this.id;
+	}
+	
+	public static String getDisplayString(ViewType expenseType) {
+		return expenseType.displayString;
+	}
+	
+	public String getDisplayString() {
+		return this.displayString;
+	}
+
+	public static ViewType from(int id) {
+		for(int i = 0; i< ViewType.values().length; i++) {
+			ViewType expenseType = ViewType.values()[i];
+			if(expenseType.id == id)
+				return ViewType.values()[i];
+		}
+		return UNKNOWN;
+	}
+
+	public static ViewType from(String string) {
+		for(int i = 0; i< ViewType.values().length; i++) {
+			ViewType expenseType = ViewType.values()[i];
+			if(expenseType.displayString.equals(string))
+				return ViewType.values()[i];
+		}
+		return UNKNOWN;
+	}
+}

app/src/main/java/com/vsoft/uofl_catalogue/listeners/ReferenceListener.java

+package com.vsoft.uofl_catalogue.listeners;
+
+import com.vsoft.uofl_catalogue.db.models.Reference;
+
+/**
+ * Created by Kunj on 10/8/16.
+ */
+public interface ReferenceListener {
+    void positiveButtonClick(Reference reference);
+    void negativeButtonClick();
+}

app/src/main/java/com/vsoft/uofl_catalogue/ui/CatalogueItemScreen.java

+package com.vsoft.uofl_catalogue.ui;
+
+import android.app.Activity;
+import android.app.ProgressDialog;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.adapters.CatalogueCategoryItemAdapter;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueItemApiListener;
+import com.vsoft.uofl_catalogue.api.managers.CatalogueItemApiManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueItemManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueManager;
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import java.util.List;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class CatalogueItemScreen extends Activity {
+
+    private Catalogue mCatalogue;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // TODO Auto-generated method stub
+        super.onCreate(savedInstanceState);
+
+        Bundle extras = getIntent().getExtras();
+        String catalogueSysId = null;
+        if (extras != null) {
+            catalogueSysId = extras.getString(Constants.DATA_KEY_SYS_ID);
+            //The key argument here must match that used in the other activity
+        }
+
+        mCatalogue = CatalogueManager.getCatalogueFromSysId(catalogueSysId);
+        if(mCatalogue == null) {
+            CatalogueLog.e("CatalogueItemScreen: onCreate: mCatalogue is null");
+            return;
+        }
+        List<CatalogueItem> catalogueItemList = CatalogueItemManager.getAllCatalogueItems(mCatalogue.getId());
+        if(catalogueItemList.isEmpty()) {
+            new FetchCatalogueItem().execute();
+        } else {
+            createView(catalogueItemList);
+        }
+
+    }
+
+    class FetchCatalogueItem extends AsyncTask<String, Void, SyncStatus> {
+        private ProgressDialog progressDialog;
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+            progressDialog = new ProgressDialog(CatalogueItemScreen.this);
+            progressDialog.setMessage(getString(R.string.loading_string));
+            progressDialog.show();
+            progressDialog.setCancelable(false);
+        }
+
+        @Override
+        protected SyncStatus doInBackground(String... params) {
+            SyncStatus syncStatus = CatalogueItemApiManager.getCatalogueItems(mCatalogue.getSysId(), new GetCatalogueItemApiListener() {
+                @Override
+                public void onDoneApiCall(List<CatalogueItem> catalogueItemList) {
+                    CatalogueLog.e("Data: catalogueItemList: "+catalogueItemList);
+                    CatalogueItemManager.handleGetCatalogueItem(mCatalogue.getId(), catalogueItemList);
+                }
+            });
+
+            return syncStatus;
+        }
+
+        @Override
+        protected void onPostExecute(SyncStatus syncStatus) {
+            super.onPostExecute(syncStatus);
+            if(progressDialog != null && progressDialog.isShowing()) {
+                progressDialog.dismiss();
+            }
+            createView(CatalogueItemManager.getAllCatalogueItems(mCatalogue.getId()));
+        }
+    }
+
+    private void createView(final List<CatalogueItem> catalogueItemList) {
+
+        if(!catalogueItemList.isEmpty()) {
+            ListView listView = new ListView(CatalogueItemScreen.this);
+
+            CatalogueCategoryItemAdapter adapter = new CatalogueCategoryItemAdapter(CatalogueItemScreen.this);
+            adapter.setCatalogueList(catalogueItemList);
+            listView.setAdapter(adapter);
+
+            setContentView(listView);
+
+            listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+
+                @Override
+                public void onItemClick(AdapterView<?> parent, View view,
+                                        int position, long id) {
+                    CatalogueLog.e("OnItemClickListener: position: " + position + ", Catalogue: " + catalogueItemList.get(position));
+                    Intent intent = new Intent(CatalogueItemScreen.this, CatalogueVariableScreen.class);
+                    intent.putExtra(Constants.DATA_KEY_SYS_ID, catalogueItemList.get(position).getSysId());
+                    startActivity(intent);
+                }
+            });
+        } else {
+            /*There is no catalogue items*/
+            TextView textView = new TextView(CatalogueItemScreen.this);
+            textView.setGravity(Gravity.CENTER);
+            textView.setText(R.string.no_catalogue_item_string);
+            setContentView(textView);
+        }
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/ui/CatalogueScreen.java

+package com.vsoft.uofl_catalogue.ui;
+
+import android.app.Activity;
+import android.app.ProgressDialog;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ListView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.adapters.CatalogueCategoryAdapter;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueApiListener;
+import com.vsoft.uofl_catalogue.api.managers.CatalogueApiManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueManager;
+import com.vsoft.uofl_catalogue.db.models.Catalogue;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import java.util.List;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class CatalogueScreen extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // TODO Auto-generated method stub
+        super.onCreate(savedInstanceState);
+
+        List<Catalogue> catalogueList = CatalogueManager.getAllCatalogues();
+        if(catalogueList.isEmpty()) {
+            new FetchCatalogue().execute();
+        } else {
+            createView(catalogueList);
+        }
+    }
+
+    class FetchCatalogue extends AsyncTask<String, Void, SyncStatus> {
+        private ProgressDialog progressDialog;
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+            progressDialog = new ProgressDialog(CatalogueScreen.this);
+            progressDialog.setMessage(getString(R.string.loading_string));
+            progressDialog.show();
+            progressDialog.setCancelable(false);
+        }
+
+        @Override
+        protected SyncStatus doInBackground(String... params) {
+            SyncStatus syncStatus = CatalogueApiManager.getCatalogues(new GetCatalogueApiListener() {
+                @Override
+                public void onDoneApiCall(List<Catalogue> catalogueList) {
+                    CatalogueLog.e("Data: catalogueList: "+catalogueList);
+                    CatalogueManager.handleGetCatalogue(catalogueList);
+                }
+            });
+
+            return syncStatus;
+        }
+
+        @Override
+        protected void onPostExecute(SyncStatus syncStatus) {
+            super.onPostExecute(syncStatus);
+            if(progressDialog != null && progressDialog.isShowing()) {
+                progressDialog.dismiss();
+            }
+            createView(CatalogueManager.getAllCatalogues());
+        }
+    }
+
+    private void createView(final List<Catalogue> catalogueList) {
+        ListView listView = new ListView(CatalogueScreen.this);
+
+        CatalogueCategoryAdapter adapter = new CatalogueCategoryAdapter(CatalogueScreen.this);
+        adapter.setCatalogueList(catalogueList);
+        listView.setAdapter(adapter);
+
+        setContentView(listView);
+
+        listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view,
+                                    int position, long id) {
+                CatalogueLog.e("OnItemClickListener: position: "+position + ", Catalogue: "+catalogueList.get(position));
+                Intent intent = new Intent(CatalogueScreen.this, CatalogueItemScreen.class);
+                intent.putExtra(Constants.DATA_KEY_SYS_ID, catalogueList.get(position).getSysId());
+                startActivity(intent);
+            }
+        });
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/ui/CatalogueVariableScreen.java

+package com.vsoft.uofl_catalogue.ui;
+
+import android.app.DatePickerDialog;
+import android.app.ProgressDialog;
+import android.app.TimePickerDialog;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.support.v4.app.FragmentActivity;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.content.ContextCompat;
+import android.text.Html;
+import android.text.TextUtils;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.DatePicker;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+import android.widget.TextView;
+import android.widget.TimePicker;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetCatalogueVariableApiListener;
+import com.vsoft.uofl_catalogue.api.listeners.get.GetVariableChoiceApiListener;
+import com.vsoft.uofl_catalogue.api.managers.CatalogueItemApiManager;
+import com.vsoft.uofl_catalogue.api.managers.CatalogueVariableApiManager;
+import com.vsoft.uofl_catalogue.api.managers.VariableChoiceApiManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueItemManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueVariableManager;
+import com.vsoft.uofl_catalogue.db.managers.CatalogueVariableValueManager;
+import com.vsoft.uofl_catalogue.db.managers.VariableChoiceManager;
+import com.vsoft.uofl_catalogue.db.models.CatalogueItem;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.db.models.Reference;
+import com.vsoft.uofl_catalogue.db.models.VariableChoice;
+import com.vsoft.uofl_catalogue.dialog.SelectReferenceDialog;
+import com.vsoft.uofl_catalogue.enums.SyncStatus;
+import com.vsoft.uofl_catalogue.enums.ViewType;
+import com.vsoft.uofl_catalogue.listeners.ReferenceListener;
+import com.vsoft.uofl_catalogue.ui.supportviews.DateAndTimePickerFragment;
+import com.vsoft.uofl_catalogue.utils.CatalogueLog;
+import com.vsoft.uofl_catalogue.utils.Constants;
+import com.vsoft.uofl_catalogue.utils.DBConstants;
+import com.vsoft.uofl_catalogue.utils.TagObject;
+import com.vsoft.uofl_catalogue.utils.Util;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class CatalogueVariableScreen extends FragmentActivity {
+
+    private CatalogueItem mCatalogueItem;
+    private List<CatalogueVariable> mCatalogueVariableList;
+    private LinearLayout mMainLayout;
+    private JSONArray mJsonArray;
+    private CatalogueApplication mApplication;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // TODO Auto-generated method stub
+        super.onCreate(savedInstanceState);
+        mApplication = (CatalogueApplication) getApplication();
+
+        Bundle extras = getIntent().getExtras();
+        String catalogueItemSysId = null;
+        if (extras != null) {
+            catalogueItemSysId = extras.getString(Constants.DATA_KEY_SYS_ID);
+            //The key argument here must match that used in the other activity
+        }
+
+        mCatalogueItem = CatalogueItemManager.getCatalogueItemFromSysId(catalogueItemSysId);
+        if (mCatalogueItem == null) {
+            CatalogueLog.e("CatalogueVariableScreen: onCreate: mCatalogueItem is null");
+            return;
+        }
+
+
+        mCatalogueVariableList = CatalogueVariableManager.getAllVariable(mCatalogueItem.getId());
+        setVariableChoices();
+
+        if (mCatalogueVariableList.isEmpty()) {
+            new FetchCatalogueVariable().execute();
+        } else {
+            createView();
+        }
+
+    }
+
+    class FetchCatalogueVariable extends AsyncTask<String, Void, SyncStatus> {
+        private ProgressDialog progressDialog;
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+            progressDialog = new ProgressDialog(CatalogueVariableScreen.this);
+            progressDialog.setMessage(getString(R.string.loading_string));
+            progressDialog.show();
+            progressDialog.setCancelable(false);
+        }
+
+        @Override
+        protected SyncStatus doInBackground(String... params) {
+            SyncStatus syncStatus = CatalogueVariableApiManager.getCatalogueVariable(mCatalogueItem.getSysId(), new GetCatalogueVariableApiListener() {
+                @Override
+                public void onDoneApiCall(List<CatalogueVariable> catalogueVariableList) {
+                    CatalogueLog.e("Data: catalogueVariableList: " + catalogueVariableList);
+
+                    CatalogueVariableManager.handleGetVariable(mCatalogueItem.getId(), catalogueVariableList);
+                    if(!catalogueVariableList.isEmpty()) {
+                        for (int i = 0; i < catalogueVariableList.size(); i++) {
+                            final CatalogueVariable catalogueVariable = catalogueVariableList.get(i);
+                            if (catalogueVariable.getType() == ViewType.MULTIPLE_CHOICE
+                                    || catalogueVariable.getType() == ViewType.SELECT_BOX) {
+                                /*Fetch multi choice variable values*/
+                                VariableChoiceApiManager.getVariableChoice(catalogueVariable.getSysId(), new GetVariableChoiceApiListener() {
+                                    @Override
+                                    public void onDoneApiCall(List<VariableChoice> variableChoiceList) {
+                                        CatalogueLog.e("Data: variableChoiceList: " + variableChoiceList);
+                                        catalogueVariable.setVariableChoiceList(variableChoiceList);
+                                        VariableChoiceManager.handleGetVariableChoice(catalogueVariable.getId(), variableChoiceList);
+                                    }
+                                });
+                            }
+                        }
+                        /*Create Dynamic table for CatalogueVariable*/
+                        Util.createDynamicTable(mCatalogueItem.getSysId(), catalogueVariableList);
+                    }
+                }
+            });
+
+            return syncStatus;
+        }
+
+        @Override
+        protected void onPostExecute(SyncStatus syncStatus) {
+            super.onPostExecute(syncStatus);
+            if (progressDialog != null && progressDialog.isShowing()) {
+                progressDialog.dismiss();
+            }
+            mCatalogueVariableList = CatalogueVariableManager.getAllVariable(mCatalogueItem.getId());
+            setVariableChoices();
+            createView();
+        }
+    }
+
+    private void setVariableChoices() {
+        if(!mCatalogueVariableList.isEmpty()) {
+            for (int i = 0; i < mCatalogueVariableList.size(); i++) {
+                CatalogueVariable catalogueVariable = mCatalogueVariableList.get(i);
+                if (catalogueVariable.getType() == ViewType.MULTIPLE_CHOICE
+                        || catalogueVariable.getType() == ViewType.SELECT_BOX) {
+                    List<VariableChoice> variableChoiceList = VariableChoiceManager.getAllVariableChoices(catalogueVariable.getId());
+                    catalogueVariable.setVariableChoiceList(variableChoiceList);
+                }
+            }
+        }
+    }
+
+    private void createView() {
+        mMainLayout = new LinearLayout(CatalogueVariableScreen.this);
+        mMainLayout.setOrientation(LinearLayout.VERTICAL);
+        mMainLayout.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT));
+
+        mMainLayout.addView(getCustomLayout());
+        if(!mCatalogueVariableList.isEmpty()) {
+            mMainLayout.addView(getVerticalSeparator());
+            mMainLayout.addView(getBottomLayout());
+        }
+
+        setContentView(mMainLayout);
+    }
+
+    private View getCustomLayout() {
+        ScrollView scrollView = new ScrollView(CatalogueVariableScreen.this);
+        scrollView.setFillViewport(true);
+        scrollView.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 0, .9f));
+
+        /*Child view of scroll view*/
+        LinearLayout linearLayout = new LinearLayout(CatalogueVariableScreen.this);
+        ScrollView.LayoutParams params = new ScrollView.LayoutParams(ScrollView.LayoutParams.MATCH_PARENT, ScrollView.LayoutParams.WRAP_CONTENT);
+        linearLayout.setLayoutParams(params);
+        linearLayout.setOrientation(LinearLayout.VERTICAL);
+        linearLayout.setPadding((int)getResources().getDimension(R.dimen.normal_margin),
+                                (int)getResources().getDimension(R.dimen.normal_margin),
+                                (int)getResources().getDimension(R.dimen.normal_margin),
+                                (int)getResources().getDimension(R.dimen.normal_margin));
+        scrollView.addView(linearLayout, params);
+
+        LinearLayout.LayoutParams childControlViewLayoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT);
+        LinearLayout.LayoutParams childLabelViewLayoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT);
+
+        /*Added item Description in form*/
+        if(!mCatalogueItem.getDescription().isEmpty()) {
+            TextView descriptionView = new TextView(CatalogueVariableScreen.this);
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
+                descriptionView.setText(Html.fromHtml(mCatalogueItem.getDescription(), Html.FROM_HTML_MODE_LEGACY));
+            } else {
+                descriptionView.setText(Html.fromHtml(mCatalogueItem.getDescription()));
+            }
+
+            linearLayout.addView(descriptionView, childControlViewLayoutParams);
+        }
+
+        if(mCatalogueVariableList.isEmpty()) {
+            TextView noVariableView = new TextView(CatalogueVariableScreen.this);
+            noVariableView.setText(R.string.no_variables_string);
+            noVariableView.setGravity(Gravity.CENTER);
+            linearLayout.addView(noVariableView, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,
+                    LinearLayout.LayoutParams.MATCH_PARENT));
+        } else {
+            for (int i = 0; i < mCatalogueVariableList.size(); i++) {
+                CatalogueVariable catalogueVariable = mCatalogueVariableList.get(i);
+                ViewType viewType = catalogueVariable.getType();
+                CatalogueLog.e("viewType: " + viewType);
+                if (catalogueVariable.getName() == null) {
+                    TextView nameNullView = new TextView(CatalogueVariableScreen.this);
+                    nameNullView.setText(R.string.name_null_view_string);
+                    nameNullView.setBackgroundColor(ContextCompat.getColor(CatalogueVariableScreen.this, R.color.name_null_view_color));
+                    childLabelViewLayoutParams.topMargin = (int) getResources().getDimension(R.dimen.small_margin);
+                    nameNullView.setPadding((int) getResources().getDimension(R.dimen.small_margin),
+                            (int) getResources().getDimension(R.dimen.small_margin),
+                            (int) getResources().getDimension(R.dimen.small_margin),
+                            (int) getResources().getDimension(R.dimen.small_margin));
+                    linearLayout.addView(nameNullView, childLabelViewLayoutParams);
+                } else {
+                    if (viewType != ViewType.LABEL && viewType != ViewType.CHECK_BOX && viewType != ViewType.BREAK) {
+                        /*Create label for every type*/
+                        if (!catalogueVariable.isMandatory()) {
+                            TextView label = new TextView(CatalogueVariableScreen.this);
+                            label.setText(catalogueVariable.getQuestionText());
+                            childLabelViewLayoutParams.topMargin = (int) getResources().getDimension(R.dimen.small_margin);
+                            linearLayout.addView(label, childLabelViewLayoutParams);
+                        } else {
+                            /*Create label with mandatory value*/
+                            LinearLayout labelLayout = new LinearLayout(CatalogueVariableScreen.this);
+                            labelLayout.setOrientation(LinearLayout.HORIZONTAL);
+
+                            TextView label = new TextView(CatalogueVariableScreen.this);
+                            label.setText(catalogueVariable.getQuestionText());
+                            childLabelViewLayoutParams.topMargin = (int) getResources().getDimension(R.dimen.small_margin);
+                            labelLayout.addView(label, childLabelViewLayoutParams);
+
+                            TextView mandatory = new TextView(CatalogueVariableScreen.this);
+                            mandatory.setText("*");
+                            mandatory.setTextColor(ContextCompat.getColor(CatalogueVariableScreen.this, R.color.error_color));
+                            labelLayout.addView(mandatory);
+
+                            linearLayout.addView(labelLayout);
+                        }
+                    }
+
+                    View controlView = Util.getView(CatalogueVariableScreen.this, viewType, catalogueVariable);
+
+                    if (controlView != null) {
+                        controlView.setTag(new TagObject(i, null));
+                        if (viewType == ViewType.DATE) {
+                            controlView.setOnClickListener(dateListener);
+                        } else if (viewType == ViewType.DATE_AND_TIME) {
+                            controlView.setOnClickListener(dateTimeListener);
+                        } else if (viewType == ViewType.REFERENCE) {
+                            controlView.setOnTouchListener(referenceListener);
+                        }
+
+                        /*Set bottom margin for custom view*/
+                        if (viewType != ViewType.BREAK) {
+                            linearLayout.addView(controlView, childControlViewLayoutParams);
+                        } else
+                            linearLayout.addView(controlView);
+
+                        /*Mandatory variable contain error view*/
+                        if (catalogueVariable.isMandatory()) {
+                            /*Add error view for validation*/
+                            View errorView = getErrorView();
+                            errorView.setTag("error_" + i);
+                            linearLayout.addView(errorView);
+                        }
+                    } else {
+                        TextView viewNotImplemented = new TextView(CatalogueVariableScreen.this);
+                        viewNotImplemented.setText(String.format(getString(R.string.view_not_implemented_string), viewType.getDisplayString()));
+                        viewNotImplemented.setBackgroundColor(ContextCompat.getColor(CatalogueVariableScreen.this, R.color.view_not_implemented_color));
+                        childLabelViewLayoutParams.topMargin = (int) getResources().getDimension(R.dimen.small_margin);
+                        linearLayout.addView(viewNotImplemented, childLabelViewLayoutParams);
+                    }
+                }
+            }
+        }
+        return scrollView;
+    }
+
+    private View getBottomLayout() {
+        LinearLayout bottomLayout = new LinearLayout(CatalogueVariableScreen.this);
+        bottomLayout.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 0, .1f));
+        bottomLayout.setOrientation(LinearLayout.HORIZONTAL);
+        bottomLayout.setBackgroundColor(ContextCompat.getColor(CatalogueVariableScreen.this, android.R.color.white));
+
+        LinearLayout.LayoutParams bottomChildViewParams = new LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.MATCH_PARENT, 1.0f);
+        TextView cancelTextView = new TextView(CatalogueVariableScreen.this);
+        cancelTextView.setText(android.R.string.cancel);
+        cancelTextView.setLayoutParams(bottomChildViewParams);
+        cancelTextView.setGravity(Gravity.CENTER);
+        cancelTextView.setId(R.id.create_form_cancel_text_view);
+        cancelTextView.setOnClickListener(listener);
+        bottomLayout.addView(cancelTextView);
+
+        bottomLayout.addView(getHorizontalSeparator());
+
+        TextView saveTextView = new TextView(CatalogueVariableScreen.this);
+        saveTextView.setText(R.string.save_string);
+        saveTextView.setLayoutParams(bottomChildViewParams);
+        saveTextView.setGravity(Gravity.CENTER);
+        saveTextView.setId(R.id.create_form_save_text_view);
+        saveTextView.setOnClickListener(listener);
+        bottomLayout.addView(saveTextView);
+
+        return bottomLayout;
+    }
+
+    private View getVerticalSeparator() {
+        View view = new View(CatalogueVariableScreen.this);
+        view.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, (int)getResources().getDimension(R.dimen.separator_value)));
+        view.setBackgroundColor(ContextCompat.getColor(CatalogueVariableScreen.this, android.R.color.black));
+        return view;
+    }
+
+    private View getHorizontalSeparator() {
+        View view = new View(CatalogueVariableScreen.this);
+        view.setLayoutParams(new LinearLayout.LayoutParams((int)getResources().getDimension(R.dimen.separator_value), LinearLayout.LayoutParams.MATCH_PARENT));
+        view.setBackgroundColor(ContextCompat.getColor(CatalogueVariableScreen.this, android.R.color.black));
+        return view;
+    }
+
+    private View getErrorView() {
+        TextView textView = new TextView(CatalogueVariableScreen.this);
+        textView.setTextColor(ContextCompat.getColor(CatalogueVariableScreen.this, R.color.error_color));
+        textView.setText(R.string.error_string);
+        textView.setVisibility(View.GONE);
+        return textView;
+    }
+
+    View.OnClickListener listener = new View.OnClickListener() {
+        @Override
+        public void onClick(final View v) {
+            switch (v.getId()) {
+                case R.id.create_form_cancel_text_view:
+                    finish();
+                    break;
+                case R.id.create_form_save_text_view:
+                    saveFormData();
+                    break;
+            }
+        }
+    };
+
+    private void saveFormData() {
+        /*For Local DB column and value*/
+        List<String> columnList = new ArrayList<>(mCatalogueVariableList.size());
+        List<String> valueList = new ArrayList<>(mCatalogueVariableList.size());
+
+        mJsonArray = new JSONArray();
+        TagObject tempTagObj = new TagObject(0, null);
+
+        boolean hasErrors = false;
+        for (int i = 0; i < mCatalogueVariableList.size(); i++) {
+            tempTagObj.setIndex(i);
+            CatalogueVariable catalogueVariable = mCatalogueVariableList.get(i);
+            ViewType viewType = catalogueVariable.getType();
+            if(viewType != ViewType.LABEL && viewType != ViewType.BREAK) {
+
+                View view = mMainLayout.findViewWithTag(tempTagObj);
+                if (view != null) {
+                    String value = Util.getVariableViewValue(view, viewType);
+                    View errorView = mMainLayout.findViewWithTag("error_"+i);
+
+                    columnList.add(catalogueVariable.getName());
+                    JSONObject jsonObject = new JSONObject();
+                    String jsonColumnValue = value;
+                    /*Convert date and time long value to string for server communication*/
+                    if(viewType == ViewType.DATE) {
+                        jsonColumnValue = Util.getDateFromLong(Long.parseLong(value));
+                    } else if(viewType == ViewType.DATE_AND_TIME) {
+                        jsonColumnValue = Util.getDateTimeFromLong(Long.parseLong(value));
+                    }
+
+                    if(viewType != ViewType.SELECT_BOX) {
+                        if (TextUtils.isEmpty(jsonColumnValue)) {
+                            hasErrors = true;
+                            // show error view
+                            if (errorView != null)
+                                errorView.setVisibility(View.VISIBLE);
+                        } else {
+                            // hide error view
+                            if (errorView != null)
+                                errorView.setVisibility(View.GONE);
+                        }
+                    } else {
+                        if (jsonColumnValue.equals(getString(R.string.none_string))) {
+                            hasErrors = true;
+                            // show error view
+                            if (errorView != null)
+                                errorView.setVisibility(View.VISIBLE);
+                        } else {
+                            // hide error view
+                            if (errorView != null)
+                                errorView.setVisibility(View.GONE);
+                        }
+                    }
+
+                    try {
+                        jsonObject.put(catalogueVariable.getName(), jsonColumnValue);
+                    } catch (JSONException e) {
+                        e.printStackTrace();
+                    }
+                    mJsonArray.put(jsonObject);
+                    valueList.add(value);
+                }
+            }
+        }
+
+        if(hasErrors)
+            return;
+
+        if(mApplication.isNetConnected()) {
+            new SubmitCatalogueItem().execute();
+        } else {
+            CatalogueVariableValueManager.save("t_" + mCatalogueItem.getSysId(), columnList, valueList, DBConstants.SYNC_FLAG_CREATE);
+            finish();
+        }
+    }
+
+    View.OnClickListener dateListener = new View.OnClickListener() {
+        @Override
+        public void onClick(final View v) {
+            DatePickerDialog.OnDateSetListener listener = new DatePickerDialog.OnDateSetListener() {
+                @Override
+                public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
+                    ((TextView)v).setText(String.format(getString(R.string.date_string), (dayOfMonth < 10 ? "0" + dayOfMonth : dayOfMonth), getMonth(monthOfYear), year));
+                }
+            };
+            FragmentManager fm = getSupportFragmentManager();
+            DateAndTimePickerFragment dateAndTimePickerFragment = DateAndTimePickerFragment.newInstance(getString(R.string.select_date_string));
+            dateAndTimePickerFragment.setDateListener(listener);
+            dateAndTimePickerFragment.show(fm, "Dialog Fragment");
+            dateAndTimePickerFragment.setCancelable(false);
+        }
+    };
+
+    View.OnClickListener dateTimeListener = new View.OnClickListener() {
+        @Override
+        public void onClick(final View v) {
+            DatePickerDialog.OnDateSetListener dateListener = new DatePickerDialog.OnDateSetListener() {
+                @Override
+                public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
+                    ((TextView)v).setText(String.format(getString(R.string.date_string), (dayOfMonth < 10 ? "0" + dayOfMonth : dayOfMonth), getMonth(monthOfYear), year));
+                }
+            };
+
+            TimePickerDialog.OnTimeSetListener timeListener = new TimePickerDialog.OnTimeSetListener() {
+                @Override
+                public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
+                    ((TextView)v).append(String.format(getString(R.string.date_and_time_string), (hourOfDay < 10 ? "0" + hourOfDay : hourOfDay), (minute < 10 ? "0" + minute : minute)));
+                }
+            };
+
+            FragmentManager fm = getSupportFragmentManager();
+            DateAndTimePickerFragment dateAndTimePickerFragment = DateAndTimePickerFragment.newInstance(getString(R.string.select_date_and_time_string));
+            dateAndTimePickerFragment.setDateListener(dateListener);
+            dateAndTimePickerFragment.setmTimeListener(timeListener);
+            dateAndTimePickerFragment.show(fm, "Dialog Fragment");
+            dateAndTimePickerFragment.setCancelable(false);
+        }
+    };
+
+    View.OnTouchListener referenceListener = new View.OnTouchListener() {
+        @Override
+        public boolean onTouch(final View v, MotionEvent event) {
+
+            if(event.getAction() == MotionEvent.ACTION_UP) {
+                final EditText editText = (EditText)v;
+                ReferenceListener listener = new ReferenceListener() {
+                    @Override
+                    public void positiveButtonClick(Reference reference) {
+                        editText.setText(reference.getName());
+                        TagObject tagObject = (TagObject)v.getTag();
+                        tagObject.setTagObject(reference);
+                    }
+
+                    @Override
+                    public void negativeButtonClick() {
+
+                    }
+                };
+                FragmentManager fm = getSupportFragmentManager();
+                TagObject tagObject = (TagObject)v.getTag();
+                String tableName = mCatalogueVariableList.get(tagObject.getIndex()).getReferenceTable();
+                SelectReferenceDialog spinnerDialog = SelectReferenceDialog.newInstance(tableName);
+                spinnerDialog.setListener(listener);
+                spinnerDialog.show(fm, "");
+                return true;
+            }
+            return false;
+        }
+    };
+
+    class SubmitCatalogueItem extends AsyncTask<String, Void, SyncStatus> {
+        private ProgressDialog progressDialog;
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+            progressDialog = new ProgressDialog(CatalogueVariableScreen.this);
+            progressDialog.setMessage(getString(R.string.loading_string));
+            progressDialog.show();
+            progressDialog.setCancelable(false);
+        }
+
+        @Override
+        protected SyncStatus doInBackground(String... params) {
+            SyncStatus syncStatus = CatalogueItemApiManager.submitCatalogueItem(mCatalogueItem.getSysId(), mJsonArray);
+            return syncStatus;
+        }
+
+        @Override
+        protected void onPostExecute(SyncStatus syncStatus) {
+            super.onPostExecute(syncStatus);
+            if (progressDialog != null && progressDialog.isShowing()) {
+                progressDialog.dismiss();
+            }
+            finish();
+        }
+    }
+
+    public String getMonth(int month) {
+        return Constants.month[month];
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/ui/HomeScreen.java

+package com.vsoft.uofl_catalogue.ui;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.GridView;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.adapters.HomeScreenAdapter;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import butterknife.OnItemClick;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class HomeScreen extends Activity {
+
+    @BindView(R.id.home_screen_grid_view) GridView mGridView;
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // TODO Auto-generated method stub
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.home_screen);
+        ButterKnife.bind(this);
+
+        mGridView.setAdapter(new HomeScreenAdapter(this, getResources().getStringArray(R.array.home_screen_array)));
+    }
+
+    @OnItemClick(R.id.home_screen_grid_view)
+    void gridViewItemClicked(int position) {
+        if(position == 1) {
+            startActivity(new Intent(HomeScreen.this, CatalogueScreen.class));
+        }
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/ui/LoginScreen.java

+package com.vsoft.uofl_catalogue.ui;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.vsoft.uofl_catalogue.R;
+
+import butterknife.ButterKnife;
+import butterknife.OnClick;
+
+/**
+ * Created by Kunj on 11/8/16.
+ */
+public class LoginScreen extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // TODO Auto-generated method stub
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.login_screen);
+
+        ButterKnife.bind(this);
+    }
+
+    @OnClick(R.id.login_screen_login_text_view)
+    void onLoginClicked() {
+        startActivity(new Intent(LoginScreen.this, HomeScreen.class));
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/ui/supportviews/DateAndTimePickerFragment.java

+package com.vsoft.uofl_catalogue.ui.supportviews;
+
+import android.app.DatePickerDialog;
+import android.app.TimePickerDialog;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.DatePicker;
+import android.widget.TextView;
+import android.widget.TimePicker;
+
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.utils.Constants;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import butterknife.OnClick;
+import butterknife.Unbinder;
+
+
+public class DateAndTimePickerFragment extends DialogFragment {
+    private DatePickerDialog.OnDateSetListener mOnDateSetListener;
+    private TimePickerDialog.OnTimeSetListener mOnTimeSetListener;
+    @BindView(R.id.date_picker) DatePicker mDatePicker;
+    @BindView(R.id.time_picker) TimePicker mTimePicker;
+    @BindView(R.id.date_and_time_title_text_view) TextView mTitle;
+
+    private Unbinder unbinder;
+
+    public DateAndTimePickerFragment(){
+
+    }
+
+    public void setDateListener(DatePickerDialog.OnDateSetListener listener) {
+      mOnDateSetListener = listener;
+    }
+
+    public void setmTimeListener(TimePickerDialog.OnTimeSetListener listener) {
+        mOnTimeSetListener = listener;
+    }
+
+    public static DateAndTimePickerFragment newInstance(String title) {
+        DateAndTimePickerFragment fragment = new DateAndTimePickerFragment();
+        Bundle bundle = new Bundle();
+        bundle.putString(Constants.DATA_DATE_AND_TIME_PICKER_TITLE, title);
+        fragment.setArguments(bundle);
+        return fragment;
+    }
+
+    @Override
+     public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setStyle(STYLE_NO_TITLE, R.style.DatePickerCustomDialog);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View rootView = inflater.inflate(R.layout.custom_dialog_date_picker, container, false);
+        unbinder = ButterKnife.bind(this, rootView);
+
+        String title = getArguments().getString(Constants.DATA_DATE_AND_TIME_PICKER_TITLE);
+        if(title.equals(getString(R.string.select_date_string))) {
+            mTimePicker.setVisibility(View.GONE);
+        } else if(title.equals(getString(R.string.select_date_and_time_string))) {
+            mTimePicker.setVisibility(View.VISIBLE);
+        }
+        mTitle.setText(title);
+
+        getDialog().setCanceledOnTouchOutside(true);
+        return rootView;
+    }
+
+    @OnClick(R.id.date_picker_cancel_text_view)
+    void cancelLayoutClick() {
+        getDialog().dismiss();
+    }
+
+    @OnClick(R.id.date_picker_set_text_view)
+    void setLayoutClick() {
+        mOnDateSetListener.onDateSet(mDatePicker, mDatePicker.getYear(), mDatePicker.getMonth(), mDatePicker.getDayOfMonth());
+
+        if(mOnTimeSetListener!=null) {
+            int currentApiVersion = android.os.Build.VERSION.SDK_INT;
+            if (currentApiVersion > android.os.Build.VERSION_CODES.LOLLIPOP_MR1) {
+                mOnTimeSetListener.onTimeSet(mTimePicker, mTimePicker.getHour(), mTimePicker.getMinute());
+            } else {
+                mOnTimeSetListener.onTimeSet(mTimePicker, mTimePicker.getCurrentHour(), mTimePicker.getCurrentMinute());
+            }
+        }
+        getDialog().dismiss();
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        unbinder.unbind();
+    }
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/utils/CatalogueBuildConfig.java

+package com.vsoft.uofl_catalogue.utils;
+
+/**
+ * @since 1.0
+ * @author prathap bezawada
+ * 
+ *         Boolean Flag to set Build Target and DDMS Log enable/disable
+ */
+public final class CatalogueBuildConfig {
+	public final static boolean DEBUG = true;
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/utils/CatalogueLog.java

+package com.vsoft.uofl_catalogue.utils;
+
+import android.util.Log;
+
+/**
+ * @since 1.0
+ * @author prathap bezawada
+ * 
+ */
+public class CatalogueLog {
+
+	public static void d(String msg) {
+		if (CatalogueBuildConfig.DEBUG) {
+			Log.d(Constants.TAG, msg);
+		}
+	}
+
+	public static void e(String msg) {
+		if(CatalogueBuildConfig.DEBUG) {
+			Log.e(Constants.TAG, msg);
+		}
+	}
+
+	public static void e(String msg, Exception e) {
+		if(CatalogueBuildConfig.DEBUG) {
+			Log.e(Constants.TAG, msg, e);
+		}
+	}
+}

app/src/main/java/com/vsoft/uofl_catalogue/utils/Constants.java

+package com.vsoft.uofl_catalogue.utils;
+
+import com.vsoft.uofl_catalogue.BuildConfig;
+
+/**
+ * @author Kunj on 11/8/16.
+ * @since 1.0
+ */
+public class Constants {
+
+    public static final String TAG = "UofLCatalogue";
+    public static final String[] month = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+    /**
+     * Preference
+     */
+    public static final String PREFS_OLD_VERSION_NUMBER = "oldVersionNumber";
+    public static final String PREFS_NEW_VERSION_NUMBER = "newVersionNumber";
+
+    /**
+     * Intent String
+     */
+    public static final String DATA_DATE_AND_TIME_PICKER_TITLE = "title";
+    public static final String DATA_KEY_SYS_ID = "sys_id";
+    public static final String DATA_KEY_REFERENCE_TABLE_NAME = "table_name";
+
+    /**
+     * Catalogue services post parameters
+     */
+    public static final String URL_PARAM_SYSPRM_QUERY = "sysparm_query";
+    public static final String URL_PARAM_SYSPRM_FIELDS = "sysparm_fields";
+
+    /**
+     * Debug logs
+     */
+    public static final boolean DEBUG = true;
+
+    /**
+     * Decides the URLS used
+     */
+    private static final String DOMAIN_PRODUCTION = "https://ven01199.service-now.com/";
+    private static final String DOMAIN_TEST = "https://uofltest.service-now.com/";
+
+    private static final String API_PATH_PRODUCTION = "/api/now/table/";
+    private static final String API_PATH_TEST = "/api/now/table/";
+
+    public static final int BUILD_TYPE_DEBUG = 1;
+    public static final int BUILD_TYPE_RELEASE = 2;
+
+    private static final String API_PATH = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? API_PATH_PRODUCTION
+            : API_PATH_TEST);
+
+    private static final String DOMAIN_FROM_BUILD = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? DOMAIN_PRODUCTION
+            : DOMAIN_TEST);
+
+    /**
+     * Decides the Client data used
+     */
+    private static final String LOGIN_CLIENT_ID_PRODUCTION = "a40b3f05ae582600433c09623de6cbe4";
+    private static final String LOGIN_CLIENT_SECRET_PRODUCTION = "t8SdV}crm&";
+
+    private static final String LOGIN_CLIENT_ID_TEST = "8689966b6f8426001fbf10d078fc4cc5";
+    private static final String LOGIN_CLIENT_SECRET_TEST = "tGm41IOL6i";
+
+    public static final String LOGIN_CLIENT_ID = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? LOGIN_CLIENT_ID_PRODUCTION
+            : LOGIN_CLIENT_ID_TEST);
+
+    public static final String LOGIN_CLIENT_SECRET = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? LOGIN_CLIENT_SECRET_PRODUCTION
+            : LOGIN_CLIENT_SECRET_TEST);
+
+    /**
+     * Decides the Api auth data used
+     */
+    private static final String API_AUTH_PARAM_USER_NAME_PRODUCTION = "vsoft.admin";
+    private static final String API_AUTH_PARAM_PASSWORD_PRODUCTION = "v50ft@123456";
+
+    private static final String API_AUTH_PARAM_USER_NAME_TEST = "a0kuma18";
+    private static final String API_AUTH_PARAM_PASSWORD_TEST = "v$0ftA$win";
+
+    public static final String API_AUTH_PARAM_USER_NAME = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? API_AUTH_PARAM_USER_NAME_PRODUCTION
+            : API_AUTH_PARAM_USER_NAME_TEST);
+
+    public static final String API_AUTH_PARAM_PASSWORD = (BUILD_TYPE_RELEASE == BuildConfig.BUILD_TYPE_INT
+            ? API_AUTH_PARAM_PASSWORD_PRODUCTION
+            : API_AUTH_PARAM_PASSWORD_TEST);
+
+    /**
+     * Domain to use
+     */
+    public static final String DOMAIN = DOMAIN_FROM_BUILD;
+
+    /**
+     * 17d0392d4f00e2005e1a3d728110c739
+     * Catalogue web services Header parameters
+     */
+    public static final String API_HEADER_PARAM_AUTHORIZATION = "Authorization";
+
+    /**
+     * Catalogue web service post response object name
+     **/
+    public static final String RESPONSE_RESULT_OBJECT_NAME = "result";
+    public static final String RESPONSE_ERROR_OBJECT_NAME = "error";
+
+    /**
+     * Catalogue web services urls
+     */
+    public static final String URL_GET_CATALOGUE = API_PATH + "sc_category";
+    public static final String URL_GET_CATALOGUE_ITEM = API_PATH + "sc_cat_item";
+    public static final String URL_GET_VARIABLE = "/api/uno33/uofl_mobile/variables";
+    public static final String URL_GET_VARIABLE_CHOICE = API_PATH + "question_choice";
+    public static final String URL_POST_CATALOGUE_ITEM = "api/uno33/uofl_mobile";
+    public static final String URL_GET_REFERENCE = API_PATH;
+
+}

app/src/main/java/com/vsoft/uofl_catalogue/utils/DBConstants.java

+package com.vsoft.uofl_catalogue.utils;
+
+public interface DBConstants {
+	//Tables
+	String TABLE_CATALOGUE = "catalogue_category";
+	String TABLE_CATALOGUE_ITEM = "catalogue_category_item";
+	String TABLE_CATALOGUE_VARIABLES = "catalogue_variable";
+	String TABLE_VARIABLE_CHOICES = "variable_choices";
+
+	String ID = "_id";
+	String SYS_ID = "sys_id";
+
+	String SYNC_DIRTY = "sync_dirty";
+	int SYNC_FLAG_NONE = 0;
+	int SYNC_FLAG_CREATE = 1;
+	int SYNC_FLAG_UPDATE = 2;
+	int SYNC_FLAG_DELETE = 3;
+
+	/**
+	 * Catalogue table
+	 */
+	String CATALOGUE_ID = ID;
+	String CATALOGUE_TITLE = "title";
+	String CATALOGUE_DESCRIPTION = "description";
+	String CATALOGUE_SYS_ID = SYS_ID;
+	String CATALOGUE_SYNC_DIRTY = SYNC_DIRTY;
+
+	/*
+	 * Indices for Catalogue table. *Use these only if you fetch all columns*
+	 */
+	int INDEX_CATALOGUE_ID = 0;
+	int INDEX_CATALOGUE_TITLE = 1;
+	int INDEX_CATALOGUE_DESCRIPTION = 2;
+	int INDEX_CATALOGUE_SYS_ID = 3;
+	int INDEX_CATALOGUE_SYNC_DIRTY = 4;
+
+	int CATALOGUE_COLUMN_COUNT = 5;
+
+	/**
+	 * Catalogue_item table
+	 */
+	String CATALOGUE_ITEM_ID = ID;
+	String CATALOGUE_ITEM_CATALOGUE_ID = "catalogue_id";
+	String CATALOGUE_ITEM_NAME = "name";
+	String CATALOGUE_ITEM_SHORT_DESCRIPTION = "short_description";
+	String CATALOGUE_ITEM_DESCRIPTION = "item_description";
+	String CATALOGUE_ITEM_SYS_ID = SYS_ID;
+	String CATALOGUE_ITEM_SYNC_DIRTY = SYNC_DIRTY;
+
+	/**
+	 * Indices for Catalogue_item table. *Use these only if you fetch all columns*
+	 */
+	int INDEX_CATALOGUE_ITEM_ID = 0;
+	int INDEX_CATALOGUE_ITEM_CATALOGUE_ID = 1;
+	int INDEX_CATALOGUE_ITEM_NAME = 2;
+	int INDEX_CATALOGUE_ITEM_SHORT_DESCRIPTION = 3;
+	int INDEX_CATALOGUE_ITEM_DESCRIPTION = 4;
+	int INDEX_CATALOGUE_ITEM_SYS_ID = 5;
+	int INDEX_CATALOGUE_ITEM_SYNC_DIRTY = 6;
+
+	int CATALOGUE_ITEM_COLUMN_COUNT = 7;
+
+	/**
+	 * Catalogue variables table
+	 */
+	String CATALOGUE_VARIABLE_ID = ID;
+	String CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID = "catalogue_item_id";
+	String CATALOGUE_VARIABLE_NAME = "name";
+	String CATALOGUE_VARIABLE_QUESTION_TEXT = "question_text";
+	String CATALOGUE_VARIABLE_TYPE = "type";
+	String CATALOGUE_VARIABLE_MANDATORY = "mandatory";
+	String CATALOGUE_VARIABLE_NONE_REQUIRED = "isNoneRequired";
+	String CATALOGUE_VARIABLE_REFERENCE_TABLE = "reference_table";
+	String CATALOGUE_VARIABLE_SYS_ID = SYS_ID;
+	String CATALOGUE_VARIABLE_SYNC_DIRTY = SYNC_DIRTY;
+
+	/**
+	 * Indices for Catalogue variables table. *Use these only if you fetch all columns*
+	 */
+	int INDEX_CATALOGUE_VARIABLE_ID = 0;
+	int INDEX_CATALOGUE_VARIABLE_CATALOGUE_ITEM_ID = 1;
+	int INDEX_CATALOGUE_VARIABLE_NAME = 2;
+	int INDEX_CATALOGUE_VARIABLE_QUESTION_TEXT = 3;
+	int INDEX_CATALOGUE_VARIABLE_TYPE = 4;
+	int INDEX_CATALOGUE_VARIABLE_MANDATORY = 5;
+	int INDEX_CATALOGUE_VARIABLE_NONE_REQUIRED = 6;
+	int INDEX_CATALOGUE_VARIABLE_REFERENCE = 7;
+	int INDEX_CATALOGUE_VARIABLE_SYS_ID = 8;
+	int INDEX_CATALOGUE_VARIABLE_SYNC_DIRTY = 9;
+
+	int CATALOGUE_VARIABLE_COLUMN_COUNT = 10;
+
+	/**
+	 * Variables Choice table
+	 */
+	String VARIABLE_CHOICE_ID = ID;
+	String VARIABLE_CHOICE_VARIABLE_ID = "variable_id";
+	String VARIABLE_CHOICE_TEXT = "text";
+	String VARIABLE_CHOICE_VALUE = "value";
+	String VARIABLE_CHOICE_ORDER = "choice_order";
+	String VARIABLE_CHOICE_MISC = "misc";
+
+	/**
+	 * Indices for Variables Choice table. *Use these only if you fetch all columns*
+	 */
+	int INDEX_VARIABLE_CHOICE_ID = 0;
+	int INDEX_VARIABLE_CHOICE_VARIABLE_ID = 1;
+	int INDEX_VARIABLE_CHOICE_TEXT = 2;
+	int INDEX_VARIABLE_CHOICE_VALUE = 3;
+	int INDEX_VARIABLE_CHOICE_ORDER = 4;
+	int INDEX_VARIABLE_CHOICE_MISC = 5;
+
+	int VARIABLE_CHOICE_COLUMN_COUNT = 6;
+}
\ No newline at end of file

app/src/main/java/com/vsoft/uofl_catalogue/utils/TagObject.java

+package com.vsoft.uofl_catalogue.utils;
+
+/**
+ * Created by Kunj on 18/8/16.
+ */
+public class TagObject {
+    private int index;
+    private Object tagObject;
+
+    public TagObject(int index, Object tagObject) {
+        this.index = index;
+        this.tagObject = tagObject;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public void setIndex(int index) {
+        this.index = index;
+    }
+
+    public Object getTagObject() {
+        return tagObject;
+    }
+
+    public void setTagObject(Object tagObject) {
+        this.tagObject = tagObject;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return (o instanceof TagObject && this.index==((TagObject) o).index);
+    }
+}

app/src/main/java/com/vsoft/uofl_catalogue/utils/Util.java

+package com.vsoft.uofl_catalogue.utils;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.support.v4.content.ContextCompat;
+import android.text.InputType;
+import android.text.method.PasswordTransformationMethod;
+import android.view.Gravity;
+import android.view.View;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+import android.widget.Spinner;
+import android.widget.TextView;
+
+import com.vsoft.uofl_catalogue.CatalogueApplication;
+import com.vsoft.uofl_catalogue.R;
+import com.vsoft.uofl_catalogue.db.models.CatalogueVariable;
+import com.vsoft.uofl_catalogue.db.models.Reference;
+import com.vsoft.uofl_catalogue.db.models.VariableChoice;
+import com.vsoft.uofl_catalogue.enums.ViewType;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Created by Kunj on 12/8/16.
+ */
+public class Util {
+    public static View getView(Context context, ViewType viewType, CatalogueVariable catalogueVariable) {
+        switch (viewType) {
+            case YES_NO:
+                Spinner spinner = new Spinner(context);
+                ArrayAdapter<String> spinnerArrayAdapter =
+                        new ArrayAdapter<>(context, android.R.layout.simple_spinner_item, new String[] {"Yes", "No"});
+                spinnerArrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+                spinner.setAdapter(spinnerArrayAdapter);
+                return spinner;
+            case MULTI_LINE_TEXT:
+                EditText multiLineEditText = new EditText(context);
+                multiLineEditText.setSingleLine(false);
+                multiLineEditText.setImeOptions(EditorInfo.IME_FLAG_NO_ENTER_ACTION);
+                multiLineEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE);
+                multiLineEditText.setLines(3);
+                multiLineEditText.setVerticalScrollBarEnabled(true);
+                multiLineEditText.setGravity(Gravity.START);
+                return multiLineEditText;
+            case HTML:
+                EditText htmlEditText = new EditText(context);
+                htmlEditText.setSingleLine(false);
+                htmlEditText.setImeOptions(EditorInfo.IME_FLAG_NO_ENTER_ACTION);
+                htmlEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE);
+                htmlEditText.setLines(3);
+                htmlEditText.setVerticalScrollBarEnabled(true);
+                htmlEditText.setGravity(Gravity.START);
+                return htmlEditText;
+            case NUMERIC_SCALE:
+                LinearLayout linearLayout = new LinearLayout(context);
+                RadioButton[] radioButtons = new RadioButton[5];
+                RadioGroup rg = new RadioGroup(context); //create the RadioGroup
+                rg.setOrientation(RadioGroup.HORIZONTAL);//or RadioGroup.VERTICAL
+                for(int i = 0; i < 5; i++){
+                    radioButtons[i]  = new RadioButton(context);
+                    radioButtons[i].setText("" +(i+1));
+                    rg.addView(radioButtons[i]);
+                }
+                linearLayout.addView(rg);
+                return linearLayout;
+            case CHECK_BOX:
+                CheckBox checkBox = new CheckBox(context);
+                checkBox.setText(catalogueVariable.getQuestionText());
+                return checkBox;
+            case SINGLE_LINE_TEXT:
+                EditText singleLineEditText = new EditText(context);
+                singleLineEditText.setSingleLine(true);
+                singleLineEditText.setLines(1);
+                return singleLineEditText;
+            case WIDE_SINGLE_LINE_TEXT:
+                EditText wideSingleLineEditText = new EditText(context);
+                wideSingleLineEditText.setSingleLine(true);
+                wideSingleLineEditText.setLines(1);
+                return wideSingleLineEditText;
+            case DATE:
+                Button dateTextButton = new Button(context);
+                dateTextButton.setText(getDefaultDate());
+                dateTextButton.setGravity(Gravity.CENTER_VERTICAL);
+                return dateTextButton;
+            case DATE_AND_TIME:
+                Button dateTimeButton = new Button(context);
+                dateTimeButton.setText(getDefaultDate() + " " + getDefaultTime());
+                dateTimeButton.setGravity(Gravity.CENTER_VERTICAL);
+                return dateTimeButton;
+            case REFERENCE:
+                EditText referenceEditText = new EditText(context);
+                referenceEditText.setLines(1);
+                referenceEditText.setSingleLine(true);
+                referenceEditText.setFocusable(false);
+                referenceEditText.setFocusableInTouchMode(false);
+                referenceEditText.setClickable(false);
+                referenceEditText.setCompoundDrawablesWithIntrinsicBounds(0, 0, android.R.drawable.ic_menu_search, 0);
+                return referenceEditText;
+            case LABEL:
+                TextView labelTextView = new TextView(context);
+                labelTextView.setText(catalogueVariable.getQuestionText());
+                return labelTextView;
+            case MASKED:
+                EditText maskedEditText = new EditText(context);
+                maskedEditText.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);
+                maskedEditText.setLines(1);
+                maskedEditText.setSingleLine(true);
+                maskedEditText.setTransformationMethod(PasswordTransformationMethod.getInstance());
+                return maskedEditText;
+            case MULTIPLE_CHOICE:
+                LinearLayout multiChoiceLinearLayout = new LinearLayout(context);
+                multiChoiceLinearLayout.setOrientation(LinearLayout.HORIZONTAL);
+
+                RadioButton[] multiChoiceRadioButtons = new RadioButton[catalogueVariable.getVariableChoiceList().size()];
+                RadioGroup radioGroup = new RadioGroup(context); //create the RadioGroup
+                radioGroup.setOrientation(RadioGroup.VERTICAL);//or RadioGroup.HORIZONTAL
+                for(int i = 0; i < catalogueVariable.getVariableChoiceList().size(); i++) {
+                    multiChoiceRadioButtons[i]  = new RadioButton(context);
+                    VariableChoice variableChoice = catalogueVariable.getVariableChoiceList().get(i);
+                    if(variableChoice.getMisc() > 0) {
+                        multiChoiceRadioButtons[i].setText(
+                                String.format(context.getString(R.string.variable_form_misc_info_string),
+                                        variableChoice.getText(),
+                                        variableChoice.getMisc()));
+                    } else {
+                        multiChoiceRadioButtons[i].setText(variableChoice.getText());
+                    }
+                    multiChoiceRadioButtons[i].setTag(catalogueVariable.getVariableChoiceList().get(i).getValue());
+                    radioGroup.addView(multiChoiceRadioButtons[i]);
+                }
+                multiChoiceLinearLayout.addView(radioGroup);
+                return multiChoiceLinearLayout;
+            case SELECT_BOX:
+                Spinner selectBoxSpinner = new Spinner(context);
+                selectBoxSpinner.setPadding(0, (int) context.getResources().getDimension(R.dimen.normal_margin),
+                                            0, (int) context.getResources().getDimension(R.dimen.normal_margin));
+                ArrayAdapter<String> selectBoxSpinnerArrayAdapter =
+                        new ArrayAdapter<>(context, android.R.layout.simple_spinner_item, catalogueVariable.getDisplayChoiceText(context, catalogueVariable.isNoneRequired()));
+                selectBoxSpinnerArrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+                selectBoxSpinner.setAdapter(selectBoxSpinnerArrayAdapter);
+                return selectBoxSpinner;
+            case BREAK:
+                View view = new View(context);
+                view.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 1));
+                view.setBackgroundColor(ContextCompat.getColor(context, android.R.color.black));
+                return view;
+        }
+        return null;
+    }
+
+    public static void createDynamicTable(String catalogueItemSysId, List<CatalogueVariable> catalogueVariableList) {
+
+        StringBuilder queryString = new StringBuilder();
+        //Opens database in writable mode.
+        SQLiteDatabase database = CatalogueApplication.getDatabase();
+
+        queryString.append("CREATE TABLE IF NOT EXISTS t_");
+        queryString.append(catalogueItemSysId);
+        queryString.append(" (");
+
+        queryString.append(DBConstants.ID);
+        queryString.append(" integer primary key autoincrement, ");
+
+        CatalogueVariable catalogueVariable = catalogueVariableList.get(0);
+        if(catalogueVariable.getName() != null) {
+            queryString.append(catalogueVariable.getName());
+            queryString.append(" text, ");
+        }
+        for(int i = 1; i < catalogueVariableList.size(); i++) {
+            catalogueVariable = catalogueVariableList.get(i);
+            if(catalogueVariable.getName()!=null) {
+                queryString.append(catalogueVariable.getName());
+                queryString.append(" text, ");
+            }
+        }
+
+        queryString.append(DBConstants.CATALOGUE_VARIABLE_SYNC_DIRTY);
+        queryString.append(" integer default ");
+        queryString.append(DBConstants.SYNC_FLAG_NONE);
+        queryString.append(");");
+
+        System.out.println("Create Table Stmt : "+ queryString);
+        database.execSQL(queryString.toString());
+    }
+
+    public static String getVariableViewValue(View view, ViewType viewType) {
+        switch (viewType) {
+            case YES_NO:
+                Spinner yesNoSpinner = (Spinner) view;
+                return yesNoSpinner.getSelectedItem().toString();
+            case MULTI_LINE_TEXT:
+                EditText multiLineTextEditText = (EditText) view;
+                return multiLineTextEditText.getText().toString();
+            case HTML:
+                EditText htmlEditText = (EditText) view;
+                return htmlEditText.getText().toString();
+            case NUMERIC_SCALE:
+                LinearLayout linearLayout = (LinearLayout) view;
+                for(int i = 0; i < linearLayout.getChildCount(); i++) {
+                    RadioGroup radioGroup = (RadioGroup) linearLayout.getChildAt(i);
+                    int radioButtonID = radioGroup.getCheckedRadioButtonId();
+                    RadioButton radioButton = (RadioButton)radioGroup.findViewById(radioButtonID);
+                    return radioButton.getText().toString();
+                }
+            case CHECK_BOX:
+                CheckBox checkBox = (CheckBox) view;
+                return checkBox.isChecked() ? "1" : "0";
+            case SINGLE_LINE_TEXT:
+                EditText singleLineEditText = (EditText) view;
+                return singleLineEditText.getText().toString();
+            case WIDE_SINGLE_LINE_TEXT:
+                EditText wideSingleLineEditText = (EditText) view;
+                return wideSingleLineEditText.getText().toString();
+            case DATE:
+                Button dateTextButton = (Button) view;
+                return ""+ getDateFromString(dateTextButton.getText().toString());
+            case DATE_AND_TIME:
+                Button dateTimeButton = (Button) view;
+                return ""+ getDateTimeFromString(dateTimeButton.getText().toString());
+            case REFERENCE:
+                TagObject tagObject = (TagObject) view.getTag();
+                Reference reference = (Reference)tagObject.getTagObject();
+                if(reference!=null) {
+                    return reference.getSysId();
+                } else {
+                    return "";
+                }
+            case MASKED:
+                EditText maskedEditText = (EditText) view;
+                return maskedEditText.getText().toString();
+            case MULTIPLE_CHOICE:
+                LinearLayout multipleChoiceLinearLayout = (LinearLayout) view;
+                for(int i = 0; i < multipleChoiceLinearLayout.getChildCount(); i++) {
+                    RadioGroup radioGroup = (RadioGroup) multipleChoiceLinearLayout.getChildAt(i);
+                    int radioButtonID = radioGroup.getCheckedRadioButtonId();
+                    RadioButton radioButton = (RadioButton)radioGroup.findViewById(radioButtonID);
+                    if(radioButton != null) {
+                        return radioButton.getTag().toString();
+                    }
+                }
+                return "";
+            case SELECT_BOX:
+                Spinner selectBoxSpinner = (Spinner) view;
+                return selectBoxSpinner.getSelectedItem().toString();
+            default:
+                return "";
+        }
+    }
+
+    public static String getDefaultDate() {
+        Calendar c = Calendar.getInstance();
+        SimpleDateFormat df = new SimpleDateFormat("dd MMM, yyyy");
+        String formattedDate = df.format(c.getTime());
+        return formattedDate;
+    }
+
+    public static String getDefaultTime() {
+        Calendar c = Calendar.getInstance();
+        int hour = c.get(Calendar.HOUR_OF_DAY);
+        int min = c.get(Calendar.MINUTE);
+        String time = (hour < 10 ? ("0" + hour) : hour) + ":" + (min < 10 ? ("0" + min) : min);
+        return time;
+    }
+
+    public static long getDateFromString(String strDate) {
+        SimpleDateFormat df = new SimpleDateFormat("dd MMM, yyyy");
+        Date date = null;
+        try {
+            date = df.parse(strDate);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+        return date.getTime();
+    }
+
+    public static String getDateFromLong(long timeStamp) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat
+                ("yyyy-MM-dd", Locale.getDefault());
+        return dateFormat.format(timeStamp);
+    }
+
+    public static long getDateTimeFromString(String strDate) {
+        SimpleDateFormat df = new SimpleDateFormat("dd MMM, yyyy HH:mm");
+        Date date = null;
+        try {
+            date = df.parse(strDate);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+        return date.getTime();
+    }
+
+    public static String getDateTimeFromLong(long timeStamp) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat
+                ("dd MMM, yyyy HH:mm", Locale.getDefault());
+        return dateFormat.format(timeStamp);
+    }
+
+    public static void hideSoftKeyboard(Context context, View view) {
+        InputMethodManager imm =(InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
+        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
+    }
+}

app/src/main/res/layout/catalogue_category_adapter.xml

+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:weightSum="10">
+
+    <ImageView
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="2.5"
+        android:layout_gravity="center"
+        android:src="@android:drawable/ic_dialog_dialer"/>
+
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="7.5"
+        android:orientation="vertical"
+        android:padding="@dimen/small_margin">
+
+        <TextView
+            android:id="@+id/catalogue_category_adapter_title_tv"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:textSize="@dimen/normal_text_size"
+            android:lines="1" />
+
+        <TextView
+            android:id="@+id/catalogue_category_adapter_des_tv"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:lines="2"
+            android:textSize="@dimen/small_text_size"
+            android:paddingTop="@dimen/small_margin" />
+    </LinearLayout>
+</LinearLayout>
\ No newline at end of file

app/src/main/res/layout/catalogue_category_item_adapter.xml

+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/catalogue_item_content_layout"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:weightSum="10">
+
+    <ImageView
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:layout_weight="2.5"
+        android:src="@android:drawable/ic_dialog_dialer" />
+
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="7.5"
+        android:orientation="vertical"
+        android:padding="@dimen/small_margin">
+
+        <TextView
+            android:id="@+id/catalogue_category_item_adapter_name_tv"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:lines="1"
+            android:textSize="@dimen/normal_text_size" />
+
+        <TextView
+            android:id="@+id/catalogue_category_item_adapter_des_tv"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ellipsize="end"
+            android:lines="2"
+            android:paddingTop="@dimen/small_margin"
+            android:textSize="@dimen/small_text_size" />
+    </LinearLayout>
+</LinearLayout>
\ No newline at end of file

app/src/main/res/layout/custom_dialog.xml

+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    style="@style/WhiteBackgroundStyle"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:weightSum="10">
+
+    <TextView
+        android:id="@+id/dialog_title"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:paddingBottom="@dimen/normal_margin"
+        android:paddingTop="@dimen/normal_margin"
+        android:text="@string/search_for_reference_string"
+        android:textSize="@dimen/large_text_size"/>
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="0.5dp"
+        android:background="@android:color/black" />
+
+    <EditText
+        android:id="@+id/dialog_edit_text"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="@dimen/large_margin"
+        android:layout_marginRight="@dimen/large_margin"
+        android:layout_weight="0"
+        android:drawableEnd="@android:drawable/ic_menu_close_clear_cancel"
+        android:drawableRight="@android:drawable/ic_menu_close_clear_cancel"
+        android:hint="@string/search_for_reference_string"
+        android:imeOptions="actionSearch"
+        android:singleLine="true"
+        android:textColor="@android:color/black"/>
+
+    <ListView
+        android:id="@+id/dialog_list_view"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="10"
+        android:divider="@android:color/black"
+        android:dividerHeight="0.5dp"/>
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="0.5dp"
+        android:background="@android:color/black" />
+
+    <TextView
+        android:id="@+id/dialog_cancel_layout"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_weight="0"
+        android:gravity="center"
+        android:orientation="horizontal"
+        android:paddingBottom="@dimen/normal_margin"
+        android:paddingTop="@dimen/normal_margin"
+        android:text="@android:string/cancel"/>
+</LinearLayout>
\ No newline at end of file

app/src/main/res/layout/custom_dialog_date_picker.xml

+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/date_and_time_title_text_view"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:paddingBottom="@dimen/normal_margin"
+        android:paddingTop="@dimen/normal_margin"
+        android:textColor="@android:color/black"
+        android:textSize="@dimen/large_text_size" />
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="0.5dp"
+        android:background="@android:color/black" />
+
+    <DatePicker
+        android:id="@+id/date_picker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center" />
+
+    <TimePicker
+        android:id="@+id/time_picker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center" />
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="0.5dp"
+        android:background="@android:color/black" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="@android:color/white"
+        android:gravity="center"
+        android:orientation="horizontal"
+        android:paddingBottom="@dimen/normal_margin"
+        android:paddingTop="@dimen/normal_margin">
+
+        <TextView
+            android:id="@+id/date_picker_cancel_text_view"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="@dimen/small_margin"
+            android:layout_marginStart="@dimen/small_margin"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="@android:string/cancel"
+            android:textColor="@android:color/black"
+            android:textSize="@dimen/normal_text_size" />
+
+        <View
+            android:layout_width="0.5dp"
+            android:layout_height="match_parent"
+            android:background="@android:color/black" />
+
+        <TextView
+            android:id="@+id/date_picker_set_text_view"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="@dimen/small_margin"
+            android:layout_marginStart="@dimen/small_margin"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="@string/set_string"
+            android:textColor="@android:color/black"
+            android:textSize="@dimen/normal_text_size" />
+    </LinearLayout>
+</LinearLayout>
\ No newline at end of file

app/src/main/res/layout/home_screen.xml

+<?xml version="1.0" encoding="utf-8"?>
+<merge
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <GridView
+        android:id="@+id/home_screen_grid_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:verticalSpacing="@dimen/large_margin"
+        android:horizontalSpacing="@dimen/large_margin"
+        android:stretchMode="columnWidth"
+        android:padding="@dimen/large_margin"
+        android:background="@color/home_screen_bg_color"
+        android:numColumns="2"/>
+
+</merge>
\ No newline at end of file

app/src/main/res/layout/home_screen_adapter.xml

+<?xml version="1.0" encoding="utf-8"?>
+<TextView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/home_screen_adapter_text_view"
+    android:layout_width="match_parent"
+    android:layout_height="@dimen/home_screen_item_height"
+    android:gravity="center"
+    android:padding="@dimen/normal_margin"
+    android:background="@android:color/black"
+    android:textColor="@android:color/white"
+    android:textSize="@dimen/large_text_size"/>
\ No newline at end of file

app/src/main/res/layout/login_screen.xml

+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+<LinearLayout
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:layout_marginLeft="@dimen/large_margin"
+    android:layout_marginRight="@dimen/large_margin">
+
+    <ImageView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:src="@drawable/login_screen_logo"/>
+
+    <EditText
+        android:id="@+id/login_screen_username_edit_text"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:lines="1"
+        android:singleLine="true"
+        android:layout_marginTop="@dimen/normal_margin"
+        android:hint="@string/login_screen_user_name_string"/>
+
+    <EditText
+        android:id="@+id/login_screen_password_edit_text"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:inputType="textPassword"
+        android:lines="1"
+        android:singleLine="true"
+        android:layout_marginTop="@dimen/normal_margin"
+        android:hint="@string/login_screen_password_string"/>
+
+    <TextView
+        android:id="@+id/login_screen_login_text_view"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="end"
+        android:layout_marginTop="@dimen/normal_margin"
+        android:background="@color/login_screen_login_button_bg_color"
+        android:textColor="@android:color/white"
+        android:textSize="@dimen/extra_normal_text_size"
+        android:paddingBottom="@dimen/normal_margin"
+        android:paddingTop="@dimen/normal_margin"
+        android:paddingLeft="@dimen/extra_large_margin"
+        android:paddingRight="@dimen/extra_large_margin"
+        android:text="@string/login_screen_login_string"/>
+</LinearLayout>
+    </ScrollView>
\ No newline at end of file

app/src/main/res/values/arrays.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="home_screen_array">
+        <item>Report Incident</item>
+        <item>Order Services</item>
+        <item>My Incidents</item>
+        <item>My Requests</item>
+        <item>My Dashboard</item>
+    </string-array>
+</resources>
\ No newline at end of file

app/src/main/res/values/colors.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#F44336</color>
+    <color name="colorPrimaryDark">#D32F2F</color>
+    <color name="colorAccent">#FF5252</color>
+
+    <color name="error_color">#FF0000</color>
+    <color name="dark_gray_color">#A9A9A9</color>
+
+    <color name="name_null_view_color">#88FFA500</color>
+    <color name="view_not_implemented_color">#88ff0000</color>
+
+    <color name="login_screen_login_button_bg_color">@color/colorPrimary</color>
+    <color name="home_screen_bg_color">@color/colorPrimary</color>
+</resources>

app/src/main/res/values/dimen.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!--Margins-->
+    <dimen name="small_margin">5dp</dimen>
+    <dimen name="normal_margin">10dp</dimen>
+    <dimen name="large_margin">15dp</dimen>
+    <dimen name="extra_large_margin">20dp</dimen>
+
+    <!--Text size-->
+    <dimen name="small_text_size">12sp</dimen>
+    <dimen name="normal_text_size">16sp</dimen>
+    <dimen name="extra_normal_text_size">18sp</dimen>
+    <dimen name="large_text_size">20sp</dimen>
+
+    <dimen name="separator_value">1dp</dimen>
+
+    <!--Home Screen-->
+    <dimen name="home_screen_item_height">120dp</dimen>
+
+    <!--Spinner Item height-->
+    <dimen name="spinner_item_height">40dp</dimen>
+</resources>
\ No newline at end of file

app/src/main/res/values/ids.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item name="create_form_save_text_view" type="id"/>
+    <item name="create_form_cancel_text_view" type="id"/>
+</resources>
\ No newline at end of file

app/src/main/res/values/strings.xml

+<resources>
+    <string name="app_name">UofL Catalogue</string>
+
+    <string name="set_string">Set</string>
+    <string name="save_string">Save</string>
+    <string name="error_string">* Required</string>
+    <string name="none_string">-None-</string>
+    <string name="search_for_reference_string">Reference</string>
+
+    <string name="loading_string">Loading&#8230;</string>
+    <string name="select_date_string">Select Date</string>
+    <string name="select_date_and_time_string">Select Date &#038; Time</string>
+
+    <string name="name_null_view_string">Not rendering (name not available)</string>
+    <string name="view_not_implemented_string">Not Implemented: %s</string>
+    <string name="no_variables_string">No Variables&#8230;</string>
+
+    <string name="date_string">%1$s %2$s, %3$s</string>
+    <string name="date_and_time_string"> %1$s:%2$s</string>
+
+    <!--Login Screen-->
+    <string name="login_screen_user_name_string">Username</string>
+    <string name="login_screen_password_string">Password</string>
+    <string name="login_screen_login_string">Login</string>
+
+    <string name="variable_form_misc_info_string">%1$s [add %2$s]</string>
+
+    <!--Catalogue Item Screen-->
+    <string name="no_catalogue_item_string">No Catalogue Items&#8230;</string>
+
+</resources>

app/src/main/res/values/styles.xml

+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+    <style name="WhiteBackgroundStyle" parent="@style/Theme.AppCompat">
+        <item name="android:background">@android:color/white</item>
+    </style>
+
+    <style name="DatePickerCustomDialog" parent="@android:style/Theme.Dialog">
+        <item name="android:windowBackground">@android:color/white</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="editTextStyle">@android:style/Widget.EditText</item>
+    </style>
+
+    <style name="CustomDialog">
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:windowContentOverlay">@null</item>
+    </style>
+</resources>

build.gradle

+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:2.0.0'
+        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

gradle.properties

+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
\ No newline at end of file

gradle/wrapper/gradle-wrapper.properties

+#Mon Dec 28 10:00:20 PST 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip

gradlew

+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

+include ':app'