diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.gitignore b/MSS/BaseProject/Android/branches/BAFMCS_V3/.gitignore new file mode 100644 index 0000000..760c105 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.gitignore @@ -0,0 +1,14 @@ +*.iml +.gradle +/local.properties +/.idea/workspace.xml +/.idea/libraries +.DS_Store +/build +/captures +for-testing-only/build/ +google-play-services/build/ +mssbase/build/ +msscoll/build/ +mssodr/build/ +msssvy/build/ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/entries b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/entries new file mode 100644 index 0000000..48082f7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/entries @@ -0,0 +1 @@ +12 diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/format b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/format new file mode 100644 index 0000000..48082f7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/format @@ -0,0 +1 @@ +12 diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0011cca09c91ffdedbcb402394b3499b3f918c88.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0011cca09c91ffdedbcb402394b3499b3f918c88.svn-base new file mode 100644 index 0000000..9944bd0 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0011cca09c91ffdedbcb402394b3499b3f918c88.svn-base @@ -0,0 +1,139 @@ +package com.adins.mss.coll; + +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager.NameNotFoundException; +import android.os.Build; +import android.os.Bundle; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.LoginActivity; +import com.adins.mss.base.NewMainActivity; +import com.adins.mss.base.dynamictheme.DynamicTheme; +import com.adins.mss.base.dynamictheme.ThemeLoader; +import com.adins.mss.base.login.DefaultLoginModel; +import com.adins.mss.coll.login.MCDefaultLoginModel; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.GeneralParameter; +import com.adins.mss.dao.User; +import com.adins.mss.foundation.db.dataaccess.GeneralParameterDataAccess; +import com.adins.mss.foundation.db.dataaccess.UserDataAccess; +import com.adins.mss.foundation.security.storepreferences.ObscuredSharedPreferences; +import com.google.firebase.analytics.FirebaseAnalytics; + +import java.util.HashMap; + + +public class MCLoginActivity extends LoginActivity implements ThemeLoader.ColorSetLoaderCallback { + + private FirebaseAnalytics screenName; + + @Override + public void onCreate(Bundle savedInstanceState) { + //instantiate theme loader + themeLoader = new ThemeLoader(this); + + defaultConfig = new HashMap<>(); + defaultConfig.put("cipher_unsupported_device", Global.SQLITE_CIPHER_UNSUPPORTED); + this.fetchConfig(); + + PackageInfo pInfo = null; + String sqliteCipherException; + String deviceModel = Build.MODEL; + + screenName = FirebaseAnalytics.getInstance(this); + + try { + sqliteCipherException = GlobalData.getSharedGlobalData().getRemoteConfig().getString("cipher_unsupported_device"); + pInfo = getPackageManager().getPackageInfo(getPackageName(), 0); + Global.APP_VERSION = pInfo.versionName; + Global.BUILD_VERSION = pInfo.versionCode; + Global.IS_DEV = BuildConfig.IS_DEV; + Global.FLAVORS = BuildConfig.IS_FLAVORS; + Global.IS_BYPASSROOT = BuildConfig.IS_BYPASSROOT; + Global.IS_DBENCRYPT = (!sqliteCipherException.contains(deviceModel)) && BuildConfig.IS_DBENCRYPT; + } catch (NameNotFoundException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + if(Global.AUTOLOGIN_ENABLE){ + NewMainActivity.setMainMenuClass(NewMCMainActivity.class); + ObscuredSharedPreferences sharedPref = ObscuredSharedPreferences.getPrefs(getApplicationContext(), + "GlobalData", Context.MODE_PRIVATE); + hasLogged = sharedPref.getBoolean("HAS_LOGGED", false); + if (hasLogged /*&& GlobalData.getSharedGlobalData().getUser() != null*/) { + super.onCreate(savedInstanceState); + NewMainActivity.InitializeGlobalDataIfError(getApplicationContext()); + + String uuidUser = GlobalData.getSharedGlobalData().getUser() == null ? sharedPref.getString("UUID_USER", "") : GlobalData.getSharedGlobalData().getUser().getUuid_user(); + //check theme config. + GeneralParameter generalParameter = GeneralParameterDataAccess.getOne(this, uuidUser, + Global.GS_THEME_CONFIG_COLLECTION); + + if(generalParameter != null){ + String urlConfig = generalParameter.getGs_value(); + themeLoader.loadThemeFromUrl(urlConfig,this); + } + else {//go to main activity + Intent intent = new Intent(getApplicationContext(), NewMCMainActivity.class); + startActivity(intent); + finish(); + } + } + else {//load directly login page and load saved theme + super.onCreate(savedInstanceState); + logo.setImageResource(com.adins.mss.base.R.drawable.icon_coll_act); + try { + loadSavedTheme(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + else {//load directly login page and load saved theme + super.onCreate(savedInstanceState); + logo.setImageResource(com.adins.mss.base.R.drawable.icon_coll_act); + loadSavedTheme(); + } + } + + private void loadSavedTheme(){ + if(themeLoader != null){ + themeLoader.loadSavedColorSet(this); + } + } + + @Override + protected DefaultLoginModel getNewDefaultLoginModel(Context context) { + // TODO Auto-generated method stub + return new MCDefaultLoginModel(this); + } + + @Override + public void onHasLoaded(DynamicTheme dynamicTheme) {//callback load from local db + if(dynamicTheme != null && dynamicTheme.getThemeItemList().size() > 0){ + applyColorTheme(dynamicTheme); + } + } + + @Override + public void onHasLoaded(DynamicTheme dynamicTheme, boolean needUpdate) {//callback load from server + Intent intent = new Intent(getApplicationContext(), NewMCMainActivity.class); + startActivity(intent); + finish(); + } + + @Override + public void onResume() { + super.onResume(); + + //Set Firebase screen name + screenName.setCurrentScreen(this,getString(R.string.screen_name_coll_login),null); + + defaultConfig = new HashMap<>(); + defaultConfig.put("cipher_unsupported_device", Global.SQLITE_CIPHER_UNSUPPORTED); + this.fetchConfig(); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0059d8bfbd49bc61b23ec3bbd52a1f6a80e64008.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0059d8bfbd49bc61b23ec3bbd52a1f6a80e64008.svn-base new file mode 100644 index 0000000..a7b8a2b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0059d8bfbd49bc61b23ec3bbd52a1f6a80e64008.svn-base @@ -0,0 +1,13 @@ +package com.adins.mss.odr; + +import android.app.Application; +import android.test.ApplicationTestCase; + +/** + * Testing Fundamentals + */ +public class ApplicationTest extends ApplicationTestCase { + public ApplicationTest() { + super(Application.class); + } +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007168360eaea3951f81aac6f6425f83421e7cd8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007168360eaea3951f81aac6f6425f83421e7cd8.svn-base new file mode 100644 index 0000000..9efd34b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007168360eaea3951f81aac6f6425f83421e7cd8.svn-base @@ -0,0 +1,256 @@ +package com.adins.mss.base.timeline; + +import android.app.Activity; +import android.content.Context; +import android.graphics.Bitmap; +import android.os.AsyncTask; +import android.text.format.DateFormat; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.todolist.ToDoList; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.Timeline; +import com.adins.mss.dao.User; +import com.adins.mss.foundation.db.dataaccess.GeneralParameterDataAccess; +import com.adins.mss.foundation.db.dataaccess.UserDataAccess; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.image.Utils; + +import org.acra.ACRA; + +import java.util.Calendar; +import java.util.Collections; +import java.util.List; + +/** + * Created by kusnendi.muhamad on 26/07/2017. + */ + +public class TimelineImpl implements TimelineInterface { + + private static String tempUuidUser; + private Activity activity; + private Context context; + private Bitmap bitmap; + private List timelines; + private String cashLimit; + private String coh; + private double limit; + private double cashOnHand; + private String sLimit; + private String sCOH; + private TimelineListener timelineListener; + private int position = 0; + private NewTimelineFragment timelineFragment; + private static final String DATE_TIME_FORMAT = "yyyy.MM.dd G \'at\' HH:mm:ss z"; + private static final String ERROR_REFRESH_BACKGROUND = "errorRefreshBackgroundTask"; + + public TimelineImpl(Activity activity) { + this.activity = activity; + } + + public TimelineImpl(Activity activity, TimelineListener timelineListener) { + this.activity = activity; + this.timelineListener = timelineListener; + } + + public int getPosition() { + return position; + } + + public void setPosition(int position) { + this.position = position; + } + + public User getUser() { + setTempUuidUser(GlobalData.getSharedGlobalData().getUser().getUuid_user()); + return UserDataAccess.getOne(context, getTempUuidUser()); + } + + @Override + public boolean isCOHAktif() { + String parameter = GeneralParameterDataAccess.getOne(activity, GlobalData.getSharedGlobalData().getUser().getUuid_user(), + Global.GS_CASHONHAND).getGs_value(); + return parameter != null && parameter.equals(Global.TRUE_STRING); + } + + @Override + public AsyncTask refreshImageBitmap(final int viewId, final int defaultDrawable, final byte[] byteImage) { + return new AsyncTask() { + @Override + protected Bitmap doInBackground(Void... args) { + if (byteImage != null) { + try { + return Utils.byteToBitmap(byteImage); + } catch (OutOfMemoryError ex) { + ex.printStackTrace(); + ACRA.getErrorReporter().putCustomData("errorOutOfMemory", ex.getMessage()); + ACRA.getErrorReporter().putCustomData("errorOutOfMemory", DateFormat.format(DATE_TIME_FORMAT, Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception OutOfMemory")); + return null; + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + ACRA.getErrorReporter().putCustomData("errorConvertingByteToBitmap", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorConvertingByteToBitmap", DateFormat.format(DATE_TIME_FORMAT, Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat convert byte to bitmap")); + return null; + } + + } else { + return null; + } + } + + @Override + protected void onPostExecute(Bitmap res) { + super.onPostExecute(res); + if (res != null) { + setBitmap(res); + timelineListener.onSuccessImageBitmap(res, viewId, defaultDrawable); + } + } + }; + } + + @Override + public AsyncTask> refreshBackgroundTask() { + final int TASK_DURATION = 2 * 1000; // 2 seconds + return new AsyncTask>() { + @Override + protected List doInBackground(Void... params) { + // Sleep for a small amount of time to simulate a background-task + try { + Thread.sleep(TASK_DURATION); + } catch (InterruptedException e) { + e.printStackTrace(); + Thread.currentThread().interrupt(); + ACRA.getErrorReporter().putCustomData(ERROR_REFRESH_BACKGROUND, e.getMessage()); + ACRA.getErrorReporter().putCustomData(ERROR_REFRESH_BACKGROUND, DateFormat.format(DATE_TIME_FORMAT, Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set Thread.sleep")); + } + try { + int range = GlobalData.getSharedGlobalData().getKeepTimelineInDays(); + position = getPosition(); + timelineFragment = new NewTimelineFragment(); + return timelineFragment.getTimeline(position, range); + + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + ACRA.getErrorReporter().putCustomData(ERROR_REFRESH_BACKGROUND, e.getMessage()); + ACRA.getErrorReporter().putCustomData(ERROR_REFRESH_BACKGROUND, DateFormat.format(DATE_TIME_FORMAT, Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set range")); + } + + return Collections.emptyList(); + } + + @Override + protected void onPostExecute(List records) { + super.onPostExecute(records); + if (records != null) { + setTimelines(records); + timelineListener.onSuccessBackgroundTask(records); + } + } + }; + } + + public void setCashOnHand() { + try { + setCashLimit(GlobalData.getSharedGlobalData().getUser().getCash_limit()); + setLimit(cashLimit != null ? Double.parseDouble(cashLimit) : 0.0); + setCoh(GlobalData.getSharedGlobalData().getUser().getCash_on_hand()); + setCashOnHand(coh != null ? Double.parseDouble(coh) : 0.0); + setsLimit(Tool.separateThousand(limit)); + setsCOH(Tool.separateThousand(cashOnHand)); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + + public List getTimelines() { + return timelines; + } + + public void setTimelines(List timelines) { + this.timelines = timelines; + } + + public Bitmap getBitmap() { + return bitmap; + } + + public void setBitmap(Bitmap bitmap) { + this.bitmap = bitmap; + } + + public void setContext(Context context) { + this.context = context; + } + + public String getCashLimit() { + return cashLimit; + } + + public void setCashLimit(String cashLimit) { + this.cashLimit = cashLimit; + } + + public String getCoh() { + return coh; + } + + public void setCoh(String coh) { + this.coh = coh; + } + + public double getCashOnHand() { + return cashOnHand; + } + + public void setCashOnHand(double cashOnHand) { + this.cashOnHand = cashOnHand; + } + + public double getLimit() { + return limit; + } + + public void setLimit(double limit) { + this.limit = limit; + } + + public String getsLimit() { + return sLimit; + } + + public void setsLimit(String sLimit) { + this.sLimit = sLimit; + } + + public String getsCOH() { + return sCOH; + } + + public void setsCOH(String sCOH) { + this.sCOH = sCOH; + } + + public long getTaskListCounter() { + return ToDoList.getAllCounter(activity); + } + + + public static String getTempUuidUser() { + return tempUuidUser; + } + + public static void setTempUuidUser(String tempUuidUser) { + TimelineImpl.tempUuidUser = tempUuidUser; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007cb8818cf416314c10446c3fe7294ba9c212b5.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007cb8818cf416314c10446c3fe7294ba9c212b5.svn-base new file mode 100644 index 0000000..6dadbd3 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/007cb8818cf416314c10446c3fe7294ba9c212b5.svn-base @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0088ee4e59b0defd8a1256bff22c21659e824ce0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0088ee4e59b0defd8a1256bff22c21659e824ce0.svn-base new file mode 100644 index 0000000..5000446 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/0088ee4e59b0defd8a1256bff22c21659e824ce0.svn-base @@ -0,0 +1,772 @@ +package com.adins.mss.base.todolist.form; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import com.google.android.material.bottomnavigation.BottomNavigationView; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentTransaction; +import androidx.swiperefreshlayout.widget.SwipeRefreshLayout; +import androidx.appcompat.app.AlertDialog; +import androidx.appcompat.widget.AppCompatSpinner; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import androidx.appcompat.widget.Toolbar; +import android.text.format.DateFormat; +import android.util.DisplayMetrics; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.view.Window; +import android.view.WindowManager; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.RelativeLayout; +import android.widget.TextView; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.NewMainActivity; +import com.adins.mss.base.R; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.dynamicform.CustomerFragment; +import com.adins.mss.base.dynamicform.SurveyHeaderBean; +import com.adins.mss.base.dynamicform.TaskManager; +import com.adins.mss.base.dynamicform.newlead.NewLeadFragment; +import com.adins.mss.base.timeline.TimelineImpl; +import com.adins.mss.base.timeline.TimelineInterface; +import com.adins.mss.base.todolist.ToDoList; +import com.adins.mss.base.util.Utility; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.GeneralParameter; +import com.adins.mss.dao.Scheme; +import com.adins.mss.dao.TaskD; +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.db.dataaccess.SchemeDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskDDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.dialog.DialogManager; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder_PL; +import com.adins.mss.foundation.formatter.Tool; + +import org.acra.ACRA; + +import java.util.ArrayList; +import java.util.Calendar; +import java.util.List; + +/** + * Created by muhammad.aap on 11/12/2018. + */ + +public class NewToDoListTabFragment extends Fragment implements OnTaskListClickListener, TasklistListener { + public static final String uuidSchemeDummy = "schemeDummy"; + private static final String ARG_COLUMN_COUNT = "column-count"; + public static ToDoList toDoList; + private List listTaskH; + public static Handler mHandler; + private static String param; + private SwipeRefreshLayout mSwipeRefreshLayout; + public static NewToDoListViewAdapter viewAdapter; + public NewToDoListTabFragment.FormAdapter formAdapter; + public NewToDoListTabFragment.NewToDoListAdapter newToDoListAdapter; + private List formListName; + private static Scheme selectedScheme; + private TextView textView; + private RecyclerView recyclerView; + private RelativeLayout layout; + private TextView dataNotFound; + private boolean isNewToDoListOpen = false; + public static NewToDoListTabFragment.NewToDoListHandler handler; + private TasklistInterface iTasklist; + private TimelineInterface iTimeline; + + private static Menu mainMenu; + public static boolean isMenuClicked = false; + + private BottomNavigationView bottomNav; + + private int formPosition = 0; + public static int taskPosition = 0; + + @SuppressWarnings("unused") + public static NewToDoListTabFragment newInstance(int columnCount) { + NewToDoListTabFragment fragment = new NewToDoListTabFragment(); + Bundle args = new Bundle(); + args.putInt(ARG_COLUMN_COUNT, Integer.parseInt(param)); + fragment.setArguments(args); + return fragment; + } + + private void setToolbar() { + getActivity().findViewById(R.id.search).setVisibility(View.VISIBLE); + getActivity().findViewById(R.id.spinner).setVisibility(View.GONE); + getActivity().setTitle(""); + + // olivia : set tampilan toolbar untuk masing" density + DisplayMetrics displayMetrics = new DisplayMetrics(); + getActivity().getWindowManager().getDefaultDisplay().getMetrics(displayMetrics); + switch (displayMetrics.densityDpi) { + case DisplayMetrics.DENSITY_MEDIUM: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(200, Toolbar.LayoutParams.WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_HIGH: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(300, Toolbar.LayoutParams.WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XHIGH: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(470, Toolbar.LayoutParams.WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XXHIGH: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(710, Toolbar.LayoutParams.WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XXXHIGH: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(950, Toolbar.LayoutParams.WRAP_CONTENT)); + break; + default: + break; + } + } + + @Override + public void onPrepareOptionsMenu(Menu menu) { + super.onPrepareOptionsMenu(menu); + mainMenu = menu; + menu.findItem(R.id.menuMore).setVisible(true); + setToolbar(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + // Handle item selection + if(isMenuClicked == false){ + int id = item.getItemId(); + if (id == R.id.menuMore) { + mainMenu.findItem(R.id.mnViewMap).setVisible(true); + isMenuClicked=false; + } + if (id == R.id.mnViewMap) { + MapsViewerFragment fragment = new MapsViewerFragment(); + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + isMenuClicked=true; + } + // olivia : menu View All Header sdh tidak digunakan karena hampir sama dgn Task List + else if (id == R.id.mnViewAllHeader) { + AllHeaderViewerFragment viewerFragment = AllHeaderViewerFragment.newInstance(AllHeaderViewerFragment.REQ_PRIORITY_LIST); + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, viewerFragment); + transaction.addToBackStack(null); + transaction.commit(); + isMenuClicked=true; + } + + } + return super.onOptionsItemSelected(item); + } + + @Override + public void onPause() { + super.onPause(); + isNewToDoListOpen = false; + bottomNav.getMenu().findItem(R.id.taskListNav).setEnabled(true); + + if (mSwipeRefreshLayout != null) { + mSwipeRefreshLayout.setRefreshing(false); + mSwipeRefreshLayout.destroyDrawingCache(); + mSwipeRefreshLayout.clearAnimation(); + } + } + + @Override + public void onResume() { + super.onResume(); + isNewToDoListOpen = true; + isMenuClicked = false; + setToolbar(); + + bottomNav.getMenu().findItem(R.id.taskListNav).setEnabled(false); + + listTaskH = iTasklist.getSelectedTaskH(taskPosition); + viewAdapter = new NewToDoListViewAdapter(getActivity(), listTaskH, NewToDoListTabFragment.this, param); + recyclerView.setAdapter(viewAdapter); + viewAdapter.notifyDataSetChanged(); + initBackground(listTaskH); + + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (Global.APPLICATION_COLLECTION.equalsIgnoreCase(application)) { + try { + setCashOnHandUI(); + } catch (Exception e) { + FireCrash.log(e); + ACRA.getErrorReporter().putCustomData("errorOnResume", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorOnResume", DateFormat.format("yyyy.MM.dd G \'at\' HH:mm:ss z", Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat Set Cash UI")); + } + } + try { + NewMainActivity.setCounter(); + } catch (Exception e) { + ACRA.getErrorReporter().putCustomData("ErrorMainMenuActivity", e.getMessage()); + ACRA.getErrorReporter().putCustomData("ErrorMainMenuActivity", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set Drawer Counter")); + } + DialogManager.showTimeProviderAlert(getActivity()); + } + + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + Fragment fragment = this; + iTasklist = new TasklistImpl(fragment, this); + iTimeline = new TimelineImpl(getActivity()); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + param = iTasklist.getParam(); + toDoList = iTasklist.getTodoList(); + listTaskH = new ArrayList<>(); + + mHandler = new Handler(); + + try { + listTaskH = iTasklist.getTaskH(null, 0); + ViewMapActivity.setListTaskH(listTaskH); + } catch (Exception e) { + ACRA.getErrorReporter().putCustomData("ErrorOnCreate", e.getMessage()); + ACRA.getErrorReporter().putCustomData("ErrorOnCreate", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set List TaskH")); + if (Global.IS_DEV) + e.printStackTrace(); + } + + formListName = new ArrayList<>(); + formListName.clear(); + setAllschemeSpinner(); + formListName.addAll(SchemeDataAccess.getAllActivePriorityScheme(getActivity())); + viewAdapter = new NewToDoListViewAdapter(getActivity(), listTaskH, this, param); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View view = inflater.inflate(R.layout.new_fragment_task_list, container, false); + + bottomNav = (BottomNavigationView) getActivity().findViewById(R.id.bottomNav); + + // olivia : untuk trigger dialog search ketika klik layout search di toolbar + textView = (TextView) getActivity().findViewById(R.id.searchTask); + textView.setText(getString(R.string.all_form_all_task)); + taskPosition = 0; + formPosition = 0; + getActivity().findViewById(R.id.buttonSearch).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + searchDialog(); + } + }); + + // Set the adapter + if (view instanceof RelativeLayout) { + handler = new NewToDoListTabFragment.NewToDoListHandler(); + Context context = view.getContext(); + recyclerView = (RecyclerView) view.findViewById(R.id.listTask); + layout = (RelativeLayout) view.findViewById(R.id.layout); + dataNotFound = (TextView) view.findViewById(R.id.txv_data_not_found); + recyclerView.setLayoutManager(new LinearLayoutManager(context)); + recyclerView.getRecycledViewPool().setMaxRecycledViews(1, 500); + recyclerView.setHasFixedSize(true); + + initBackground(listTaskH); + recyclerView.setLayoutManager(new LinearLayoutManager(context)); + recyclerView.setAdapter(viewAdapter); + mSwipeRefreshLayout = (SwipeRefreshLayout) view.findViewById(R.id.refreshTimeline); + mSwipeRefreshLayout.setColorSchemeColors(getResources().getColor(R.color.tv_light), + getResources().getColor(R.color.tv_normal), + getResources().getColor(R.color.tv_dark), + getResources().getColor(R.color.tv_darker)); + mSwipeRefreshLayout + .setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() { + @Override + public void onRefresh() { + iTasklist.setSelectedScheme(selectedScheme); + iTasklist.setSelectedTask(taskPosition); + iTasklist.initiateRefresh(true); + } + }); + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (Global.APPLICATION_COLLECTION.equalsIgnoreCase(application)) { + try { + setCashOnHandUI(); + } catch (Exception e) { + ACRA.getErrorReporter().putCustomData("errorOnResume", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorOnResume", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat Set Cash UI")); + e.printStackTrace(); + } + } + } + return view; + } + + public void initBackground(List taskHList) { + if (taskHList.size() == 0) { + layout.setBackgroundResource(R.drawable.bg_notfound); + } else { + layout.setBackgroundResource(R.color.bgColor); + } + } + + // olivia : melakukan search sesuai value di dropdown + public void doSearch() { + selectedScheme = formAdapter.getItem(formPosition); + iTasklist.setSelectedScheme(selectedScheme); + iTasklist.cancelRefreshTask(); + iTasklist.setSelectedTask(taskPosition); + listTaskH = iTasklist.getSelectedTaskH(taskPosition); + + viewAdapter = new NewToDoListViewAdapter(getActivity(), listTaskH, NewToDoListTabFragment.this, param); + recyclerView.setAdapter(viewAdapter); + viewAdapter.notifyDataSetChanged(); + initBackground(listTaskH); + } + + public void setAdapter(String[] listTask) { + formListName = new ArrayList<>(); + formListName.clear(); + setAllschemeSpinner(); + formListName.addAll(SchemeDataAccess.getAllActivePriorityScheme(getActivity())); + newToDoListAdapter = new NewToDoListTabFragment.NewToDoListAdapter(getActivity(), R.layout.spinner_style2, listTask); + newToDoListAdapter.setDropDownViewResource(R.layout.spinner_style); + formAdapter = new NewToDoListTabFragment.FormAdapter(getActivity(), R.layout.spinner_style2, R.id.text_spin, formListName); + formAdapter.setDropDownViewResource(R.layout.spinner_style); + } + + @Override + public void onRefreshBackgroundCancelled(boolean value) { + if (mSwipeRefreshLayout != null && mSwipeRefreshLayout.isRefreshing()) + mSwipeRefreshLayout.setRefreshing(false); + } + + @Override + public void onRefreshBackgroundComplete(List result) { + onRefreshComplete(result); + initBackground(listTaskH); + } + + private void setCashOnHandUI() { + iTimeline.setCashOnHand(); + } + + private void setAllschemeSpinner() { + Scheme schemeDummy = new Scheme(); + schemeDummy.setUuid_scheme(uuidSchemeDummy); + schemeDummy.setScheme_description(getString(R.string.all_form)); + schemeDummy.setForm_id("schemeDummy"); + + formListName.add(0, schemeDummy); + } + + @Override + public void onAttach(Context context) { + super.onAttach(context); + setHasOptionsMenu(true); + } + + @Override + public void onDetach() { + super.onDetach(); + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + iTasklist.cancelRefreshTask(); + Utility.freeMemory(); + try { + mainMenu.findItem(R.id.menuMore).setVisible(false); + } catch (Exception e) { + } + bottomNav.getMenu().findItem(R.id.taskListNav).setEnabled(true); + } + + @Override + public void onItemClickListener(TaskH item, int position) { + try { + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (Global.APPLICATION_COLLECTION.equalsIgnoreCase(application) && iTimeline.isCOHAktif() && iTimeline.getLimit() > 0 && iTimeline.getCashOnHand() >= iTimeline.getLimit()) { + DialogManager.showAlertNotif(getActivity(), getActivity().getString(R.string.limit_coh), "Cash On Hand"); + } else { + Scheme scheme = null; + scheme = item.getScheme(); + if (scheme == null) { + if (item.getUuid_scheme() != null) { + scheme = SchemeDataAccess.getOne(getActivity(), + item.getUuid_scheme()); + if (scheme != null) + item.setScheme(scheme); + } + } + + if (scheme == null) { + Toast.makeText(getActivity(), getActivity().getString(R.string.task_cant_seen), + Toast.LENGTH_SHORT).show(); + } else { + if (!GlobalData.getSharedGlobalData().getDoingTask()) { + SurveyHeaderBean header = new SurveyHeaderBean(item); + Fragment fragment = null; + if (GlobalData.getSharedGlobalData().getApplication().equals(Global.APPLICATION_ORDER)) + fragment = NewLeadFragment.create(header); + else + fragment = CustomerFragment.create(header); + FragmentTransaction transaction = getFragmentManager().beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + } + } + } catch (Exception e) { + ACRA.getErrorReporter().putCustomData("errorClickListener", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorClickListener", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat click item")); + String message = e.getMessage(); + Toast.makeText(getActivity(), message, Toast.LENGTH_SHORT).show(); + } + } + + @Override + public void onItemLongClickListener(final TaskH item, int position) { + try { + if(item.getStatus().equals(TaskHDataAccess.STATUS_SEND_UPLOADING)){ + try { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.info_capital)) + .withMessage(getActivity().getString(R.string.confirm_upload)+" "+item.getCustomer_name()+" ?") + .withButton1Text(getActivity().getString(R.string.btnYes)) + .withButton2Text(getActivity().getString(R.string.btnCancel)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + if (Tool.isInternetconnected(getActivity())) { + if (Global.isIsUploading() || Global.isIsManualUploading()) { + Toast.makeText(getActivity(), getActivity().getString(R.string.upload_on_queue), Toast.LENGTH_SHORT).show(); + } else { + try { + List taskd = TaskDDataAccess.getUnsentImageByTaskH(getActivity(), item.getUuid_user(), item.getUuid_task_h()); + TaskManager.ManualUploadImage(getActivity(), taskd); + for (int i = 1; i < getActivity().getSupportFragmentManager().getBackStackEntryCount(); i++) + getActivity().getSupportFragmentManager().popBackStack(); + } catch (Exception e) { + Toast.makeText(getActivity(), getActivity().getString(R.string.request_error), Toast.LENGTH_SHORT).show(); + } + } + } else { + Toast.makeText(getActivity(), getActivity().getString(R.string.no_internet_connection), Toast.LENGTH_SHORT).show(); + } + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } catch (Exception e) { + e.printStackTrace(); + } + }else if(item.getStatus().equals(TaskHDataAccess.STATUS_SEND_PENDING)){ + String btnText1 = getActivity().getString(R.string.btnSend); + if(item.getIs_prepocessed()!= null && item.getIs_prepocessed().equals(Global.FORM_TYPE_VERIFICATION)) + btnText1 = getActivity().getString(R.string.verifyBtn); + else if(item.getIs_prepocessed()!= null && item.getIs_prepocessed().equals(Global.FORM_TYPE_APPROVAL)) + btnText1 = getActivity().getString(R.string.approveBtn); + final NiftyDialogBuilder_PL dialogBuilder = NiftyDialogBuilder_PL.getInstance(getActivity()); + dialogBuilder.withNoTitle() + .withNoMessage() + .withButton1Text(btnText1) + .withButton2Text(getActivity().getString(R.string.btnDelete)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + if (Tool.isInternetconnected(getActivity())) { + if(item.getTask_id()!=null) { + if(item.getIs_prepocessed() != null && item.getIs_prepocessed().equals(Global.FORM_TYPE_VERIFICATION)) { + if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK)) + new TaskManager().sendApprovalTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK, false, item.getVerification_notes()); + else if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY)) + new TaskManager().sendRejectedWithReSurveyTask(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY, Global.VERIFICATION_FLAG); + else + new TaskManager.ForceSendTaskOnBackground(getActivity(), item.getTask_id()).execute(); + } else if(item.getIs_prepocessed() != null && item.getIs_prepocessed().equals(Global.FORM_TYPE_APPROVAL)) { + if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK)) + new TaskManager().sendApprovalTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK, true, item.getVerification_notes()); + else if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY)) + new TaskManager().sendRejectedWithReSurveyTask(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY, Global.APPROVAL_FLAG); + else + new TaskManager().sendApprovalTaskOnBackground(getActivity(), item, Global.FLAG_FOR_APPROVALTASK, true, item.getVerification_notes()); + } else + new TaskManager.ForceSendTaskOnBackground(getActivity(), item.getTask_id()).execute(); + + for (int i = 1; i < getActivity().getSupportFragmentManager().getBackStackEntryCount(); i++) + getActivity().getSupportFragmentManager().popBackStack(); + + getActivity().runOnUiThread(new Runnable() { + @Override + public void run() { + listTaskH.clear(); + listTaskH.addAll(iTasklist.getSelectedTaskH(0)); + viewAdapter.notifyDataSetChanged(); + } + }); + } + } else{ + Toast.makeText(getActivity(), getActivity().getString(R.string.no_internet_connection), Toast.LENGTH_SHORT).show(); + } + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + TaskHDataAccess.deleteWithRelation(getActivity(), item); + if(item.getTask_id()!=null) + ToDoList.removeSurveyFromList(item.getTask_id()); + iTasklist.setSelectedScheme(selectedScheme); + iTasklist.setSelectedTask(taskPosition); + iTasklist.initiateRefresh(true); + dialogBuilder.dismiss(); + } + }).show(); + }else if (item.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT)){ + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.info_capital)) + .withMessage(getActivity().getString(R.string.confirm_delete)+" "+item.getCustomer_name()+" ?") + .withButton1Text(getActivity().getString(R.string.btnYes)) + .withButton2Text(getActivity().getString(R.string.btnCancel)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + TaskHDataAccess.deleteWithRelation(getActivity(), item); + ToDoList.removeSurveyFromList(item.getTask_id()); + iTasklist.setSelectedScheme(selectedScheme); + iTasklist.setSelectedTask(taskPosition); + iTasklist.initiateRefresh(true); + dialogBuilder.dismiss(); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } + } catch (Exception ex) { + FireCrash.log(ex); + } + } + + private void onRefreshComplete(List result) { + try { + listTaskH.clear(); + listTaskH = result; + viewAdapter = new NewToDoListViewAdapter(getActivity(), listTaskH, NewToDoListTabFragment.this, param); + recyclerView.setAdapter(viewAdapter); + + viewAdapter.notifyDataSetChanged(); + } catch (UnsupportedOperationException e) { + try { + viewAdapter.notifyDataSetChanged(); + } catch (Exception e2) { + ACRA.getErrorReporter().putCustomData("ErrorOnRefreshCompleted", e.getMessage()); + ACRA.getErrorReporter().putCustomData("ErrorOnRefreshCompleted", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set Notify Data Set Changed")); + } + } catch (Exception e) { + try { + viewAdapter.notifyDataSetChanged(); + } catch (Exception e2) { + ACRA.getErrorReporter().putCustomData("ErrorOnRefreshCompleted", e.getMessage()); + ACRA.getErrorReporter().putCustomData("ErrorOnRefreshCompleted", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat set Notify Data Set Changed")); + } + } + // Stop the refreshing indicator + if (mSwipeRefreshLayout != null && mSwipeRefreshLayout.isRefreshing()) + mSwipeRefreshLayout.setRefreshing(false); + } + + public void searchDialog() { + final AlertDialog dialog = new AlertDialog.Builder(getActivity(), R.style.Dialog_NoTitle) + .setView(R.layout.new_dialog_search) + .create(); + dialog.requestWindowFeature(Window.FEATURE_NO_TITLE); + WindowManager.LayoutParams wmlp = dialog.getWindow().getAttributes(); + wmlp.gravity = Gravity.BOTTOM; + wmlp.windowAnimations = R.style.DialogAnimation; + dialog.show(); + dialog.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT); + + final AppCompatSpinner searchForm = (AppCompatSpinner) dialog.findViewById(R.id.spinnerForm); + final AppCompatSpinner searchTask = (AppCompatSpinner) dialog.findViewById(R.id.spinnerTask); + Button search = (Button) dialog.findViewById(R.id.btnSearch); + + String[] listTask = getActivity().getResources().getStringArray(R.array.taskSearch); + + newToDoListAdapter = new NewToDoListTabFragment.NewToDoListAdapter(getActivity(), R.layout.spinner_style2, listTask); + newToDoListAdapter.setDropDownViewResource(R.layout.spinner_style); + formAdapter = new NewToDoListTabFragment.FormAdapter(getActivity(), R.layout.spinner_style2, R.id.text_spin, formListName); + formAdapter.setDropDownViewResource(R.layout.spinner_style); + + searchForm.setAdapter(formAdapter); + searchTask.setAdapter(newToDoListAdapter); + + searchForm.setSelection(formPosition); + searchTask.setSelection(taskPosition); + + search.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + taskPosition = searchTask.getSelectedItemPosition(); + formPosition = searchForm.getSelectedItemPosition(); + + Scheme scheme = (Scheme) searchForm.getSelectedItem(); + + textView.setText(scheme.getScheme_description() + " . " + searchTask.getSelectedItem().toString()); + + doSearch(); + dialog.dismiss(); + } + }); + } + + public class FormAdapter extends ArrayAdapter { + private Activity activity; + private List values; + + public FormAdapter(Activity activity, int resource, int textViewResourceId, List objects) { + super(activity, resource, textViewResourceId, objects); + this.activity = activity; + this.values = objects; + } + + public int getCount() { + return values.size(); + } + + public Scheme getItem(int position) { + return values.get(position); + } + + public long getItemId(int position) { + return position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = activity.getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style2, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getScheme_description()); + return label; + } + + @Override + public View getDropDownView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = activity.getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getScheme_description()); + return label; + } + } + + public class NewToDoListAdapter extends ArrayAdapter { + private Activity activity; + private String[] values; + + public NewToDoListAdapter(Activity activity, int resource, String[] objects) { + super(activity, resource, objects); + this.activity = activity; + this.values = objects; + } + + public int getCount() { + return values.length; + } + + public String getItem(int position) { + return values[position]; + } + + public long getItemId(int position) { + return position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = activity.getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style2, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values[position]); + return label; + } + + @Override + public View getDropDownView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = activity.getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values[position]); + return label; + } + } + + public static NewToDoListTabFragment.NewToDoListHandler getHandler() { + return handler; + } + + public static void setHandler(NewToDoListTabFragment.NewToDoListHandler handler) { + NewToDoListTabFragment.handler = handler; + } + + public class NewToDoListHandler extends Handler { + + @Override + public void handleMessage(Message msg) { + try { + if (isNewToDoListOpen) { + iTasklist.initiateRefresh(false); + } + } catch (Exception e) { + FireCrash.log(e); + ACRA.getErrorReporter().putCustomData("errorRefresh", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorRefresh", Tool.getSystemDateTime().toLocaleString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat initiate Refresh")); + } + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00913980b24056f1d3d6c6045ef3ebe769a20db0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00913980b24056f1d3d6c6045ef3ebe769a20db0.svn-base new file mode 100644 index 0000000..bad450e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00913980b24056f1d3d6c6045ef3ebe769a20db0.svn-base @@ -0,0 +1,75 @@ +package com.adins.mss.foundation.db.dataaccess; + +import android.content.Context; + +import com.adins.mss.dao.Account; +import com.adins.mss.dao.AccountDao; +import com.adins.mss.dao.DaoSession; +import com.adins.mss.foundation.db.DaoOpenHelper; + +import java.util.List; + +import de.greenrobot.dao.query.QueryBuilder; + +/** + * Created by olivia.dg on 11/16/2017. + */ + +public class AccountDataAccess { + + protected static DaoSession getDaoSession(Context context){ + return DaoOpenHelper.getDaoSession(context); + } + + protected static AccountDao getAccountDao(Context context) { + return getDaoSession(context).getAccountDao(); + } + + public static void add(Context context, Account account){ + getAccountDao(context).insert(account); + getDaoSession(context).clear(); + } + + public static void add(Context context, List accountList){ + getAccountDao(context).insertInTx(accountList); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, Account account){ + getAccountDao(context).insertOrReplaceInTx(account); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, List accountList){ + getAccountDao(context).insertOrReplaceInTx(accountList); + getDaoSession(context).clear(); + } + + public static void clean(Context context){ + getAccountDao(context).deleteAll(); + } + + public static void delete(Context context, Account account){ + getAccountDao(context).delete(account); + getDaoSession(context).clear(); + } + + public static void update(Context context, Account account){ + getAccountDao(context).update(account); + } + + public static List getAll(Context context){ + QueryBuilder qb = getAccountDao(context).queryBuilder(); + qb.build(); + return qb.list(); + } + + public static Account getOne(Context context, String uuid){ + QueryBuilder qb = getAccountDao(context).queryBuilder(); + qb.where(AccountDao.Properties.Uuid_account.eq(uuid)); + qb.build(); + + if ((qb.list() == null) || qb.list().isEmpty()) return null; + return qb.list().get(0); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/009781c8c032ba62ef682ec4916c357ee93b319b.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/009781c8c032ba62ef682ec4916c357ee93b319b.svn-base new file mode 100644 index 0000000..46e97bf --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/009781c8c032ba62ef682ec4916c357ee93b319b.svn-base @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00b8702c4f6c5038553ea73f2188338584a68994.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00b8702c4f6c5038553ea73f2188338584a68994.svn-base new file mode 100644 index 0000000..6cf28fd --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00b8702c4f6c5038553ea73f2188338584a68994.svn-base @@ -0,0 +1,288 @@ +package com.adins.mss.dao; + +import java.util.List; +import java.util.ArrayList; +import android.database.Cursor; + +import de.greenrobot.dao.AbstractDao; +import de.greenrobot.dao.Property; +import de.greenrobot.dao.internal.SqlUtils; +import de.greenrobot.dao.internal.DaoConfig; +import de.greenrobot.dao.database.Database; +import de.greenrobot.dao.database.DatabaseStatement; +import de.greenrobot.dao.query.Query; +import de.greenrobot.dao.query.QueryBuilder; + +import com.adins.mss.dao.ErrorLog; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. +/** + * DAO for table "TR_ERROR_LOG". +*/ +public class ErrorLogDao extends AbstractDao { + + public static final String TABLENAME = "TR_ERROR_LOG"; + + /** + * Properties of entity ErrorLog.
+ * Can be used for QueryBuilder and for referencing column names. + */ + public static class Properties { + public final static Property Uuid_error_log = new Property(0, String.class, "uuid_error_log", true, "UUID_ERROR_LOG"); + public final static Property Error_description = new Property(1, String.class, "error_description", false, "ERROR_DESCRIPTION"); + public final static Property Device_name = new Property(2, String.class, "device_name", false, "DEVICE_NAME"); + public final static Property Dtm_activity = new Property(3, java.util.Date.class, "dtm_activity", false, "DTM_ACTIVITY"); + public final static Property Uuid_user = new Property(4, String.class, "uuid_user", false, "UUID_USER"); + public final static Property Task_id = new Property(5, String.class, "task_id", false, "TASK_ID"); + }; + + private DaoSession daoSession; + + private Query user_ErrorLogListQuery; + private Query taskH_ErrorLogListQuery; + + public ErrorLogDao(DaoConfig config) { + super(config); + } + + public ErrorLogDao(DaoConfig config, DaoSession daoSession) { + super(config, daoSession); + this.daoSession = daoSession; + } + + /** Creates the underlying database table. */ + public static void createTable(Database db, boolean ifNotExists) { + String constraint = ifNotExists? "IF NOT EXISTS ": ""; + db.execSQL("CREATE TABLE " + constraint + "\"TR_ERROR_LOG\" (" + // + "\"UUID_ERROR_LOG\" TEXT PRIMARY KEY NOT NULL ," + // 0: uuid_error_log + "\"ERROR_DESCRIPTION\" TEXT," + // 1: error_description + "\"DEVICE_NAME\" TEXT," + // 2: device_name + "\"DTM_ACTIVITY\" INTEGER," + // 3: dtm_activity + "\"UUID_USER\" TEXT," + // 4: uuid_user + "\"TASK_ID\" TEXT);"); // 5: task_id + } + + /** Drops the underlying database table. */ + public static void dropTable(Database db, boolean ifExists) { + String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"TR_ERROR_LOG\""; + db.execSQL(sql); + } + + /** @inheritdoc */ + @Override + protected void bindValues(DatabaseStatement stmt, ErrorLog entity) { + stmt.clearBindings(); + stmt.bindString(1, entity.getUuid_error_log()); + + String error_description = entity.getError_description(); + if (error_description != null) { + stmt.bindString(2, error_description); + } + + String device_name = entity.getDevice_name(); + if (device_name != null) { + stmt.bindString(3, device_name); + } + + java.util.Date dtm_activity = entity.getDtm_activity(); + if (dtm_activity != null) { + stmt.bindLong(4, dtm_activity.getTime()); + } + + String uuid_user = entity.getUuid_user(); + if (uuid_user != null) { + stmt.bindString(5, uuid_user); + } + + String task_id = entity.getTask_id(); + if (task_id != null) { + stmt.bindString(6, task_id); + } + } + + @Override + protected void attachEntity(ErrorLog entity) { + super.attachEntity(entity); + entity.__setDaoSession(daoSession); + } + + /** @inheritdoc */ + @Override + public String readKey(Cursor cursor, int offset) { + return cursor.getString(offset + 0); + } + + /** @inheritdoc */ + @Override + public ErrorLog readEntity(Cursor cursor, int offset) { + ErrorLog entity = new ErrorLog( // + cursor.getString(offset + 0), // uuid_error_log + cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // error_description + cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2), // device_name + cursor.isNull(offset + 3) ? null : new java.util.Date(cursor.getLong(offset + 3)), // dtm_activity + cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4), // uuid_user + cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5) // task_id + ); + return entity; + } + + /** @inheritdoc */ + @Override + public void readEntity(Cursor cursor, ErrorLog entity, int offset) { + entity.setUuid_error_log(cursor.getString(offset + 0)); + entity.setError_description(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1)); + entity.setDevice_name(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2)); + entity.setDtm_activity(cursor.isNull(offset + 3) ? null : new java.util.Date(cursor.getLong(offset + 3))); + entity.setUuid_user(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); + entity.setTask_id(cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5)); + } + + /** @inheritdoc */ + @Override + protected String updateKeyAfterInsert(ErrorLog entity, long rowId) { + return entity.getUuid_error_log(); + } + + /** @inheritdoc */ + @Override + public String getKey(ErrorLog entity) { + if(entity != null) { + return entity.getUuid_error_log(); + } else { + return null; + } + } + + /** @inheritdoc */ + @Override + protected boolean isEntityUpdateable() { + return true; + } + + /** Internal query to resolve the "errorLogList" to-many relationship of User. */ + public List _queryUser_ErrorLogList(String uuid_user) { + synchronized (this) { + if (user_ErrorLogListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Uuid_user.eq(null)); + user_ErrorLogListQuery = queryBuilder.build(); + } + } + Query query = user_ErrorLogListQuery.forCurrentThread(); + query.setParameter(0, uuid_user); + return query.list(); + } + + /** Internal query to resolve the "errorLogList" to-many relationship of TaskH. */ + public List _queryTaskH_ErrorLogList(String task_id) { + synchronized (this) { + if (taskH_ErrorLogListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Task_id.eq(null)); + taskH_ErrorLogListQuery = queryBuilder.build(); + } + } + Query query = taskH_ErrorLogListQuery.forCurrentThread(); + query.setParameter(0, task_id); + return query.list(); + } + + private String selectDeep; + + protected String getSelectDeep() { + if (selectDeep == null) { + StringBuilder builder = new StringBuilder("SELECT "); + SqlUtils.appendColumns(builder, "T", getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T0", daoSession.getUserDao().getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T1", daoSession.getTaskHDao().getAllColumns()); + builder.append(" FROM TR_ERROR_LOG T"); + builder.append(" LEFT JOIN MS_USER T0 ON T.\"UUID_USER\"=T0.\"UUID_USER\""); + builder.append(" LEFT JOIN TR_TASK_H T1 ON T.\"TASK_ID\"=T1.\"UUID_TASK_H\""); + builder.append(' '); + selectDeep = builder.toString(); + } + return selectDeep; + } + + protected ErrorLog loadCurrentDeep(Cursor cursor, boolean lock) { + ErrorLog entity = loadCurrent(cursor, 0, lock); + int offset = getAllColumns().length; + + User user = loadCurrentOther(daoSession.getUserDao(), cursor, offset); + entity.setUser(user); + offset += daoSession.getUserDao().getAllColumns().length; + + TaskH taskH = loadCurrentOther(daoSession.getTaskHDao(), cursor, offset); + entity.setTaskH(taskH); + + return entity; + } + + public ErrorLog loadDeep(Long key) { + assertSinglePk(); + if (key == null) { + return null; + } + + StringBuilder builder = new StringBuilder(getSelectDeep()); + builder.append("WHERE "); + SqlUtils.appendColumnsEqValue(builder, "T", getPkColumns()); + String sql = builder.toString(); + + String[] keyArray = new String[] { key.toString() }; + Cursor cursor = db.rawQuery(sql, keyArray); + + try { + boolean available = cursor.moveToFirst(); + if (!available) { + return null; + } else if (!cursor.isLast()) { + throw new IllegalStateException("Expected unique result, but count was " + cursor.getCount()); + } + return loadCurrentDeep(cursor, true); + } finally { + cursor.close(); + } + } + + /** Reads all available rows from the given cursor and returns a list of new ImageTO objects. */ + public List loadAllDeepFromCursor(Cursor cursor) { + int count = cursor.getCount(); + List list = new ArrayList(count); + + if (cursor.moveToFirst()) { + if (identityScope != null) { + identityScope.lock(); + identityScope.reserveRoom(count); + } + try { + do { + list.add(loadCurrentDeep(cursor, false)); + } while (cursor.moveToNext()); + } finally { + if (identityScope != null) { + identityScope.unlock(); + } + } + } + return list; + } + + protected List loadDeepAllAndCloseCursor(Cursor cursor) { + try { + return loadAllDeepFromCursor(cursor); + } finally { + cursor.close(); + } + } + + + /** A raw-style query where you can pass any WHERE clause and arguments. */ + public List queryDeep(String where, String... selectionArg) { + Cursor cursor = db.rawQuery(getSelectDeep() + where, selectionArg); + return loadDeepAllAndCloseCursor(cursor); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00bdbfbf65c56f0205e8188c28d2d62587229c77.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00bdbfbf65c56f0205e8188c28d2d62587229c77.svn-base new file mode 100644 index 0000000..5a1b266 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00bdbfbf65c56f0205e8188c28d2d62587229c77.svn-base @@ -0,0 +1,183 @@ +package com.adins.mss.odr.news; + +import android.app.Activity; +import android.content.Context; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.dao.MobileContentD; +import com.adins.mss.dao.MobileContentH; +import com.adins.mss.dao.User; +import com.adins.mss.foundation.db.dataaccess.MobileContentDDataAccess; +import com.adins.mss.foundation.db.dataaccess.MobileContentHDataAccess; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.adins.mss.foundation.http.KeyValue; +import com.adins.mss.foundation.http.MssRequestType; + +import java.util.List; + +public class News { + private static Context context; + private static Activity activity; + private static List listHeaderSVR; + private static List listNewsChildSVR; + private static List listContentSVR; + + private static List listNewsParent; + private static List listNewsChild; + private static MobileContentH contentH; + private static List listContent; +// private static String uuid_user = GlobalData.getSharedGlobalData().getUser().getUuid_user(); + int i = 1; + +// public void getNewsHeaderFromServer() { +// try { +// listHeaderSVR = getlistNewsParentFromServer(); +// if(listHeaderSVR!=null || listHeaderSVR.size()>0){ +// +// for(MobileContentH contentP : listHeaderSVR){ +// contentP.setUser(user); +// if(contentP.getUuid_parent_content()==null|| +// contentP.getUuid_parent_content().equals("")){ +// +// } +// MobileContentHDataAccess.add(context, contentP); +// } +// } +// } catch (Exception e) { +// System.out.println(e.getMessage()); +// } +// } + + public News(Activity activity) { + News.context = activity; + News.activity=activity; + } + + public static long getCounterNews(Context context) { + long counter = 0; + try { + counter = MobileContentHDataAccess.getParentCounter(context, GlobalData.getSharedGlobalData().getUser().getUuid_user()); +// MOMainMenuActivity.mnNews.setCounter(String.valueOf(listNewsParent.size())); + } catch (Exception e) { + } + return counter; + } + + public void getNewsContentFromServer(MobileContentH contentH) { + try { + String uuid_mobile_content_h = contentH.getUuid_mobile_content_h(); + listContent = getListContentFromServer(uuid_mobile_content_h); + if(listContent!=null || listContent.size()>0){ + for(MobileContentD contentD : listContent){ + contentD.setMobileContentH(contentH); + MobileContentDDataAccess.add(context, contentD); + } + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public List getlistNewsParent() { + listNewsParent = MobileContentHDataAccess.getAllParent(context, GlobalData.getSharedGlobalData().getUser().getUuid_user()); + return listNewsParent; + } + + public List getAllNews() { + List listNewsParent = MobileContentHDataAccess.getAll(context, GlobalData.getSharedGlobalData().getUser().getUuid_user()); + return listNewsParent; + } + + public List getlistNewsChild(String Uuid_mobile_content_h_Parent) { + listNewsChild = MobileContentHDataAccess.getAll(context, GlobalData.getSharedGlobalData().getUser().getUuid_user(), Uuid_mobile_content_h_Parent); + return listNewsChild; + } + + public List getlistNewsChildWithoutDate(String Uuid_mobile_content_h_Parent) { + listNewsChild = MobileContentHDataAccess.getAllWithoutDate(context, GlobalData.getSharedGlobalData().getUser().getUuid_user(), Uuid_mobile_content_h_Parent); + return listNewsChild; + } + + public MobileContentH getContent(String Uuid_mobile_content_h_Parent) { + contentH = MobileContentHDataAccess.getOne(context, Uuid_mobile_content_h_Parent); + return contentH; + } + + public List getlistContent(String Uuid_mobile_content_h_Child) { + listContent = MobileContentDDataAccess.getAll(context, Uuid_mobile_content_h_Child); + return listContent; + } + + public List getlistContentOnDate(String Uuid_mobile_content_h_Child) { + listContent = MobileContentDDataAccess.getAllOnDate(context, Uuid_mobile_content_h_Child); + return listContent; + } + + public List getlistContentWithoutDate(String Uuid_mobile_content_h_Child) { + listContent = MobileContentDDataAccess.getAll(context, Uuid_mobile_content_h_Child); + return listContent; + } + + public List getListContentFromServer( + String uuid_mobile_content_h) { + JsonRequestNews requestType = new JsonRequestNews(); + requestType.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + requestType.addImeiAndroidIdToUnstructured(); + requestType.setuuid_mobile_content_h(uuid_mobile_content_h); + + String data = GsonHelper.toJson(requestType); + + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + HttpCryptedConnection httpConn = new HttpCryptedConnection(activity, encrypt, decrypt); +// HttpConnectionResult result = null; + String result = null; + JsonResponseNewsContent content = GsonHelper.fromJson(result, JsonResponseNewsContent.class); + listContent = content.getListMobileContentD(); + + return listContent; + } + +// private List getlistNewsParentFromServer() { +// JsonRequestNews requestType = new JsonRequestNews(); +// requestType.setAudit(GlobalData.getSharedGlobalData().getAuditData()); +// requestType.addItemToUnstructured(imeIvalue, false); +//// requestType.setListContentHeader(getlistNewsParent()); +// Gson gson = new GsonBuilder().setDateFormat("ddMMyyyyHHmmss").create(); +// +// String json = gson.toJson(requestType); +// String url = "Global.URL_GET_NEWS"; +// +// HttpCryptedConnection httpConn = new HttpCryptedConnection(Global.ENCRYPT_COMM, Global.DECRYPT_COMM); +// +// HttpConnectionResult result = null; +// try { +// result = httpConn.requestHTTPPost(url, json); +// } catch (Exception e) { +// e.printStackTrace(); +// } +// +// String data = result.getResult(); +// data ="{\"listHeader\":[{\"content_description\":\"Lorem ipsum dolor sit amet.\",\"content_name\":\"YAMAHA\",\"effective_date\":\"25022015101314\",\"uuid_mobile_content_h\":\"c0db330c-47eb-4f1b-bfd8-139d27749789\"},{\"content_description\":\"Lorem ipsum dolor sit amet.\",\"content_name\":\"TOYOTA\",\"effective_date\":\"25022015101314\",\"uuid_mobile_content_h\":\"0bd0210a-91f1-40a3-b2f4-347229fb702a\"},{\"content_description\":\"Lorem ipsum dolor sit amet.\",\"content_name\":\"YAMAHA MX\",\"effective_date\":\"25022015101314\",\"uuid_mobile_content_h\":\"2e635f95-2f8e-4681-8393-bd086426c92a\",\"uuid_parent_content\":\"c0db330c-47eb-4f1b-bfd8-139d27749789\"},{\"content_description\":\"Lorem ipsum dolor sit amet.\",\"content_name\":\"YAMAHA R1000\",\"effective_date\":\"25022015101314\",\"uuid_mobile_content_h\":\"6777a562-6efe-4ebf-b16c-0efd7e280e03\",\"uuid_parent_content\":\"c0db330c-47eb-4f1b-bfd8-139d27749789\"}],\"status\":{\"code\":\"1\"}}"; +// try { +//// result = httpConn.requestHTTPPost(Global.URL_GET_CONTENTNEWS, data); +// +// } catch (Exception e) { +// e.printStackTrace(); +// } +// +// JsonResponseNewsHeader news = gson.fromJson(data, JsonResponseNewsHeader.class); +// listNewsParent = news.getListHeader(); +//// MobileContentHDataAccess.add(context, mobileContentHList); +// return listNewsParent; +// } + + private List getlistNewsChildFromServer( + String uuid_mobile_content_h) { + // TODO Bikin cara buat dapetin dari server +// MobileContentHDataAccess.add(context, mobileContentHList); + + return listNewsChild; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00beea1b8dfc7ec9c612eb44d5fbc3db35760569.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00beea1b8dfc7ec9c612eb44d5fbc3db35760569.svn-base new file mode 100644 index 0000000..d3676d2 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00beea1b8dfc7ec9c612eb44d5fbc3db35760569.svn-base @@ -0,0 +1,33 @@ +package com.adins.mss.base.loyalti.mypointdashboard; + +import com.adins.mss.foundation.http.MssRequestType; +import com.google.gson.annotations.SerializedName; + +import java.util.ArrayList; +import java.util.List; + +class DetailKompetisiRequest extends MssRequestType { + + @SerializedName("LOGIN_ID") + protected String LOGIN_ID; + + public String getLOGIN_ID() { + return LOGIN_ID; + } + + public void setLOGIN_ID(String LOGIN_ID) { + this.LOGIN_ID = LOGIN_ID; + } + +// @SerializedName("MEMBERSHIP_PROGRAM_CODE") +// protected ArrayList MEMBERSHIP_PROGRAM_CODE; +// +// public ArrayList getMEMBERSHIP_PROGRAM_CODE() { +// return MEMBERSHIP_PROGRAM_CODE; +// } +// +// public void setMEMBERSHIP_PROGRAM_CODE(ArrayList MEMBERSHIP_PROGRAM_CODE) { +// this.MEMBERSHIP_PROGRAM_CODE = MEMBERSHIP_PROGRAM_CODE; +// } +} + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00f1c56f3cfd44436717a35d0ab1d37d4cf0334e.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00f1c56f3cfd44436717a35d0ab1d37d4cf0334e.svn-base new file mode 100644 index 0000000..ff485cf --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/00/00f1c56f3cfd44436717a35d0ab1d37d4cf0334e.svn-base @@ -0,0 +1,9 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/0142f990991ff2c6067c4a63a109230a96db2619.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/0142f990991ff2c6067c4a63a109230a96db2619.svn-base new file mode 100644 index 0000000..fd36333 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/0142f990991ff2c6067c4a63a109230a96db2619.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/014b3d9ca00fd8779db382ee701608b805c2fae6.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/014b3d9ca00fd8779db382ee701608b805c2fae6.svn-base new file mode 100644 index 0000000..4d344bc --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/014b3d9ca00fd8779db382ee701608b805c2fae6.svn-base @@ -0,0 +1,300 @@ +package com.adins.mss.foundation.db.dataaccess; + +import android.content.Context; +import android.database.Cursor; +import android.util.Log; + +import com.adins.mss.constant.Global; +import com.adins.mss.dao.DaoSession; +import com.adins.mss.dao.Scheme; +import com.adins.mss.dao.SchemeDao; +import com.adins.mss.foundation.db.DaoOpenHelper; + +import java.util.ArrayList; +import java.util.List; + +import de.greenrobot.dao.query.QueryBuilder; + +public class SchemeDataAccess { + + private SchemeDataAccess() { + //EMPTY + } + + /** + * use to generate dao session that you can access modelDao + * + * @param context --> context from activity + * @return + */ + protected static DaoSession getDaoSession(Context context) { + return DaoOpenHelper.getDaoSession(context); + } + + /** + * get scheme dao and you can access the DB + * + * @param context + * @return + */ + protected static SchemeDao getSchemeDao(Context context) { + return getDaoSession(context).getSchemeDao(); + } + + /** + * Clear session, close db and set daoOpenHelper to null + */ + public static void closeAll() { + DaoOpenHelper.closeAll(); + } + + /** + * add scheme as entity + * + * @param context + * @param scheme + */ + public static void add(Context context, Scheme scheme) { + getSchemeDao(context).insertInTx(scheme); + getDaoSession(context).clear(); + } + + /** + * add scheme as list entity + * + * @param context + * @param schemeList + */ + public static void add(Context context, List schemeList) { + getSchemeDao(context).insertInTx(schemeList); + getDaoSession(context).clear(); + } + + /** + * delete all content in table. + * + * @param context + */ + public static void clean(Context context) { + getSchemeDao(context).deleteAll(); + getDaoSession(context).clear(); + } + + /** + * @param context + * @param scheme + */ + public static void delete(Context context, Scheme scheme) { + getSchemeDao(context).delete(scheme); + getDaoSession(context).clear(); + } + + /** + * delete all record by keyScheme + * + * @param context + */ + public static void delete(Context context, String keyScheme) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Uuid_scheme.eq(keyScheme)); + qb.build(); + getSchemeDao(context).deleteInTx(qb.list()); + getDaoSession(context).clear(); + } + + /** + * @param context + * @param scheme + */ + public static void update(Context context, Scheme scheme) { + getSchemeDao(context).update(scheme); + getDaoSession(context).clear(); + } + + /** + * add scheme as entity + * + * @param context + * @param scheme + */ + public static void addOrReplace(Context context, Scheme scheme) { + getSchemeDao(context).insertOrReplaceInTx(scheme); + getDaoSession(context).clear(); + } + + /** + * add scheme as list entity + * + * @param context + * @param listScheme + */ + public static void addOrReplace(Context context, List listScheme) { + getSchemeDao(context).insertOrReplaceInTx(listScheme); + getDaoSession(context).clear(); + } + + /** + * select * from table where uuid_scheme = param + * + * @param context + * @param keyScheme + * @return + */ + public static Scheme getOne(Context context, String keyScheme) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Uuid_scheme.eq(keyScheme)); + qb.build().forCurrentThread(); + if (qb.list().isEmpty()) + return null; + return qb.list().get(0); + } + + /** + * select * from table where uuid_scheme = param + * + * @param context + * @return + */ + public static List getAll(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.build(); + return qb.list(); + } + + public static List getAllActiveScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.build(); + return qb.list(); + } + + public static List getAllActivePriorityScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.where(SchemeDao.Properties.Form_type.notEq(Global.FORM_TYPE_SIMULASI)); + qb.build(); + return qb.list(); + } + + public static String getOneSchemeName(Context context, String uuid){ + List result = new ArrayList<>(); + String SQL_DISTINCT_ENAME = "SELECT "+ SchemeDao.Properties.Scheme_description.columnName+ + " FROM "+ SchemeDao.TABLENAME+ + " WHERE "+ SchemeDao.Properties.Is_active.columnName+"='"+Global.TRUE_STRING+"' "+ + " AND " + SchemeDao.Properties.Uuid_scheme.columnName+"='"+uuid+"' "+ + " ORDER BY "+ + SchemeDao.Properties.Scheme_description.columnName+ + " ASC"; + Cursor c = getSchemeDao(context).getDatabase().rawQuery(SQL_DISTINCT_ENAME, null); + if (c.moveToFirst()) { + do { + result.add(c.getString(0)); + } while (c.moveToNext()); + } + c.close(); + String resultName = ""; + if(result != null && result.size()>0){ + resultName = result.get(0); + } + return resultName; + } + + public static List getAllSchemeName(Context context) { + List result = new ArrayList<>(); + String SQL_DISTINCT_ENAME = "SELECT " + SchemeDao.Properties.Scheme_description.columnName + + " FROM " + SchemeDao.TABLENAME + + " WHERE " + SchemeDao.Properties.Is_active.columnName + "='" + Global.TRUE_STRING + "' " + + " ORDER BY " + + SchemeDao.Properties.Scheme_description.columnName + + " ASC"; + Cursor c = getSchemeDao(context).getDatabase().rawQuery(SQL_DISTINCT_ENAME, null); + if (c.moveToFirst()) { + do { + result.add(c.getString(0)); + } while (c.moveToNext()); + } + c.close(); + return result; + } + + /** + * get simulasi scheme + * + * @param context + * @return + */ + public static List getAllSimulateScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_SIMULASI)); + qb.build(); + return qb.list(); + } + + /** + * get Order Scheme + * + * @param context + * @return + */ + public static List getAllOrderScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.and(qb.or(SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_ORDER), + SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_KTP)), + SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.build(); + return qb.list(); + } + + /** + * get Collection Scheme + * + * @param context + * @return + */ + public static List getAllCollectionScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_COLL), + SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.build(); + return qb.list(); + } + + /** + * get Survey scheme + * + * @param context + * @return + */ + public static List getAllSurveyScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(qb.or(SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_SURVEY), + SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_KTP)), + SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.build(); + return qb.list(); + } + + /** + * select scheme by last update + * + * @param context + * @return + */ + public static Scheme getOneByLastUpdate(Context context, String keyScheme, java.util.Date scheme_last_update) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Uuid_scheme.eq(keyScheme), + SchemeDao.Properties.Scheme_last_update.eq(scheme_last_update)); + qb.build().forCurrentThread(); + if (qb.list().isEmpty()) + return null; + return qb.list().get(0); + } + + public static List getAllMarketingScheme(Context context) { + QueryBuilder qb = getSchemeDao(context).queryBuilder(); + qb.where(SchemeDao.Properties.Form_type.eq(Global.FORM_TYPE_MARKETING), + SchemeDao.Properties.Is_active.eq(Global.TRUE_STRING)); + qb.build(); + return qb.list(); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/017ec6bb09bb826e1a2648bb14c853410ca4c5ca.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/017ec6bb09bb826e1a2648bb14c853410ca4c5ca.svn-base new file mode 100644 index 0000000..1e4f9c9 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/017ec6bb09bb826e1a2648bb14c853410ca4c5ca.svn-base @@ -0,0 +1,38 @@ +package com.adins.mss.base.loyalti.barchart; + +import com.adins.mss.base.loyalti.model.PointDetail; +import com.github.mikephil.charting.data.BarDataSet; +import com.github.mikephil.charting.data.BarEntry; + +import java.util.ArrayList; +import java.util.List; + +public class LoyaltyBarDataSet extends BarDataSet { + + List pointDetailsDataSet = new ArrayList<>(); + List pointCategories = new ArrayList<>(); + + public LoyaltyBarDataSet(List pointDetails, List pointCategories, List yVals, String label) { + super(yVals, label); + pointDetailsDataSet = pointDetails; + this.pointCategories = pointCategories; + } + + @Override + public int getColor(int index) { + if(index >= pointDetailsDataSet.size()) + return pointCategories.get(0).colorValue; + + PointDetail currentPointDetail = pointDetailsDataSet.get(index); + int selectedColor = -1; + for (PointDetail category:pointCategories) { + if(category.rewardProgram.equals(currentPointDetail.rewardProgram)){ + selectedColor = category.colorValue; + break; + } + } + + return selectedColor; + } +} + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/019f9f067b588e7af9b7961aec84975749a5154a.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/019f9f067b588e7af9b7961aec84975749a5154a.svn-base new file mode 100644 index 0000000..5ba5c2b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/019f9f067b588e7af9b7961aec84975749a5154a.svn-base @@ -0,0 +1,48 @@ +package fr.castorflex.android.smoothprogressbar; + +import android.graphics.drawable.Drawable; +import android.graphics.drawable.ShapeDrawable; + +/** + * Created by castorflex on 3/5/14. + */ +public final class SmoothProgressBarUtils { + private SmoothProgressBarUtils() { + } + + public static Drawable generateDrawableWithColors(int[] colors, float strokeWidth) { + if (colors == null || colors.length == 0) return null; + + return new ShapeDrawable(new ColorsShape(strokeWidth, colors)); + } + + static void checkSpeed(float speed) { + if (speed <= 0f) + throw new IllegalArgumentException("Speed must be >= 0"); + } + + static void checkColors(int[] colors) { + if (colors == null || colors.length == 0) + throw new IllegalArgumentException("You must provide at least 1 color"); + } + + static void checkAngle(int angle) { + if (angle < 0 || angle > 360) + throw new IllegalArgumentException(String.format("Illegal angle %d: must be >=0 and <= 360", angle)); + } + + static void checkPositiveOrZero(float number, String name) { + if (number < 0) + throw new IllegalArgumentException(String.format("%s %d must be positive", name, number)); + } + + static void checkPositive(int number, String name) { + if (number <= 0) + throw new IllegalArgumentException(String.format("%s must not be null", name)); + } + + static void checkNotNull(Object o, String name) { + if (o == null) + throw new IllegalArgumentException(String.format("%s must be not null", name)); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/01a2b9d6f36c9e7df3bd354e23090ff646b9d766.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/01a2b9d6f36c9e7df3bd354e23090ff646b9d766.svn-base new file mode 100644 index 0000000..503b294 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/01/01a2b9d6f36c9e7df3bd354e23090ff646b9d766.svn-base @@ -0,0 +1,145 @@ +package com.adins.mss.coll.loyalti.pointacquisitiondaily; + +import com.adins.mss.coll.loyalti.pointacquisitionmonthly.contracts.ILoyaltyPointsDataSource; +import com.adins.mss.coll.models.loyaltymodels.GroupPointData; +import com.adins.mss.coll.models.loyaltymodels.LoyaltyPointsRequest; +import com.adins.mss.constant.Global; + +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Date; +import java.util.List; + +public class DailyPointsLogic { + private ILoyaltyPointsDataSource dataSource; + private String competitionStartDate; + private int displayMonth; + private int displayYear; + + public DailyPointsLogic(ILoyaltyPointsDataSource dataSource, String competitionStartDate, int displayMonth, int displayYear) { + this.dataSource = dataSource; + this.competitionStartDate = competitionStartDate; + this.displayMonth = displayMonth; + this.displayYear = displayYear; + } + + public DailyPointsLogic(ILoyaltyPointsDataSource dataSource) { + this.dataSource = dataSource; + } + + public void getDailyPointsData(LoyaltyPointsRequest reqData, ILoyaltyPointsDataSource.ReqPointsListener listener){ + dataSource.requestPointsData(reqData,listener); + } + + public int getTotalPoints(List dataSet){ + if(dataSet == null) + return 0; + int totalPoints = 0; + int[] totalPerIdx = new int[dataSet.size()]; + int _sum = 0; + for(int i=0; i dataSet){ + if(dataSet == null) + return 0; + float totalPoints = 0; + int avg = 0; + int[] totalPerIdx = new int[dataSet.size()]; + int _sum = 0; + for(int i=0; i dataSet){ + if(dataSet == null) + return 0; + + int max = 0; + int[] totalPerIdx = new int[dataSet.size()]; + int _sum = 0; + for(int i=0; i listValue; + + public List getListValues() { + return this.listValue; + } + + public void setListValues(List listValue) { + this.listValue = listValue; + } + + public class ListValue { + @SerializedName("key") + String key; + @SerializedName("value") + String value; + + public String getKey() { + return this.key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getValue() { + return this.value; + } + + public void setValue(String value) { + this.value = value; + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/022e5963bcb55e0edee063bf2e86894c9aa2d518.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/022e5963bcb55e0edee063bf2e86894c9aa2d518.svn-base new file mode 100644 index 0000000..9b1c41e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/022e5963bcb55e0edee063bf2e86894c9aa2d518.svn-base @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/0243b3e7d0cbce1b975887eaec2d43cdfbe3d249.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/0243b3e7d0cbce1b975887eaec2d43cdfbe3d249.svn-base new file mode 100644 index 0000000..21593fd --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/0243b3e7d0cbce1b975887eaec2d43cdfbe3d249.svn-base @@ -0,0 +1,24 @@ +package com.adins.mss.odr.followup.api; + +import com.adins.mss.dao.GroupTask; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +/** + * Created by olivia.dg on 11/24/2017. + */ + +public class GetFollowUpResponse extends MssResponseType { + @SerializedName("listFollowUp") + private List listFollowUp; + + public List getListFollowUp() { + return listFollowUp; + } + + public void setListFollowUp(List listFollowUp) { + this.listFollowUp = listFollowUp; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02808cd043aef91bcb2a133aca8d4fde49360420.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02808cd043aef91bcb2a133aca8d4fde49360420.svn-base new file mode 100644 index 0000000..fb04397 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02808cd043aef91bcb2a133aca8d4fde49360420.svn-base @@ -0,0 +1,302 @@ +package com.adins.mss.dao; + +import java.util.List; +import java.util.ArrayList; +import android.database.Cursor; + +import de.greenrobot.dao.AbstractDao; +import de.greenrobot.dao.Property; +import de.greenrobot.dao.internal.SqlUtils; +import de.greenrobot.dao.internal.DaoConfig; +import de.greenrobot.dao.database.Database; +import de.greenrobot.dao.database.DatabaseStatement; +import de.greenrobot.dao.query.Query; +import de.greenrobot.dao.query.QueryBuilder; + +import com.adins.mss.dao.Comment; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. +/** + * DAO for table "TR_COMMENT". +*/ +public class CommentDao extends AbstractDao { + + public static final String TABLENAME = "TR_COMMENT"; + + /** + * Properties of entity Comment.
+ * Can be used for QueryBuilder and for referencing column names. + */ + public static class Properties { + public final static Property Uuid_comment = new Property(0, String.class, "uuid_comment", true, "UUID_COMMENT"); + public final static Property Comment = new Property(1, String.class, "comment", false, "COMMENT"); + public final static Property Dtm_crt_server = new Property(2, java.util.Date.class, "dtm_crt_server", false, "DTM_CRT_SERVER"); + public final static Property Sender_id = new Property(3, String.class, "sender_id", false, "SENDER_ID"); + public final static Property Sender_name = new Property(4, String.class, "sender_name", false, "SENDER_NAME"); + public final static Property Usr_crt = new Property(5, String.class, "usr_crt", false, "USR_CRT"); + public final static Property Dtm_crt = new Property(6, java.util.Date.class, "dtm_crt", false, "DTM_CRT"); + public final static Property Usr_upd = new Property(7, String.class, "usr_upd", false, "USR_UPD"); + public final static Property Dtm_upd = new Property(8, java.util.Date.class, "dtm_upd", false, "DTM_UPD"); + public final static Property Uuid_timeline = new Property(9, String.class, "uuid_timeline", false, "UUID_TIMELINE"); + }; + + private DaoSession daoSession; + + private Query timeline_CommentListQuery; + + public CommentDao(DaoConfig config) { + super(config); + } + + public CommentDao(DaoConfig config, DaoSession daoSession) { + super(config, daoSession); + this.daoSession = daoSession; + } + + /** Creates the underlying database table. */ + public static void createTable(Database db, boolean ifNotExists) { + String constraint = ifNotExists? "IF NOT EXISTS ": ""; + db.execSQL("CREATE TABLE " + constraint + "\"TR_COMMENT\" (" + // + "\"UUID_COMMENT\" TEXT PRIMARY KEY NOT NULL ," + // 0: uuid_comment + "\"COMMENT\" TEXT," + // 1: comment + "\"DTM_CRT_SERVER\" INTEGER," + // 2: dtm_crt_server + "\"SENDER_ID\" TEXT," + // 3: sender_id + "\"SENDER_NAME\" TEXT," + // 4: sender_name + "\"USR_CRT\" TEXT," + // 5: usr_crt + "\"DTM_CRT\" INTEGER," + // 6: dtm_crt + "\"USR_UPD\" TEXT," + // 7: usr_upd + "\"DTM_UPD\" INTEGER," + // 8: dtm_upd + "\"UUID_TIMELINE\" TEXT);"); // 9: uuid_timeline + } + + /** Drops the underlying database table. */ + public static void dropTable(Database db, boolean ifExists) { + String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"TR_COMMENT\""; + db.execSQL(sql); + } + + /** @inheritdoc */ + @Override + protected void bindValues(DatabaseStatement stmt, Comment entity) { + stmt.clearBindings(); + stmt.bindString(1, entity.getUuid_comment()); + + String comment = entity.getComment(); + if (comment != null) { + stmt.bindString(2, comment); + } + + java.util.Date dtm_crt_server = entity.getDtm_crt_server(); + if (dtm_crt_server != null) { + stmt.bindLong(3, dtm_crt_server.getTime()); + } + + String sender_id = entity.getSender_id(); + if (sender_id != null) { + stmt.bindString(4, sender_id); + } + + String sender_name = entity.getSender_name(); + if (sender_name != null) { + stmt.bindString(5, sender_name); + } + + String usr_crt = entity.getUsr_crt(); + if (usr_crt != null) { + stmt.bindString(6, usr_crt); + } + + java.util.Date dtm_crt = entity.getDtm_crt(); + if (dtm_crt != null) { + stmt.bindLong(7, dtm_crt.getTime()); + } + + String usr_upd = entity.getUsr_upd(); + if (usr_upd != null) { + stmt.bindString(8, usr_upd); + } + + java.util.Date dtm_upd = entity.getDtm_upd(); + if (dtm_upd != null) { + stmt.bindLong(9, dtm_upd.getTime()); + } + + String uuid_timeline = entity.getUuid_timeline(); + if (uuid_timeline != null) { + stmt.bindString(10, uuid_timeline); + } + } + + @Override + protected void attachEntity(Comment entity) { + super.attachEntity(entity); + entity.__setDaoSession(daoSession); + } + + /** @inheritdoc */ + @Override + public String readKey(Cursor cursor, int offset) { + return cursor.getString(offset + 0); + } + + /** @inheritdoc */ + @Override + public Comment readEntity(Cursor cursor, int offset) { + Comment entity = new Comment( // + cursor.getString(offset + 0), // uuid_comment + cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // comment + cursor.isNull(offset + 2) ? null : new java.util.Date(cursor.getLong(offset + 2)), // dtm_crt_server + cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3), // sender_id + cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4), // sender_name + cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5), // usr_crt + cursor.isNull(offset + 6) ? null : new java.util.Date(cursor.getLong(offset + 6)), // dtm_crt + cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7), // usr_upd + cursor.isNull(offset + 8) ? null : new java.util.Date(cursor.getLong(offset + 8)), // dtm_upd + cursor.isNull(offset + 9) ? null : cursor.getString(offset + 9) // uuid_timeline + ); + return entity; + } + + /** @inheritdoc */ + @Override + public void readEntity(Cursor cursor, Comment entity, int offset) { + entity.setUuid_comment(cursor.getString(offset + 0)); + entity.setComment(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1)); + entity.setDtm_crt_server(cursor.isNull(offset + 2) ? null : new java.util.Date(cursor.getLong(offset + 2))); + entity.setSender_id(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3)); + entity.setSender_name(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); + entity.setUsr_crt(cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5)); + entity.setDtm_crt(cursor.isNull(offset + 6) ? null : new java.util.Date(cursor.getLong(offset + 6))); + entity.setUsr_upd(cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7)); + entity.setDtm_upd(cursor.isNull(offset + 8) ? null : new java.util.Date(cursor.getLong(offset + 8))); + entity.setUuid_timeline(cursor.isNull(offset + 9) ? null : cursor.getString(offset + 9)); + } + + /** @inheritdoc */ + @Override + protected String updateKeyAfterInsert(Comment entity, long rowId) { + return entity.getUuid_comment(); + } + + /** @inheritdoc */ + @Override + public String getKey(Comment entity) { + if(entity != null) { + return entity.getUuid_comment(); + } else { + return null; + } + } + + /** @inheritdoc */ + @Override + protected boolean isEntityUpdateable() { + return true; + } + + /** Internal query to resolve the "commentList" to-many relationship of Timeline. */ + public List _queryTimeline_CommentList(String uuid_timeline) { + synchronized (this) { + if (timeline_CommentListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Uuid_timeline.eq(null)); + timeline_CommentListQuery = queryBuilder.build(); + } + } + Query query = timeline_CommentListQuery.forCurrentThread(); + query.setParameter(0, uuid_timeline); + return query.list(); + } + + private String selectDeep; + + protected String getSelectDeep() { + if (selectDeep == null) { + StringBuilder builder = new StringBuilder("SELECT "); + SqlUtils.appendColumns(builder, "T", getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T0", daoSession.getTimelineDao().getAllColumns()); + builder.append(" FROM TR_COMMENT T"); + builder.append(" LEFT JOIN TR_TIMELINE T0 ON T.\"UUID_TIMELINE\"=T0.\"UUID_TIMELINE\""); + builder.append(' '); + selectDeep = builder.toString(); + } + return selectDeep; + } + + protected Comment loadCurrentDeep(Cursor cursor, boolean lock) { + Comment entity = loadCurrent(cursor, 0, lock); + int offset = getAllColumns().length; + + Timeline timeline = loadCurrentOther(daoSession.getTimelineDao(), cursor, offset); + entity.setTimeline(timeline); + + return entity; + } + + public Comment loadDeep(Long key) { + assertSinglePk(); + if (key == null) { + return null; + } + + StringBuilder builder = new StringBuilder(getSelectDeep()); + builder.append("WHERE "); + SqlUtils.appendColumnsEqValue(builder, "T", getPkColumns()); + String sql = builder.toString(); + + String[] keyArray = new String[] { key.toString() }; + Cursor cursor = db.rawQuery(sql, keyArray); + + try { + boolean available = cursor.moveToFirst(); + if (!available) { + return null; + } else if (!cursor.isLast()) { + throw new IllegalStateException("Expected unique result, but count was " + cursor.getCount()); + } + return loadCurrentDeep(cursor, true); + } finally { + cursor.close(); + } + } + + /** Reads all available rows from the given cursor and returns a list of new ImageTO objects. */ + public List loadAllDeepFromCursor(Cursor cursor) { + int count = cursor.getCount(); + List list = new ArrayList(count); + + if (cursor.moveToFirst()) { + if (identityScope != null) { + identityScope.lock(); + identityScope.reserveRoom(count); + } + try { + do { + list.add(loadCurrentDeep(cursor, false)); + } while (cursor.moveToNext()); + } finally { + if (identityScope != null) { + identityScope.unlock(); + } + } + } + return list; + } + + protected List loadDeepAllAndCloseCursor(Cursor cursor) { + try { + return loadAllDeepFromCursor(cursor); + } finally { + cursor.close(); + } + } + + + /** A raw-style query where you can pass any WHERE clause and arguments. */ + public List queryDeep(String where, String... selectionArg) { + Cursor cursor = db.rawQuery(getSelectDeep() + where, selectionArg); + return loadDeepAllAndCloseCursor(cursor); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02a20bb3a31e714bd9574b302dd10810cf9c2407.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02a20bb3a31e714bd9574b302dd10810cf9c2407.svn-base new file mode 100644 index 0000000..4b6f9fe --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02a20bb3a31e714bd9574b302dd10810cf9c2407.svn-base @@ -0,0 +1,52 @@ +package com.adins.mss.coll.models; + +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +/** + * Created by adityapurwa on 20/03/15. + */ +public class PaymentHistoryResponse extends MssResponseType { + @SerializedName("agreementNo") + private String agreementNo; + @SerializedName("paymentHistoryHList") + private List paymentHistoryHList; + + public String getAgreementNo() { + return agreementNo; + } + + public void setAgreementNo(String agreementNo) { + this.agreementNo = agreementNo; + } + + public List getPaymentHistoryHList() { + return paymentHistoryHList; + } + + public void setPaymentHistoryHList(List paymentHistoryHList) { + this.paymentHistoryHList = paymentHistoryHList; + } + + + +// public List getPaymentHistoryHList() { +// return paymentHistoryHList; +// } +// +// public void setPaymentHistoryHList(List paymentHistoryHList) { +// this.paymentHistoryHList = paymentHistoryHList; +// } +// +// public List getPaymentHistoryDList() { +// return paymentHistoryDList; +// } +// +// public void setPaymentHistoryDList(List paymentHistoryDList) { +// this.paymentHistoryDList = paymentHistoryDList; +// } + + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c0bd00cfeab5628d4c433d8ca4cdac75902eaa.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c0bd00cfeab5628d4c433d8ca4cdac75902eaa.svn-base new file mode 100644 index 0000000..2497224 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c0bd00cfeab5628d4c433d8ca4cdac75902eaa.svn-base @@ -0,0 +1,72 @@ +package com.adins.mss.foundation.dialog.gitonway.lib; + +import com.adins.mss.foundation.dialog.gitonway.lib.effects.BaseEffects; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.FadeIn; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.Fall; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.FlipH; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.FlipV; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.NewsPaper; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.RotateBottom; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.RotateLeft; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.Shake; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.SideFall; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.SlideBottom; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.SlideLeft; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.SlideRight; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.SlideTop; +import com.adins.mss.foundation.dialog.gitonway.lib.effects.Slit; + +/* + * Copyright 2014 litao + * https://github.com/sd6352051/NiftyDialogEffects + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +public enum Effectstype { + + Fadein(FadeIn.class), + Slideleft(SlideLeft.class), + Slidetop(SlideTop.class), + SlideBottom(SlideBottom.class), + Slideright(SlideRight.class), + Fall(Fall.class), + Newspager(NewsPaper.class), + Fliph(FlipH.class), + Flipv(FlipV.class), + RotateBottom(RotateBottom.class), + RotateLeft(RotateLeft.class), + Slit(Slit.class), + Shake(Shake.class), + Sidefill(SideFall.class); + private Class effectsClazz; + + private Effectstype(Class mclass) { + effectsClazz = mclass; + } + + public BaseEffects getAnimator() { + BaseEffects bEffects = null; + try { + bEffects = effectsClazz.newInstance(); + } catch (ClassCastException e) { + throw new Error("Can not init animatorClazz instance"); + } catch (InstantiationException e) { + // TODO Auto-generated catch block + throw new Error("Can not init animatorClazz instance"); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + throw new Error("Can not init animatorClazz instance"); + } + return bEffects; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c66df5b1cf55282b4b31c0863a0914dfc26f9a.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c66df5b1cf55282b4b31c0863a0914dfc26f9a.svn-base new file mode 100644 index 0000000..d946650 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02c66df5b1cf55282b4b31c0863a0914dfc26f9a.svn-base @@ -0,0 +1,15 @@ + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02cb9dc9b652411654183cc90016a4d728fcb126.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02cb9dc9b652411654183cc90016a4d728fcb126.svn-base new file mode 100644 index 0000000..90c881c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02cb9dc9b652411654183cc90016a4d728fcb126.svn-base @@ -0,0 +1,257 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02e2ff49755f0946f18da0ef173b9f601b7b0fcb.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02e2ff49755f0946f18da0ef173b9f601b7b0fcb.svn-base new file mode 100644 index 0000000..4646738 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02e2ff49755f0946f18da0ef173b9f601b7b0fcb.svn-base @@ -0,0 +1,167 @@ +package com.adins.mss.base.receipt; + +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.Typeface; + +/** + * Created by Loise on 12/04/2018. + */ + +/** + * menggambar teks pada canvas + */ +public class DrawText implements IDrawItem { + private Paint paint = new Paint(); + private String text; + private boolean newLine; + + /** + * konstruktor + * @param text teks yang akan digambar + */ + public DrawText(String text) { + this.text = text; + } + + /** + * menggambarkan teks pada canvas + * @param canvas + * @param x + * @param y + */ + @Override + public void drawOnCanvas(Canvas canvas, float x, float y) { + canvas.drawText(text, getX(canvas, x), getY(y), paint); + } + + /** + * mengembalikan titik awal pada sumbu y + * @param y + * @return + */ + private float getY(float y) { + float baseline = -paint.ascent(); + return baseline + y; + } + + /** + * mengembalikan titik awal pada sumbu x + * @param canvas + * @param x + * @return + */ + private float getX(Canvas canvas, float x) { + float xPos = x; + if (paint.getTextAlign().equals(Paint.Align.CENTER)) { + xPos = ((float)canvas.getWidth() / 2); + } else if (paint.getTextAlign().equals(Paint.Align.RIGHT)) { + xPos = canvas.getWidth(); + } + return xPos; + } + + /** + * mengembalikan tinggi objek teks + * @return + */ + @Override + public int getHeight() { + return (newLine ? (int) getTextSize() : 0); + } + + /** + * mengembalikan teks + * @return + */ + public String getText() { + return text; + } + + /** + * setter teks + * @param text + */ + public void setText(String text) { + this.text = text; + } + + /** + * mengembalikan warna teks + * @return + */ + public int getColor() { + return paint.getColor(); + } + + /** + * mengubah warna teks + * @param color + */ + public void setColor(int color) { + paint.setColor(color); + } + + /** + * mengembalikan ukuran teks + * @return + */ + public float getTextSize() { + return paint.getTextSize(); + } + + /** + * mengubah ukuran teks + * @param textSize + */ + public void setTextSize(float textSize) { + paint.setTextSize(textSize); + } + + /** + * mengembalikan font teks + */ + public void getTypeface() { + paint.getTypeface(); + } + + /** + * mengubah font teks + * @param typeface Typeface + */ + public void setTypeface(Typeface typeface) { + paint.setTypeface(typeface); + } + + /** + * mengubah akignment teks + * @param align + */ + public void setAlign(Paint.Align align) { + paint.setTextAlign(align); + } + + /** + * mengembalikan alignment teks + * @return + */ + public Paint.Align getAlign() { + return paint.getTextAlign(); + } + + /** + * menentukan apakah teks akan pindah baris atau tidak + * @param newLine + */ + public void setNewLine(boolean newLine) { + this.newLine = newLine; + } + + /** + * mengembalikan status teks pindah baris atau tidak + * @return + */ + public boolean getNewLine() { + return newLine; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02ed3898e149d9bf33420350224a536c6986c8d0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02ed3898e149d9bf33420350224a536c6986c8d0.svn-base new file mode 100644 index 0000000..5aa6dcf --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/02/02ed3898e149d9bf33420350224a536c6986c8d0.svn-base @@ -0,0 +1,18 @@ +package com.adins.mss.base.tasklog; + +import com.adins.mss.base.commons.TaskListener; +import com.adins.mss.dao.TaskH; + +import java.util.List; + +/** + * Created by kusnendi.muhamad on 28/07/2017. + */ + +public interface TaskLogInterface { + public List getListTaskLog(); + + public void callOnlineLog(TaskListener listener); + + public void cancelOnlineLog(); +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/0373e551f7a2d9e5e957493c60cddee737e5a721.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/0373e551f7a2d9e5e957493c60cddee737e5a721.svn-base new file mode 100644 index 0000000..7ef601e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/0373e551f7a2d9e5e957493c60cddee737e5a721.svn-base @@ -0,0 +1,58 @@ +/* + * Copyright 2012 Kevin Gaudin + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.acra.collector; + +import org.acra.ReportField; +import org.acra.util.JSONReportBuilder; +import org.acra.util.JSONReportBuilder.JSONReportException; +import org.json.JSONObject; + +import java.util.EnumMap; +import java.util.Properties; + +/** + * Stores a crash reports data with {@link org.acra.ReportField} enum values as keys. + * This is basically the source of {@link Properties} adapted to extend an + * EnumMap instead of Hashtable and with a few tweaks to avoid losing crazy + * amounts of android time in the generation of a date comment when storing to + * file. + */ +public final class CrashReportData extends EnumMap { + + private static final long serialVersionUID = 4112578634029874840L; + + /** + * Constructs a new {@code Properties} object. + */ + public CrashReportData() { + super(ReportField.class); + } + + /** + * Returns the property with the specified name. + * + * @param key the name of the property to find. + * @return the named property value, or {@code null} if it can't be found. + */ + public String getProperty(ReportField key) { + return super.get(key); + } + + public JSONObject toJSON() throws JSONReportException { + return JSONReportBuilder.buildJSONReport(this); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/038f06340536e4a02627241ea566bc66a4a2ec2e.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/038f06340536e4a02627241ea566bc66a4a2ec2e.svn-base new file mode 100644 index 0000000..84d4a4b Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/038f06340536e4a02627241ea566bc66a4a2ec2e.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03cad861b3edaba34e5b31d18219eecac207f700.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03cad861b3edaba34e5b31d18219eecac207f700.svn-base new file mode 100644 index 0000000..9b9defe --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03cad861b3edaba34e5b31d18219eecac207f700.svn-base @@ -0,0 +1,227 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03dd2e882d83dcc14e4b4e810b61fe09755f8cf2.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03dd2e882d83dcc14e4b4e810b61fe09755f8cf2.svn-base new file mode 100644 index 0000000..ca7c2de --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/03/03dd2e882d83dcc14e4b4e810b61fe09755f8cf2.svn-base @@ -0,0 +1,63 @@ +package com.adins.mss.svy.reassignment; + +import com.adins.mss.foundation.http.MssRequestType; +import com.google.gson.annotations.SerializedName; + +public class JsonRequestDetailOrder extends MssRequestType{ + /** Property flag */ + @SerializedName("flag") + String flag; + + /** Property nomor_order */ + @SerializedName("nomor_order") + String nomor_order; + + @SerializedName("uuid_task_h") + String uuid_task_h; + + /** Property question_id */ + @SerializedName("question_id") + String question_id; + + /** + * Gets the uuid_task_h + */ + public String getUuid_task_h() { + return this.uuid_task_h; + } + + /** + * Sets the uuid_task_h + */ + public void setUuid_task_h(String value) { + this.uuid_task_h = value; + } + /** + * Gets the flag + */ + public String getFlag() { + return this.flag; + } + + + /** + * Sets the flag + */ + public void setFlag(String value) { + this.flag = value; + } + + /** + * Gets the nomor_order + */ + public String getNomor_order() { + return this.nomor_order; + } + + /** + * Sets the nomor_order + */ + public void setNomor_order(String value) { + this.nomor_order = value; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/0451418f8d6d26e9fd8c9bd9e9ca021a07137247.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/0451418f8d6d26e9fd8c9bd9e9ca021a07137247.svn-base new file mode 100644 index 0000000..be79721 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/0451418f8d6d26e9fd8c9bd9e9ca021a07137247.svn-base @@ -0,0 +1,24 @@ +package com.adins.mss.base.depositreport; + +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +/** + * Created by angga.permadi on 8/29/2016. + */ +public class TaskLogResponse extends MssResponseType { + + @SerializedName("listTaskH") + private List taskHList; + + public List getTaskHList() { + return taskHList; + } + + public void setTaskHList(List taskHList) { + this.taskHList = taskHList; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04566efebca5b7f89e457db71be23c7893adb0a7.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04566efebca5b7f89e457db71be23c7893adb0a7.svn-base new file mode 100644 index 0000000..152d149 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04566efebca5b7f89e457db71be23c7893adb0a7.svn-base @@ -0,0 +1,52 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/046bea219d6f75372c5479e16b0dbbba25821c05.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/046bea219d6f75372c5479e16b0dbbba25821c05.svn-base new file mode 100644 index 0000000..da4288d Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/046bea219d6f75372c5479e16b0dbbba25821c05.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/049f1904bce21858cc16c5876dafabfe89144294.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/049f1904bce21858cc16c5876dafabfe89144294.svn-base new file mode 100644 index 0000000..d73bd7c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/049f1904bce21858cc16c5876dafabfe89144294.svn-base @@ -0,0 +1,139 @@ +package com.adins.mss.foundation.db.dataaccess; + +import android.content.Context; + +import com.adins.mss.dao.CollectionHistory; +import com.adins.mss.dao.CollectionHistoryDao; +import com.adins.mss.dao.DaoSession; +import com.adins.mss.foundation.db.DaoOpenHelper; + +import java.util.List; + +import de.greenrobot.dao.query.QueryBuilder; + +public class CollectionHistoryDataAccess { + +// private static DaoOpenHelper daoOpenHelper; + + /** + * use to generate dao session that you can access modelDao + * + * @param context --> context from activity + * @return + */ + protected static DaoSession getDaoSession(Context context) { + /*if(daoOpenHelper==null){ +// if(daoOpenHelper.getDaoSession()==null) + daoOpenHelper = new DaoOpenHelper(context); + } + DaoSession daoSeesion = daoOpenHelper.getDaoSession(); + return daoSeesion;*/ + return DaoOpenHelper.getDaoSession(context); + } + + /** + * get collectionHistory dao and you can access the DB + * + * @param context + * @return + */ + protected static CollectionHistoryDao getCollectionHistoryDao(Context context) { + return getDaoSession(context).getCollectionHistoryDao(); + } + + /** + * Clear session, close db and set daoOpenHelper to null + */ + public static void closeAll() { + /*if(daoOpenHelper!=null){ + daoOpenHelper.closeAll(); + daoOpenHelper = null; + }*/ + DaoOpenHelper.closeAll(); + } + + /** + * add collectionHistory as entity + * + * @param context + * @param collectionHistory + */ + public static void add(Context context, CollectionHistory collectionHistory) { + getCollectionHistoryDao(context).insert(collectionHistory); + getDaoSession(context).clear(); + } + + /** + * add collectionHistory as list entity + * + * @param context + * @param collectinoHistoryList + */ + public static void add(Context context, List collectinoHistoryList) { + getCollectionHistoryDao(context).insertInTx(collectinoHistoryList); + getDaoSession(context).clear(); + } + + /** + * delete all content in table. + * + * @param context + */ + public static void clean(Context context) { + getCollectionHistoryDao(context).deleteAll(); + } + + /** + * @param context + * @param collectionHistory + */ + public static void delete(Context context, CollectionHistory collectionHistory) { + getCollectionHistoryDao(context).deleteInTx(collectionHistory); + getDaoSession(context).clear(); + } + + /** + * delete all record by user + * + * @param context + * @param uuidUser + */ + public static void delete(Context context, String uuidUser) { + QueryBuilder qb = getCollectionHistoryDao(context).queryBuilder(); + qb.where(CollectionHistoryDao.Properties.Uuid_user.eq(uuidUser)); + qb.build(); + getCollectionHistoryDao(context).deleteInTx(qb.list()); + getDaoSession(context).clear(); + } + + /** + * @param context + * @param collectionHistory + */ + public static void update(Context context, CollectionHistory collectionHistory) { + getCollectionHistoryDao(context).update(collectionHistory); + getDaoSession(context).clear(); + } + + /** + * select * from table where uuid_user = param + * + * @param context + * @param uuidUser + * @return + */ + public static List getAll(Context context, String uuidUser) { + QueryBuilder qb = getCollectionHistoryDao(context).queryBuilder(); + qb.where(CollectionHistoryDao.Properties.Uuid_user.eq(uuidUser)); + qb.build(); + return qb.list(); + } + + /** + * select collectionHistpry per + * + * @param context + * @return + */ + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04aba71a084d91f9b0b81aa748329f346085288c.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04aba71a084d91f9b0b81aa748329f346085288c.svn-base new file mode 100644 index 0000000..831fd7c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04aba71a084d91f9b0b81aa748329f346085288c.svn-base @@ -0,0 +1,293 @@ +package com.adins.mss.dao; + +import java.util.List; +import java.util.ArrayList; +import android.database.Cursor; + +import de.greenrobot.dao.AbstractDao; +import de.greenrobot.dao.Property; +import de.greenrobot.dao.internal.SqlUtils; +import de.greenrobot.dao.internal.DaoConfig; +import de.greenrobot.dao.database.Database; +import de.greenrobot.dao.database.DatabaseStatement; +import de.greenrobot.dao.query.Query; +import de.greenrobot.dao.query.QueryBuilder; + +import com.adins.mss.dao.Menu; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. +/** + * DAO for table "MS_MENU". +*/ +public class MenuDao extends AbstractDao { + + public static final String TABLENAME = "MS_MENU"; + + /** + * Properties of entity Menu.
+ * Can be used for QueryBuilder and for referencing column names. + */ + public static class Properties { + public final static Property Uuid_menu = new Property(0, String.class, "uuid_menu", true, "UUID_MENU"); + public final static Property Menu_id = new Property(1, String.class, "menu_id", false, "MENU_ID"); + public final static Property Flag_job = new Property(2, String.class, "flag_job", false, "FLAG_JOB"); + public final static Property Is_visible = new Property(3, String.class, "is_visible", false, "IS_VISIBLE"); + public final static Property Usr_crt = new Property(4, String.class, "usr_crt", false, "USR_CRT"); + public final static Property Dtm_crt = new Property(5, java.util.Date.class, "dtm_crt", false, "DTM_CRT"); + public final static Property Usr_upd = new Property(6, String.class, "usr_upd", false, "USR_UPD"); + public final static Property Dtm_upd = new Property(7, java.util.Date.class, "dtm_upd", false, "DTM_UPD"); + public final static Property Uuid_user = new Property(8, String.class, "uuid_user", false, "UUID_USER"); + }; + + private DaoSession daoSession; + + private Query user_MenuListQuery; + + public MenuDao(DaoConfig config) { + super(config); + } + + public MenuDao(DaoConfig config, DaoSession daoSession) { + super(config, daoSession); + this.daoSession = daoSession; + } + + /** Creates the underlying database table. */ + public static void createTable(Database db, boolean ifNotExists) { + String constraint = ifNotExists? "IF NOT EXISTS ": ""; + db.execSQL("CREATE TABLE " + constraint + "\"MS_MENU\" (" + // + "\"UUID_MENU\" TEXT PRIMARY KEY NOT NULL ," + // 0: uuid_menu + "\"MENU_ID\" TEXT," + // 1: menu_id + "\"FLAG_JOB\" TEXT," + // 2: flag_job + "\"IS_VISIBLE\" TEXT," + // 3: is_visible + "\"USR_CRT\" TEXT," + // 4: usr_crt + "\"DTM_CRT\" INTEGER," + // 5: dtm_crt + "\"USR_UPD\" TEXT," + // 6: usr_upd + "\"DTM_UPD\" INTEGER," + // 7: dtm_upd + "\"UUID_USER\" TEXT);"); // 8: uuid_user + } + + /** Drops the underlying database table. */ + public static void dropTable(Database db, boolean ifExists) { + String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"MS_MENU\""; + db.execSQL(sql); + } + + /** @inheritdoc */ + @Override + protected void bindValues(DatabaseStatement stmt, Menu entity) { + stmt.clearBindings(); + stmt.bindString(1, entity.getUuid_menu()); + + String menu_id = entity.getMenu_id(); + if (menu_id != null) { + stmt.bindString(2, menu_id); + } + + String flag_job = entity.getFlag_job(); + if (flag_job != null) { + stmt.bindString(3, flag_job); + } + + String is_visible = entity.getIs_visible(); + if (is_visible != null) { + stmt.bindString(4, is_visible); + } + + String usr_crt = entity.getUsr_crt(); + if (usr_crt != null) { + stmt.bindString(5, usr_crt); + } + + java.util.Date dtm_crt = entity.getDtm_crt(); + if (dtm_crt != null) { + stmt.bindLong(6, dtm_crt.getTime()); + } + + String usr_upd = entity.getUsr_upd(); + if (usr_upd != null) { + stmt.bindString(7, usr_upd); + } + + java.util.Date dtm_upd = entity.getDtm_upd(); + if (dtm_upd != null) { + stmt.bindLong(8, dtm_upd.getTime()); + } + + String uuid_user = entity.getUuid_user(); + if (uuid_user != null) { + stmt.bindString(9, uuid_user); + } + } + + @Override + protected void attachEntity(Menu entity) { + super.attachEntity(entity); + entity.__setDaoSession(daoSession); + } + + /** @inheritdoc */ + @Override + public String readKey(Cursor cursor, int offset) { + return cursor.getString(offset + 0); + } + + /** @inheritdoc */ + @Override + public Menu readEntity(Cursor cursor, int offset) { + Menu entity = new Menu( // + cursor.getString(offset + 0), // uuid_menu + cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // menu_id + cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2), // flag_job + cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3), // is_visible + cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4), // usr_crt + cursor.isNull(offset + 5) ? null : new java.util.Date(cursor.getLong(offset + 5)), // dtm_crt + cursor.isNull(offset + 6) ? null : cursor.getString(offset + 6), // usr_upd + cursor.isNull(offset + 7) ? null : new java.util.Date(cursor.getLong(offset + 7)), // dtm_upd + cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8) // uuid_user + ); + return entity; + } + + /** @inheritdoc */ + @Override + public void readEntity(Cursor cursor, Menu entity, int offset) { + entity.setUuid_menu(cursor.getString(offset + 0)); + entity.setMenu_id(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1)); + entity.setFlag_job(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2)); + entity.setIs_visible(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3)); + entity.setUsr_crt(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); + entity.setDtm_crt(cursor.isNull(offset + 5) ? null : new java.util.Date(cursor.getLong(offset + 5))); + entity.setUsr_upd(cursor.isNull(offset + 6) ? null : cursor.getString(offset + 6)); + entity.setDtm_upd(cursor.isNull(offset + 7) ? null : new java.util.Date(cursor.getLong(offset + 7))); + entity.setUuid_user(cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8)); + } + + /** @inheritdoc */ + @Override + protected String updateKeyAfterInsert(Menu entity, long rowId) { + return entity.getUuid_menu(); + } + + /** @inheritdoc */ + @Override + public String getKey(Menu entity) { + if(entity != null) { + return entity.getUuid_menu(); + } else { + return null; + } + } + + /** @inheritdoc */ + @Override + protected boolean isEntityUpdateable() { + return true; + } + + /** Internal query to resolve the "menuList" to-many relationship of User. */ + public List _queryUser_MenuList(String uuid_user) { + synchronized (this) { + if (user_MenuListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Uuid_user.eq(null)); + user_MenuListQuery = queryBuilder.build(); + } + } + Query query = user_MenuListQuery.forCurrentThread(); + query.setParameter(0, uuid_user); + return query.list(); + } + + private String selectDeep; + + protected String getSelectDeep() { + if (selectDeep == null) { + StringBuilder builder = new StringBuilder("SELECT "); + SqlUtils.appendColumns(builder, "T", getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T0", daoSession.getUserDao().getAllColumns()); + builder.append(" FROM MS_MENU T"); + builder.append(" LEFT JOIN MS_USER T0 ON T.\"UUID_USER\"=T0.\"UUID_USER\""); + builder.append(' '); + selectDeep = builder.toString(); + } + return selectDeep; + } + + protected Menu loadCurrentDeep(Cursor cursor, boolean lock) { + Menu entity = loadCurrent(cursor, 0, lock); + int offset = getAllColumns().length; + + User user = loadCurrentOther(daoSession.getUserDao(), cursor, offset); + entity.setUser(user); + + return entity; + } + + public Menu loadDeep(Long key) { + assertSinglePk(); + if (key == null) { + return null; + } + + StringBuilder builder = new StringBuilder(getSelectDeep()); + builder.append("WHERE "); + SqlUtils.appendColumnsEqValue(builder, "T", getPkColumns()); + String sql = builder.toString(); + + String[] keyArray = new String[] { key.toString() }; + Cursor cursor = db.rawQuery(sql, keyArray); + + try { + boolean available = cursor.moveToFirst(); + if (!available) { + return null; + } else if (!cursor.isLast()) { + throw new IllegalStateException("Expected unique result, but count was " + cursor.getCount()); + } + return loadCurrentDeep(cursor, true); + } finally { + cursor.close(); + } + } + + /** Reads all available rows from the given cursor and returns a list of new ImageTO objects. */ + public List loadAllDeepFromCursor(Cursor cursor) { + int count = cursor.getCount(); + List list = new ArrayList(count); + + if (cursor.moveToFirst()) { + if (identityScope != null) { + identityScope.lock(); + identityScope.reserveRoom(count); + } + try { + do { + list.add(loadCurrentDeep(cursor, false)); + } while (cursor.moveToNext()); + } finally { + if (identityScope != null) { + identityScope.unlock(); + } + } + } + return list; + } + + protected List loadDeepAllAndCloseCursor(Cursor cursor) { + try { + return loadAllDeepFromCursor(cursor); + } finally { + cursor.close(); + } + } + + + /** A raw-style query where you can pass any WHERE clause and arguments. */ + public List queryDeep(String where, String... selectionArg) { + Cursor cursor = db.rawQuery(getSelectDeep() + where, selectionArg); + return loadDeepAllAndCloseCursor(cursor); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04da777d8620af56bd75d92d402a04aa186205f9.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04da777d8620af56bd75d92d402a04aa186205f9.svn-base new file mode 100644 index 0000000..7552141 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04da777d8620af56bd75d92d402a04aa186205f9.svn-base @@ -0,0 +1,87 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04dd79a0de6f11a60d6d13b5ea9936ed36b21239.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04dd79a0de6f11a60d6d13b5ea9936ed36b21239.svn-base new file mode 100644 index 0000000..cd2df4c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04dd79a0de6f11a60d6d13b5ea9936ed36b21239.svn-base @@ -0,0 +1,148 @@ +package com.adins.mss.coll.models; + +import com.adins.mss.foundation.http.MssResponseType; + +/** + * Created by adityapurwa on 20/03/15. + */ +public class PaymentHistoryResponseHeader extends MssResponseType { + + private String uuidTaskId; + + private java.util.Date dtmCrt; + + private String usrCrt; + + private java.util.Date dtmUpd; + private String usrUpd; + private String agreementNo; + private String branchCode; + private String receiptNo; + private String valueDate; + private java.util.Date postingDate; + private String paymentAmount; + private String installmentAmount; + private String installmentNumber; + private String transactionType; + private String wopCode; + + public String getUuidTaskId() { + return uuidTaskId; + } + + public void setUuidTaskId(String uuidTaskId) { + this.uuidTaskId = uuidTaskId; + } + + public java.util.Date getDtmCrt() { + return dtmCrt; + } + + public void setDtmCrt(java.util.Date dtmCrt) { + this.dtmCrt = dtmCrt; + } + + public String getUsrCrt() { + return usrCrt; + } + + public void setUsrCrt(String usrCrt) { + this.usrCrt = usrCrt; + } + + public java.util.Date getDtmUpd() { + return dtmUpd; + } + + public void setDtmUpd(java.util.Date dtmUpd) { + this.dtmUpd = dtmUpd; + } + + public String getUsrUpd() { + return usrUpd; + } + + public void setUsrUpd(String usrUpd) { + this.usrUpd = usrUpd; + } + + public String getAgreementNo() { + return agreementNo; + } + + public void setAgreementNo(String agreementNo) { + this.agreementNo = agreementNo; + } + + public String getBranchCode() { + return branchCode; + } + + public void setBranchCode(String branchCode) { + this.branchCode = branchCode; + } + + public String getReceiptNo() { + return receiptNo; + } + + public void setReceiptNo(String receiptNo) { + this.receiptNo = receiptNo; + } + + public String getValueDate() { + return valueDate; + } + + public void setValueDate(String valueDate) { + this.valueDate = valueDate; + } + + public java.util.Date getPostingDate() { + return postingDate; + } + + public void setPostingDate(java.util.Date postingDate) { + this.postingDate = postingDate; + } + + public String getPaymentAmount() { + return paymentAmount; + } + + public void setPaymentAmount(String paymentAmount) { + this.paymentAmount = paymentAmount; + } + + public String getInstallmentAmount() { + return installmentAmount; + } + + public void setInstallmentAmount(String installmentAmount) { + this.installmentAmount = installmentAmount; + } + + public String getInstallmentNumber() { + return installmentNumber; + } + + public void setInstallmentNumber(String installmentNumber) { + this.installmentNumber = installmentNumber; + } + + public String getTransactionType() { + return transactionType; + } + + public void setTransactionType(String transactionType) { + this.transactionType = transactionType; + } + + public String getWopCode() { + return wopCode; + } + + public void setWopCode(String wopCode) { + this.wopCode = wopCode; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04e4e28e6a16246e88b60cfa04508ce1ff11f2fd.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04e4e28e6a16246e88b60cfa04508ce1ff11f2fd.svn-base new file mode 100644 index 0000000..0af32ee --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/04/04e4e28e6a16246e88b60cfa04508ce1ff11f2fd.svn-base @@ -0,0 +1,21 @@ +package com.adins.mss.base.models; + +import com.adins.mss.foundation.http.MssRequestType; +import com.google.gson.annotations.SerializedName; + +/** + * Created by eric.sn on 4/5/2017. + */ + +public class CheckResubmitRequest extends MssRequestType { + @SerializedName("uuid_task_h") + public String uuidTaskH; + + public String getUuidTaskH() { + return uuidTaskH; + } + + public void setUuidTaskH(String uuidTaskH) { + this.uuidTaskH = uuidTaskH; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/052481bbbae93c5f10941cee58ae01c67ee212e4.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/052481bbbae93c5f10941cee58ae01c67ee212e4.svn-base new file mode 100644 index 0000000..804b56a Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/052481bbbae93c5f10941cee58ae01c67ee212e4.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/0540e9e0a4b4d961423b684a6eb68c8ce5662443.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/0540e9e0a4b4d961423b684a6eb68c8ce5662443.svn-base new file mode 100644 index 0000000..8aa4f0c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/0540e9e0a4b4d961423b684a6eb68c8ce5662443.svn-base @@ -0,0 +1,601 @@ +package com.adins.mss.svy; + +import android.app.ActionBar; +import android.content.Intent; +import android.os.Bundle; +import android.os.Handler; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentTransaction; +import androidx.drawerlayout.widget.DrawerLayout; +import android.view.KeyEvent; +import android.view.View; +import android.widget.AdapterView; +import android.widget.ListView; + +import com.adins.mss.base.ChangePasswordFragment; +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.R; +import com.adins.mss.base.about.activity.AboutActivity; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.mainmenu.MainMenuActivity; +import com.adins.mss.base.mainmenu.MainMenuHelper; +import com.adins.mss.base.tasklog.TaskLogImpl; +import com.adins.mss.base.timeline.MenuAdapter; +import com.adins.mss.base.timeline.MenuModel; +import com.adins.mss.base.todo.form.GetSchemeTask; +import com.adins.mss.base.todolist.ToDoList; +import com.adins.mss.base.todolist.form.StatusTabFragment; +import com.adins.mss.base.todolist.form.TaskListFragment_new; +import com.adins.mss.base.todolist.form.TaskListTask; +import com.adins.mss.base.todolist.form.TaskList_Fragment; +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.db.dataaccess.GeneralParameterDataAccess; +import com.adins.mss.foundation.db.dataaccess.MenuDataAccess; +import com.adins.mss.svy.assignment.OrderAssignmentActivity; +import com.adins.mss.svy.assignment.OrderAssignmentTask; +import com.adins.mss.svy.fragments.SurveyApprovalByBranchFragment; +import com.adins.mss.svy.fragments.SurveyApprovalFragment; +import com.adins.mss.svy.fragments.SurveyPerformanceFragment; +import com.adins.mss.svy.fragments.SurveyVerificationByBranchFragment; +import com.adins.mss.svy.fragments.SurveyVerificationFragment; +import com.adins.mss.svy.reassignment.OrderFilterActivity; +import com.adins.mss.svy.tool.Constants; +import com.services.FirebaseMessagingService; +import com.services.NotificationThread; +import com.services.SurveyApprovalService; +import com.services.SurveyApprovalThread; +import com.services.SurveyAssignmentThread; +import com.services.SurveyVerificationService; +import com.services.SurveyVerificationThread; + +import java.util.ArrayList; +import java.util.List; + +public class MSMainMenuActivity extends com.adins.mss.base.mainmenu.MainMenuActivity{ + + public static MenuModel mnTimeline; + public static MenuModel mnNewTask; +// public static MenuModel mnTaskList; +// public static MenuModel mnLog; + public static MenuModel mnSVYPerformance; +// public static MenuModel mnSVYVerifyByBranch; +// public static MenuModel mnSVYApprovalByBranch; + public static MenuModel mnAbsentI; + public static MenuModel mnOrderAssignment; + public static MenuModel mnOrderReassignment; + public static MenuModel mnExit; + public static MenuModel mnAbout; + public static MenuModel mnSynchronize; + public static MenuModel mnChangePassword; + public static int flag_edit=0; + public static boolean inAbsent=false; + public static SurveyVerificationThread verificationThread; + public static SurveyApprovalThread approvalThread; + Fragment fragment; + ChangePasswordFragment fragmentChgPwd; + private DrawerLayout mDrawerLayout; + private ListView mDrawerListLeft; + + + @Override + protected ArrayList getModels() { + // TODO Auto-generated method stub + + ArrayList models = new ArrayList(); + MenuModel titleGroup1 = new MenuModel(getString(R.string.title_mn_main_menu)); + titleGroup1.isGroupHeader(); + MenuModel titleGroup2 = new MenuModel(getString(R.string.title_mn_other)); + titleGroup2.isGroupHeader(); + + mnTimeline = new MenuModel(R.drawable.ic_home, getString(R.string.title_mn_home), null); + models.add(titleGroup1); + models.add(mnTimeline); + List mainMenuTitle = getMainMenuTitle(); + List mainMenuIcon = getMainMenuIcon(); + for(int i=0; i otherMenuTitle = getOtherMenuTitle(); + List otherMenuIcon = getOtherMenuIcon(); +// mnChangePassword = new MenuModel(R.drawable.ic_changepassword,getString(R.string.title_mn_changepassword), null); +// models.add(mnChangePassword); + for(int i=0; i parent, View view, final int position, + long id) { + // TODO Auto-generated method stub + super.onItemClick(parent, view, position, id); + + new Handler().postDelayed(new Runnable() { + @Override + public void run() { + if(getString(R.string.title_mn_changepassword).equalsIgnoreCase(allMenu.get(position))){ + gotoChangePassword(); + } + } + }, 250); + } + + //bong 10 apr 15 - menjaga saat change password tidak dapat lihat menu + public boolean onKeyDown(int keyCode, KeyEvent event) { + if (keyCode == KeyEvent.KEYCODE_MENU) { + if(fragmentChgPwd!=null){ + if(fragmentChgPwd.isVisible()){ + return true; + } + } + return super.onKeyDown(keyCode, event); + } + return super.onKeyDown(keyCode, event); + } + + //bong 7 apr 15 disabled onBackpressed on fragment + @Override + public void onBackPressed() { + // TODO Auto-generated method stub +// if(fragmentChgPwd!=null && fragmentChgPwd.isVisible()){ +// if(GlobalData.getSharedGlobalData().getUser().getChg_pwd().equals("1")){ +// fragmentChgPwd.onBackPressed(); +// return; +// } +// } + super.onBackPressed(); + } + + private void gotoChangePassword() { + fragment = new ChangePasswordFragment(); + Bundle args = new Bundle(); + args.putBoolean(ChangePasswordFragment.AS_ACTIVITY, false); + fragment.setArguments(args); + if(GlobalData.getSharedGlobalData().getUser().getChg_pwd().equals("1")){ + fragmentChgPwd = (ChangePasswordFragment) fragment; + fragmentChgPwd.setArguments(args); + } + FragmentTransaction transaction = MainMenuActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate,R.anim.activity_close_scale,R.anim.activity_open_scale,R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + + + @Override + protected Intent getIntentSynchronize() { + // TODO Auto-generated method stub + return new Intent(this, MSSynchronizeActivity.class); + } + + @Override + protected Fragment getChgPassFragment() { + // TODO Auto-generated method stub + return fragmentChgPwd; + } + @Override + protected void goTimeline(int position) { +// TimelineModel.taskList_Fragment=new TaskList_Fragment(); + super.goTimeline(position); + } + + @Override + protected void gotoNewTask(int position) { + GetSchemeTask task = new GetSchemeTask(this, new MSNewTaskActivity(), true); + task.execute(); + } + + @Override + protected void gotoCheckOrder(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoCreditSimulation(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoCancelOrder(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoTaskList(int position) { + TaskListTask task = new TaskListTask(this, getString(R.string.progressWait), + getString(R.string.msgNoTaskList), R.id.content_frame); + task.execute(); + } + + @Override + protected void gotoPromo(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoNews(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoSurveyPerformance(int position) { + fragment = new SurveyPerformanceFragment(); + FragmentTransaction transaction = MainMenuActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate,R.anim.activity_close_scale,R.anim.activity_open_scale,R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + + @Override + protected void gotoSurveyVerification(int position) { + fragment = new SurveyVerificationFragment(); + SurveyVerificationListTask task = new SurveyVerificationListTask(this, getString(R.string.progressWait), + getString(R.string.msgNoVerification),null); + task.execute(); + } + + @Override + protected void gotoSurveyApproval(int position) { + fragment = new SurveyApprovalFragment(); + SurveyApprovalListTask task = new SurveyApprovalListTask(this, getString(R.string.progressWait), + getString(R.string.msgNoApproval),null); + task.execute(); + } + + @Override + protected void gotoOrderAssignment(int position) { + showNotAvailableMenu(position); + } + @Override + protected void gotoOrderReassignment(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoSurveyAssignment(int position) { + OrderAssignmentTask task = new OrderAssignmentTask(this, getString(R.string.progressWait), + getString(R.string.msgNoList),R.id.content_frame); + task.execute(); + } + + @Override + protected void gotoSurveyReassignment(int position) { + fragment = new OrderFilterActivity(); + Bundle args = new Bundle(); + args.putInt(Global.BUND_KEY_TASK_TYPE, Global.TASK_ORDER_REASSIGNMENT); + fragment.setArguments(args); + + FragmentTransaction transaction = MainMenuActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate,R.anim.activity_close_scale,R.anim.activity_open_scale,R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + + @Override + protected void gotoReportSummary(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoDepositReport(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoPaymentHistory(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoInstallmentSchedule(int position) { + showNotAvailableMenu(position); + } + + @Override + protected void gotoClosingTask(int position) { + + } + + public void showNotAvailableMenu(int position){ + MainMenuHelper.showNotAvailableMenuDialog(MSMainMenuActivity.this, allMenu.get(position)); + Global.positionStack.pop(); + mDrawerListLeft.setItemChecked(Global.positionStack.lastElement(), true); + setTitle(models.get(Global.positionStack.lastElement()).getTitle()); + } + + @Override + protected void gotoSurveyVerificationByBranch(int position) { + fragment = new SurveyVerificationFragment(); + SurveyVerificationListTask task = new SurveyVerificationListTask(this, getString(R.string.progressWait), + getString(R.string.msgNoVerification), SurveyVerificationListTask.KEY_BRANCH); + task.execute(); + } + + @Override + protected void gotoSurveyApprovalByBranch(int position) { + fragment = new SurveyApprovalFragment(); + SurveyApprovalListTask task = new SurveyApprovalListTask(this, getString(R.string.progressWait), + getString(R.string.msgNoApproval), SurveyApprovalListTask.KEY_BRANCH); + task.execute(); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/059a714eccb99bec6aa7518f7440c2fe3aa06ed9.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/059a714eccb99bec6aa7518f7440c2fe3aa06ed9.svn-base new file mode 100644 index 0000000..2895dc0 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/059a714eccb99bec6aa7518f7440c2fe3aa06ed9.svn-base @@ -0,0 +1,23 @@ +package com.adins.mss.base.dynamicform; + +import com.adins.mss.base.dynamicform.form.models.PhotoDocumentBean; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.io.Serializable; +import java.util.List; + +public class JsonResponseLuOnlineView extends MssResponseType implements Serializable { + + @SerializedName("data") + private List data; + + public List getData() { + return data; + } + + public void setData(List data) { + this.data = data; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05a969e1040a2a2f39901084177933608133bddf.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05a969e1040a2a2f39901084177933608133bddf.svn-base new file mode 100644 index 0000000..eff74f0 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05a969e1040a2a2f39901084177933608133bddf.svn-base @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05af52380b56bd7ec190658c541df94a650c3cc8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05af52380b56bd7ec190658c541df94a650c3cc8.svn-base new file mode 100644 index 0000000..cec2c62 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05af52380b56bd7ec190658c541df94a650c3cc8.svn-base @@ -0,0 +1,5 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05bbe186df8fc6c679bbaa3a4cbf7104d452e829.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05bbe186df8fc6c679bbaa3a4cbf7104d452e829.svn-base new file mode 100644 index 0000000..45d7409 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05bbe186df8fc6c679bbaa3a4cbf7104d452e829.svn-base @@ -0,0 +1,95 @@ +package com.adins.mss.coll.api; + +import android.content.Context; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.base.util.Utility; +import com.adins.mss.coll.models.InstallmentScheduleRequest; +import com.adins.mss.coll.models.InstallmentScheduleResponse; +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.http.HttpConnectionResult; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.google.firebase.perf.FirebasePerformance; +import com.google.firebase.perf.metrics.HttpMetric; + +import java.io.IOException; + +/** + * Created by adityapurwa on 06/05/15. + */ +public class InstallmentScheduleApi { + private final Context context; + + public InstallmentScheduleApi(Context context) { + this.context = context; + } + + public InstallmentScheduleResponse request(String taskId) throws IOException { + InstallmentScheduleRequest request = new InstallmentScheduleRequest(); + request.setTaskId(taskId); + request.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + + String requestJson = GsonHelper.toJson(request); + + //HttpClient client = new HttpClient(context); + String url = GlobalData.getSharedGlobalData().getURL_GET_INSTALLMENTSCHEDULE(); +// Request httpRequest = client.request(url) +// .post(RequestBody.create(MediaType.parse("application/json"), requestJson)) +// .build(); +// +// Response response = client.execute(httpRequest); +// String responseJson = response.body().string(); + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + HttpCryptedConnection httpConn = new HttpCryptedConnection(context, encrypt, decrypt); + HttpConnectionResult serverResult = null; + + HttpMetric networkMetric = + FirebasePerformance.getInstance().newHttpMetric(url, FirebasePerformance.HttpMethod.POST); + Utility.metricStart(networkMetric, requestJson); + + try { + serverResult = httpConn.requestToServer(url, requestJson, Global.DEFAULTCONNECTIONTIMEOUT); + Utility.metricStop(networkMetric, serverResult); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + String responseJson ="" ; + if(serverResult!=null && serverResult.isOK()){ + try { + responseJson = serverResult.getResult(); + } catch (Exception e) { + FireCrash.log(e); } + } + + // bong 21 mei 15 - add or replace to local database + InstallmentScheduleResponse installmentSchedResp = GsonHelper.fromJson(responseJson, InstallmentScheduleResponse.class); +// if(installmentSchedResp!=null){ +// List installmentScheduleList = installmentSchedResp.getInstallmentScheduleList(); +// if(installmentScheduleList!=null && installmentScheduleList.size()>0){ +// List installmentScheduleLocalList = null; +// TaskH taskH = TaskHDataAccess.getOneTaskHeader(context, taskId); +// for(InstallmentSchedule installmentSchedule : installmentScheduleList){ +// String agreementNo = installmentSchedule.getAgreement_no(); +// if(agreementNo!=null && agreementNo.length()>0){ +// installmentScheduleLocalList = InstallmentScheduleDataAccess.getAll(context, agreementNo); +// InstallmentScheduleDataAccess.delete(context, installmentSchedule.getUuid_task_h()); +// taskH.setAppl_no(agreementNo); +// TaskHDataAccess.addOrReplace(context, taskH); +// } +// if(installmentSchedule.getUuid_installment_schedule()==null){ +// installmentSchedule.setUuid_installment_schedule(Tool.getUUID()); +// } +// InstallmentScheduleDataAccess.add(context, installmentSchedule); +// } +// } +// } + //return gson.fromJson(responseJson, InstallmentScheduleResponse.class); + return installmentSchedResp; + + + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05dd4aadb59bf531eb424c3af85d28c5fa0b9fec.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05dd4aadb59bf531eb424c3af85d28c5fa0b9fec.svn-base new file mode 100644 index 0000000..8673714 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05dd4aadb59bf531eb424c3af85d28c5fa0b9fec.svn-base @@ -0,0 +1,32 @@ +package com.adins.mss.base.dukcapil; + +import com.google.gson.annotations.SerializedName; + +import java.util.HashMap; + +public class ImageDkcpBean { + @SerializedName("status") + String generatedStatus; + + @SerializedName("read") + HashMap read; + + public HashMap getValue() { + return read; + } + + public void setValue(HashMap value) { + this.read = value; + } + + public String getGeneratedStatus() { + return generatedStatus; + } + + public void setGeneratedStatus(String generatedStatus) { + this.generatedStatus = generatedStatus; + } + public String getValueRead(String key){ + return read.get(key); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05e00fda4c44c5192f857b6c64cce9bf65016fef.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05e00fda4c44c5192f857b6c64cce9bf65016fef.svn-base new file mode 100644 index 0000000..01de673 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/05/05e00fda4c44c5192f857b6c64cce9bf65016fef.svn-base @@ -0,0 +1,48 @@ + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0a/0af969a0c40152609e6b50a72fcb5fa5af328f4a.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0a/0af969a0c40152609e6b50a72fcb5fa5af328f4a.svn-base new file mode 100644 index 0000000..aac0ad3 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0a/0af969a0c40152609e6b50a72fcb5fa5af328f4a.svn-base @@ -0,0 +1,22 @@ +package com.adins.mss.coll.networks.responses; + +import com.adins.mss.coll.networks.entities.ClosingTaskEntity; +import com.adins.mss.foundation.http.MssResponseType; + +import java.util.List; + +/** + * Created by angga.permadi on 6/6/2016. + */ +public class ClosingTaskListResponse extends MssResponseType { + + private List taskList; + + public List getTaskList() { + return taskList; + } + + public void setTaskList(List taskList) { + this.taskList = taskList; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b01a7dfd3f0370bb99ea99defcacf979d7b42ee.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b01a7dfd3f0370bb99ea99defcacf979d7b42ee.svn-base new file mode 100644 index 0000000..1e6810e Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b01a7dfd3f0370bb99ea99defcacf979d7b42ee.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b050b327309e64185f303adca13ce736c3d3f08.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b050b327309e64185f303adca13ce736c3d3f08.svn-base new file mode 100644 index 0000000..2fa5a35 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b050b327309e64185f303adca13ce736c3d3f08.svn-base @@ -0,0 +1,9 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b1e95484798803086054e303dafab63fe7e34a8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b1e95484798803086054e303dafab63fe7e34a8.svn-base new file mode 100644 index 0000000..2e0bc5e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b1e95484798803086054e303dafab63fe7e34a8.svn-base @@ -0,0 +1,154 @@ +package com.adins.mss.odr; + +import org.acra.ACRA; + +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.UserHelp.UserHelp; +import com.adins.mss.odr.reassignment.OrderReassignmentResult; +import com.adins.mss.odr.update.ResultUpdateActivity; +import com.google.firebase.analytics.FirebaseAnalytics; + +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.os.Handler; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewTreeObserver; +import android.widget.ArrayAdapter; +import android.widget.LinearLayout; +import android.widget.RelativeLayout; +import android.widget.Spinner; +import android.widget.TextView; + +import static com.adins.mss.constant.Global.SHOW_USERHELP_DELAY_DEFAULT; + +public class OrderFilterActivity extends CheckOrderActivity{ + private int taskType; + private Spinner cbSearchByStatus; + private String[] contentStatusFilter; + private TextView labelSearchByStatus; + private RelativeLayout layoutFilterByStatus; + private Bundle mArguments; + private LinearLayout container; + private FirebaseAnalytics screenName; +// private View view; + public OrderFilterActivity() { + // TODO Auto-generated constructor stub + } + + @Override + public void onAttach(Context activity) { + super.onAttach(activity); + setHasOptionsMenu(true); + ACRA.getErrorReporter().putCustomData("LAST_CLASS_ACCESSED", getClass().getSimpleName()); + mArguments = getArguments(); + taskType = mArguments.getInt(Global.BUND_KEY_TASK_TYPE, 0); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + super.onCreateView(inflater, container, savedInstanceState); + screenName = FirebaseAnalytics.getInstance(getActivity()); +// if(taskType==Global.TASK_CANCEL_ORDER){ +// addStatusFilter(); +// } + + this.container = view.findViewById(R.id.container); + this.container.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { + @Override + public void onGlobalLayout() { + Handler handler = new Handler(); + handler.postDelayed(new Runnable() { + @Override + public void run() { + if(!UserHelp.isActive) + UserHelp.showAllUserHelp(OrderFilterActivity.this.getActivity(),OrderFilterActivity.this.getClass().getSimpleName()); + } + }, SHOW_USERHELP_DELAY_DEFAULT); + } + }); + + + return view; + } + + private void addStatusFilter() { + labelSearchByStatus = (TextView)view.findViewById(R.id.lblSearchByStatus); + cbSearchByStatus = (Spinner)view.findViewById(R.id.cbSearcrByStatus); + layoutFilterByStatus = (RelativeLayout)view.findViewById(R.id.filterByStatus); + labelSearchByStatus.setVisibility(View.VISIBLE); + layoutFilterByStatus.setVisibility(View.VISIBLE); + ArrayAdapter adapter=ArrayAdapter.createFromResource + (getActivity(), R.array.cbSearchByStatus,R.layout.spinner_style); + cbSearchByStatus.setAdapter(adapter); + } + + @Override + protected Intent getNextActivityIntent() { + Intent intent =null; + if(taskType==Global.TASK_CANCEL_ORDER){ + intent = new Intent(getActivity(), ResultUpdateActivity.class); + intent.putExtra(Global.BUND_KEY_TASK_TYPE, taskType); +// int selectedItemPosition = cbSearchByStatus.getSelectedItemPosition(); +// String keySearchBy = ""; +// if(0==selectedItemPosition){ +// keySearchBy = "ALL"; +// }else if(1==selectedItemPosition){ +// keySearchBy = "OnSurvey"; +// }else if(2==selectedItemPosition){ +// keySearchBy = "OnCA"; +// } +// +// intent.putExtra("status", keySearchBy); + }else if(taskType==Global.TASK_ORDER_REASSIGNMENT){ + intent = new Intent(getActivity(), OrderReassignmentResult.class); + intent.putExtra(Global.BUND_KEY_TASK_TYPE, taskType); + } + + return intent; + } + @Override + public void onResume(){ + super.onResume(); +// getActivity().getActionBar().removeAllTabs(); + if(taskType==Global.TASK_CANCEL_ORDER){ + getActivity().setTitle(getString(R.string.title_mn_cancelorder)); + screenName.setCurrentScreen(getActivity(), getString(R.string.screen_name_cancel_order), null); + disableCheckOrderBtn(); + } + else if(taskType==Global.TASK_ORDER_REASSIGNMENT){ + //Set Firebase screen name + screenName.setCurrentScreen(getActivity(), getString(R.string.screen_name_order_reassignment), null); + getActivity().setTitle(getString(R.string.title_mn_orderreassign)); + } +// getActivity().getActionBar().setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + + if(item.getItemId() == R.id.mnGuide){ + if(!Global.BACKPRESS_RESTRICTION) { + Handler handler = new Handler(); + handler.postDelayed(new Runnable() { + @Override + public void run() { + if (!UserHelp.isActive) + UserHelp.showAllUserHelp(OrderFilterActivity.this.getActivity(), OrderFilterActivity.this.getClass().getSimpleName()); + } + }, SHOW_USERHELP_DELAY_DEFAULT); + container.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { + @Override + public void onGlobalLayout() { + if (!UserHelp.isActive) + UserHelp.showAllUserHelp(OrderFilterActivity.this.getActivity(), OrderFilterActivity.this.getClass().getSimpleName()); + } + }); + } + } + return super.onOptionsItemSelected(item); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b71fe752e34e6d60a098c4b1906d2e53a6bd3a5.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b71fe752e34e6d60a098c4b1906d2e53a6bd3a5.svn-base new file mode 100644 index 0000000..fb75497 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b71fe752e34e6d60a098c4b1906d2e53a6bd3a5.svn-base @@ -0,0 +1,19 @@ + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b967759160acf8eadf2a8c5fd351fdd8c7d95ff.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b967759160acf8eadf2a8c5fd351fdd8c7d95ff.svn-base new file mode 100644 index 0000000..69ef423 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0b967759160acf8eadf2a8c5fd351fdd8c7d95ff.svn-base @@ -0,0 +1,20 @@ +package com.adins.mss.foundation.sync.api; + +import com.adins.mss.dao.Lookup; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +public class SynchronizeResponseLookup extends MssResponseType { + @SerializedName("listSync") + private List listSync; + + public List getListSync() { + return listSync; + } + + public void setListSync(List listSync) { + this.listSync = listSync; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bbf0254c6b9a5a330b765e006af366e46f0cf6e.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bbf0254c6b9a5a330b765e006af366e46f0cf6e.svn-base new file mode 100644 index 0000000..3bf57a9 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bbf0254c6b9a5a330b765e006af366e46f0cf6e.svn-base @@ -0,0 +1,25 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bc1d9ea845bd03cdfd9dc4c82d6e78e89afbaf6.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bc1d9ea845bd03cdfd9dc4c82d6e78e89afbaf6.svn-base new file mode 100644 index 0000000..56da47b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bc1d9ea845bd03cdfd9dc4c82d6e78e89afbaf6.svn-base @@ -0,0 +1,170 @@ +package com.adins.libs.nineoldandroids.animation; + +import android.view.View; + +import com.adins.libs.nineoldandroids.util.FloatProperty; +import com.adins.libs.nineoldandroids.util.IntProperty; +import com.adins.libs.nineoldandroids.util.Property; +import com.adins.libs.nineoldandroids.view.animation.AnimatorProxy; + +final class PreHoneycombCompat { + static Property ALPHA = new FloatProperty("alpha") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setAlpha(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getAlpha(); + } + }; + static Property PIVOT_X = new FloatProperty("pivotX") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setPivotX(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getPivotX(); + } + }; + static Property PIVOT_Y = new FloatProperty("pivotY") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setPivotY(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getPivotY(); + } + }; + static Property TRANSLATION_X = new FloatProperty("translationX") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setTranslationX(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getTranslationX(); + } + }; + static Property TRANSLATION_Y = new FloatProperty("translationY") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setTranslationY(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getTranslationY(); + } + }; + static Property ROTATION = new FloatProperty("rotation") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setRotation(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getRotation(); + } + }; + static Property ROTATION_X = new FloatProperty("rotationX") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setRotationX(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getRotationX(); + } + }; + static Property ROTATION_Y = new FloatProperty("rotationY") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setRotationY(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getRotationY(); + } + }; + static Property SCALE_X = new FloatProperty("scaleX") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setScaleX(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getScaleX(); + } + }; + static Property SCALE_Y = new FloatProperty("scaleY") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setScaleY(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getScaleY(); + } + }; + static Property SCROLL_X = new IntProperty("scrollX") { + @Override + public void setValue(View object, int value) { + AnimatorProxy.wrap(object).setScrollX(value); + } + + @Override + public Integer get(View object) { + return AnimatorProxy.wrap(object).getScrollX(); + } + }; + static Property SCROLL_Y = new IntProperty("scrollY") { + @Override + public void setValue(View object, int value) { + AnimatorProxy.wrap(object).setScrollY(value); + } + + @Override + public Integer get(View object) { + return AnimatorProxy.wrap(object).getScrollY(); + } + }; + static Property X = new FloatProperty("x") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setX(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getX(); + } + }; + static Property Y = new FloatProperty("y") { + @Override + public void setValue(View object, float value) { + AnimatorProxy.wrap(object).setY(value); + } + + @Override + public Float get(View object) { + return AnimatorProxy.wrap(object).getY(); + } + }; + + + //No instances + private PreHoneycombCompat() { + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bcde7c0d6b9a0f2dc66faedf807844689d89405.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bcde7c0d6b9a0f2dc66faedf807844689d89405.svn-base new file mode 100644 index 0000000..f585e69 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bcde7c0d6b9a0f2dc66faedf807844689d89405.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bf646cb14591777fe42a10db289cf230635c271.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bf646cb14591777fe42a10db289cf230635c271.svn-base new file mode 100644 index 0000000..61f209a --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0b/0bf646cb14591777fe42a10db289cf230635c271.svn-base @@ -0,0 +1,74 @@ +package com.adins.mss.foundation.camera2; + +import android.app.Activity; +import android.content.Context; +import android.os.Build; +import android.os.Bundle; +import androidx.annotation.RequiresApi; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.R; +import com.adins.mss.base.util.LocaleHelper; + +import java.util.Locale; + +/** + * Created by ahmadkamilalmasyhur on 25/01/2018. + */ + +public class Camera2BasicRealActivity extends Activity { + public static final String PICTURE_WIDTH = "picture_width"; + public static final String PICTURE_HEIGHT = "picture_height"; + public static final String PICTURE_QUALITY = "picture_quality"; + public static final String PICTURE_URI = "picture_path"; + + public static final int PICTURE_WIDHT_DEF = 1024; + public static final int PICTURE_HEIGHT_DEF = 768; + public static final int PICTURE_QUALITY_DEF = 70; + + private static int width; + private static int height; + private static int quality; + + @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_camera2); + + Bundle bundle = getIntent().getExtras(); + + if (getIntent().getExtras() != null) { + width = getIntent().getExtras().getInt(PICTURE_WIDTH); + height = getIntent().getExtras().getInt(PICTURE_HEIGHT); + quality = getIntent().getExtras().getInt(PICTURE_QUALITY); + } + + if (width <= 0) width = PICTURE_WIDHT_DEF; + if (height <= 0) height = PICTURE_HEIGHT_DEF; + if (quality <= 0) quality = PICTURE_QUALITY_DEF; + + Camera2BasicActivity camera2BasicActivity = Camera2BasicActivity.newInstance(); + camera2BasicActivity.setArguments(bundle); + + if (null == savedInstanceState) { + getFragmentManager().beginTransaction() + .replace(R.id.container, camera2BasicActivity) + .commit(); + } + } + @Override + protected void attachBaseContext(Context newBase) { + Context context = newBase; + Locale locale; + try{ + locale = new Locale(GlobalData.getSharedGlobalData().getLocale()); + context = LocaleHelper.wrap(newBase, locale); + } catch (Exception e) { + locale = new Locale(LocaleHelper.ENGLSIH); + context = LocaleHelper.wrap(newBase, locale); + } finally { + super.attachBaseContext(context); + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c1d11c429c2cceb06f1ad8189aac00148daf30e.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c1d11c429c2cceb06f1ad8189aac00148daf30e.svn-base new file mode 100644 index 0000000..60498f7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c1d11c429c2cceb06f1ad8189aac00148daf30e.svn-base @@ -0,0 +1,369 @@ +package com.adins.mss.odr.followup; + +import android.app.ProgressDialog; +import android.content.Context; +import android.os.AsyncTask; +import android.os.Bundle; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentTransaction; +import androidx.appcompat.widget.AppCompatSpinner; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.NewMainActivity; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.base.util.Utility; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.Account; +import com.adins.mss.dao.GroupTask; +import com.adins.mss.dao.Product; +import com.adins.mss.foundation.db.dataaccess.AccountDataAccess; +import com.adins.mss.foundation.db.dataaccess.ProductDataAccess; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.http.HttpConnectionResult; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.adins.mss.odr.R; +import com.adins.mss.odr.accounts.api.AccountsSearchRequest; +import com.adins.mss.odr.followup.api.GetFollowUpResponse; +import com.google.firebase.analytics.FirebaseAnalytics; + +import java.io.IOException; +import java.text.ParseException; +import java.util.ArrayList; +import java.util.List; + +/** + * Created by olivia.dg on 11/24/2017. + */ + +public class +FragmentFollowUpSearch extends Fragment { + + private AppCompatSpinner spinnerAccount; + private AppCompatSpinner spinnerProduct; + private AppCompatSpinner spinnerStatus; + private Button btnSearch; + private List accountList; + private List productList; + private String[] statusList; + private String tempAccount; + private String tempProduct; + private String tempStatus; + private FirebaseAnalytics screenName; + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + screenName = FirebaseAnalytics.getInstance(getActivity()); + return inflater.inflate(R.layout.new_fragment_account_search, container, false); + } + + @Override + public void onViewCreated(View view, Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + + spinnerAccount = (AppCompatSpinner) view.findViewById(R.id.spinnerAccount); + spinnerProduct = (AppCompatSpinner) view.findViewById(R.id.spinnerProduct); + spinnerStatus = (AppCompatSpinner) view.findViewById(R.id.spinnerStatus); + btnSearch = (Button) view.findViewById(R.id.btnSearch); + + btnSearch.setText(getString(R.string.reqOppor)); + + accountList = new ArrayList<>(); + accountList.clear(); + setAllAccountSpinner(); + List listAcc = AccountDataAccess.getAll(getActivity()); + if (listAcc != null) + accountList.addAll(listAcc); + AccountAdapter accountSpinner = new AccountAdapter(getContext(), R.layout.spinner_style2, accountList); + spinnerAccount.setAdapter(accountSpinner); + + productList = new ArrayList<>(); + productList.clear(); + setAllProductSpinner(); + List listProd = ProductDataAccess.getAll(getContext()); + if (listProd != null) + productList.addAll(listProd); + ProductAdapter productSpinner = new ProductAdapter(getContext(), R.layout.spinner_style2, productList); + spinnerProduct.setAdapter(productSpinner); + + statusList = getActivity().getResources().getStringArray(R.array.dropdownAccountStatus); + StatusAdapter statusSpinner = new StatusAdapter(getContext(), R.layout.spinner_style2, statusList); + spinnerStatus.setAdapter(statusSpinner); + + btnSearch.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + Account account = (Account) spinnerAccount.getSelectedItem(); + Product product = (Product) spinnerProduct.getSelectedItem(); + + tempStatus = spinnerStatus.getSelectedItem().toString(); + if (tempStatus.equalsIgnoreCase(getString(R.string.allStatus))) + tempStatus = ""; + tempAccount = account.getUuid_account(); + tempProduct = product.getUuid_product(); + + try { + if (Tool.isInternetconnected(getActivity())) { + doSearch(tempAccount, tempProduct, tempStatus); + } else { + Toast.makeText(getActivity(), getString(R.string.no_internet_connection), Toast.LENGTH_SHORT).show(); + } + } catch (ParseException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + }); + } + + private void setAllAccountSpinner() { + Account accountDummy = new Account(); + accountDummy.setUuid_account(""); + accountDummy.setAccount_name("All Account"); + + accountList.add(0, accountDummy); + } + + private void setAllProductSpinner() { + Product productDummy = new Product(); + productDummy.setUuid_product(""); + productDummy.setProduct_name("All Product"); + + productList.add(0, productDummy); + } + + @Override + public void onResume() { + super.onResume(); + //Set Firebase screen name + screenName.setCurrentScreen(getActivity(), getString(R.string.screen_name_follow_up), null); + getActivity().findViewById(com.adins.mss.base.R.id.search).setVisibility(View.GONE); + getActivity().findViewById(com.adins.mss.base.R.id.spinner).setVisibility(View.GONE); + getActivity().setTitle(getString(com.adins.mss.base.R.string.title_mn_followup)); + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + Utility.freeMemory(); + } + + private void doSearch(final String account, final String product, final String status) throws ParseException, IOException { + new AsyncTask>() { + final ProgressDialog progress = new ProgressDialog(getActivity()); + String errMessage; + List result = new ArrayList(); + + @Override + protected void onPreExecute() { + super.onPreExecute(); + progress.setMessage(getActivity().getString(R.string.contact_server)); + progress.show(); + } + + @Override + protected List doInBackground(Void... params) { + AccountsSearchRequest request = new AccountsSearchRequest(); + request.setUuid_account(account); + request.setUuid_product(product); + request.setUuid_status(status); + request.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + + String json = GsonHelper.toJson(request); + + String url = GlobalData.getSharedGlobalData().getURL_GET_FOLLOWUP(); + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + HttpCryptedConnection httpConn = new HttpCryptedConnection(getActivity(), encrypt, decrypt); + HttpConnectionResult serverResult = null; + try { + serverResult = httpConn.requestToServer(url, json, Global.DEFAULTCONNECTIONTIMEOUT); + } catch (Exception e) { + e.printStackTrace(); + } + + GetFollowUpResponse response = null; + if (serverResult != null && serverResult.isOK()) { + try { + String responseBody = serverResult.getResult(); + response = GsonHelper.fromJson(responseBody, GetFollowUpResponse.class); + } catch (Exception e) { + if(Global.IS_DEV) { + e.printStackTrace(); + errMessage=e.getMessage(); + } + } + + List groupTaskList = response.getListFollowUp(); + if (groupTaskList != null && groupTaskList.size() != 0) { + result = groupTaskList; + } else { + errMessage = getActivity().getString(R.string.no_data_from_server); + } + } else { + errMessage = getActivity().getString(R.string.server_down); + } + return result; + } + + + @Override + protected void onPostExecute(List result) { + if(getActivity()!=null) { + if (progress != null && progress.isShowing()) { + progress.dismiss(); + } + if (errMessage != null) { + if (errMessage.equals(getActivity().getString(R.string.no_data_from_server))) { + NiftyDialogBuilder builder = NiftyDialogBuilder.getInstance(getActivity()); + builder.withTitle("INFO") + .withMessage(errMessage) + .show(); + } else { + Toast.makeText(getActivity(), errMessage, Toast.LENGTH_SHORT).show(); + } + } else { + Fragment fragment = new FragmentFollowUpResult(getContext(), result); + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(com.adins.mss.base.R.anim.activity_open_translate, com.adins.mss.base.R.anim.activity_close_scale, com.adins.mss.base.R.anim.activity_open_scale, com.adins.mss.base.R.anim.activity_close_translate); + transaction.replace(com.adins.mss.base.R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + } + } + }.execute(); + + } + + public class StatusAdapter extends ArrayAdapter { + private Context context; + private String[] values; + + public StatusAdapter(Context context, int resource, String[] objects) { + super(context, resource, objects); + this.context = context; + this.values = objects; + } + + public int getCount() { + return values.length; + } + + public String getItem(int position) { + return values[position]; + } + + public long getItemId(int position) { + return position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style2, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values[position]); + return label; + } + + @Override + public View getDropDownView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values[position]); + return label; + } + } + + public class AccountAdapter extends ArrayAdapter { + private Context context; + private List values; + + public AccountAdapter(Context context, int resource, List objects) { + super(context, resource, objects); + this.context = context; + this.values = objects; + } + + public int getCount() { + return values.size(); + } + + public Account getItem(int position) { + return values.get(position); + } + + public long getItemId(int position) { + return position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style2, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getAccount_name()); + return label; + } + + @Override + public View getDropDownView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getAccount_name()); + return label; + } + } + + public class ProductAdapter extends ArrayAdapter { + private Context context; + private List values; + + public ProductAdapter(Context context, int resource, List objects) { + super(context, resource, objects); + this.context = context; + this.values = objects; + } + + public int getCount() { + return values.size(); + } + + public Product getItem(int position) { + return values.get(position); + } + + public long getItemId(int position) { + return position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style2, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getProduct_name()); + return label; + } + + @Override + public View getDropDownView(int position, View convertView, ViewGroup parent) { + LayoutInflater inflater = getActivity().getLayoutInflater(); + View view = inflater.inflate(R.layout.spinner_style, parent, false); + TextView label = (TextView) view.findViewById(R.id.text_spin); + label.setText(values.get(position).getProduct_name()); + return label; + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c2650054f83fe1a21c5af6d6c6c8ba428424e6a.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c2650054f83fe1a21c5af6d6c6c8ba428424e6a.svn-base new file mode 100644 index 0000000..8a95649 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c2650054f83fe1a21c5af6d6c6c8ba428424e6a.svn-base @@ -0,0 +1,25 @@ +package com.adins.mss.base.authentication; + +import com.adins.mss.base.BaseCommunicationModel; + + +/** + * JSON Format for authentication + * + * @author glen.iglesias + * @see LoginUserRequest + * @deprecated as of 17 Dec 2014, as BaseCommunicationModel + */ +public class AuthenticationModel extends BaseCommunicationModel { + + protected String password; + protected boolean isFreshInstall; + + // public AuthenticationModel(String userId, String password, boolean useDefault, Object additionalData, boolean freshInstall){ + public AuthenticationModel(String userId, String password, boolean useDefault, boolean freshInstall) { + super(useDefault); + this.userId = userId; + this.password = password; + this.isFreshInstall = freshInstall; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c514024c773774ff6acc6723128060fe2cc3ec9.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c514024c773774ff6acc6723128060fe2cc3ec9.svn-base new file mode 100644 index 0000000..a69dc25 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c514024c773774ff6acc6723128060fe2cc3ec9.svn-base @@ -0,0 +1,32 @@ + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c6308fc5b22ee322d90409b3f8cf0764ba794f8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c6308fc5b22ee322d90409b3f8cf0764ba794f8.svn-base new file mode 100644 index 0000000..5cff227 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c6308fc5b22ee322d90409b3f8cf0764ba794f8.svn-base @@ -0,0 +1,135 @@ +package com.services; + +import android.content.Context; +import android.os.AsyncTask; +import android.util.Log; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.base.util.Utility; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.User; +import com.adins.mss.foundation.db.dataaccess.UserDataAccess; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.http.HttpConnectionResult; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.google.firebase.iid.FirebaseInstanceId; +import com.google.firebase.iid.FirebaseInstanceIdService; +import com.google.firebase.perf.FirebasePerformance; +import com.google.firebase.perf.metrics.HttpMetric; +import com.services.models.JsonResponseTokenId; +import com.services.models.JsonSendTokenId; + +/** + * Created by Farizko on 15-Mar-17. + */ + +public class RefreshToken extends FirebaseInstanceIdService { + Context context; + + public RefreshToken() { + } + + public RefreshToken(Context context) { + this.context = context; + } + + @Override + public void onTokenRefresh() { + super.onTokenRefresh(); + String token = FirebaseInstanceId.getInstance().getToken(); + Log.d("Firebase", " masuk onToken "); + + if (null != token) { + Global.Token = token; + registerToken(token); + } + } + + private void registerToken(final String token) { + if (null != token && !"".equalsIgnoreCase(token)) { + new AsyncTask() { + @Override + protected String doInBackground(Void... params) { + String result = null; + try { + Thread.sleep(5000); + } catch (Exception e) { + FireCrash.log(e); + } + User user = GlobalData.getSharedGlobalData().getUser(); + if (null != user && null != user.getToken_id_fcm() && user.getToken_id_fcm().equalsIgnoreCase(token)) { + return "selesai"; + } + if (null != user && (null == user.getToken_id_fcm() || !user.getToken_id_fcm().equalsIgnoreCase(token))) { + if (null == context){ + context = getBaseContext(); + } + if (Tool.isInternetconnected(context)) { + JsonSendTokenId task = new JsonSendTokenId(); + task.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + task.addImeiAndroidIdToUnstructured(); + task.setToken_id(token); + task.setUuid_user(GlobalData.getSharedGlobalData().getUser().getUuid_user()); + String json = GsonHelper.toJson(task); + String url = GlobalData.getSharedGlobalData().getURL_UPDATE_FCM(); + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + HttpCryptedConnection httpConn = new HttpCryptedConnection(context, encrypt, decrypt); + HttpConnectionResult serverResult = null; + + //Firebase Performance Trace HTTP Request + HttpMetric networkMetric = + FirebasePerformance.getInstance().newHttpMetric(url, FirebasePerformance.HttpMethod.POST); + Utility.metricStart(networkMetric, json); + + try { + serverResult = httpConn.requestToServer(url, json, Global.DEFAULTCONNECTIONTIMEOUT); + Utility.metricStop(networkMetric, serverResult); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + + + if (null != serverResult && serverResult.isOK()){ + result = serverResult.getResult(); + } + } + } + return result; + } + + @Override + protected void onPostExecute(final String message) { + if (null != message) { + if ("selesai".equalsIgnoreCase(message)) { + } else { + try { + JsonResponseTokenId responseTokenId = GsonHelper.fromJson(message, JsonResponseTokenId.class); + if (responseTokenId.getStatus().getCode() == 0){ + if (!"".equalsIgnoreCase(responseTokenId.getToken_id())) { + User user = GlobalData.getSharedGlobalData().getUser(); + user.setToken_id_fcm(token); + GlobalData.getSharedGlobalData().setUser(user); + UserDataAccess.update(context, user); + } + } + } catch (Exception e) { + FireCrash.log(e); + } + } + } else { + try { + registerToken(token); + } catch (Exception e) { + FireCrash.log(e); + } + } + } + }.execute(); + } + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c98b001806314acdb38a2f7f3cfc7f5c7d9cc7d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c98b001806314acdb38a2f7f3cfc7f5c7d9cc7d.svn-base new file mode 100644 index 0000000..f1c9fb5 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0c98b001806314acdb38a2f7f3cfc7f5c7d9cc7d.svn-base @@ -0,0 +1,44 @@ +package com.adins.mss.base.avatar; + +import com.google.gson.annotations.SerializedName; + +/** + * Created by intishar.fa on 02/10/2018. + */ + +public class AvatarUploadResponseJson { + @SerializedName("status") + private UploadAvatarStatus status; + @SerializedName("result") + private String result; + + public UploadAvatarStatus getStatus() { + return status; + } + + public void setStatus(UploadAvatarStatus status) { + this.status = status; + } + + public String getResult() { + return result; + } + + public void setResult(String result) { + this.result = result; + } + +} + +class UploadAvatarStatus{ + @SerializedName("code") + protected int code; + + public int getCode() { + return code; + } + + public void setCode(int code) { + this.code = code; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0ca558028d14cb915515a28ef59f1bb099fd5d32.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0ca558028d14cb915515a28ef59f1bb099fd5d32.svn-base new file mode 100644 index 0000000..068884d --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0ca558028d14cb915515a28ef59f1bb099fd5d32.svn-base @@ -0,0 +1,153 @@ +package zj.com.command.sdk; + +public class Command { + + public static final byte PIECE = (byte) 0xFF; + public static final byte NUL = (byte) 0x00; + private static final byte ESC = 0x1B; + private static final byte FS = 0x1C; + private static final byte GS = 0x1D; + private static final byte US = 0x1F; + private static final byte DLE = 0x10; + private static final byte DC4 = 0x14; + private static final byte DC1 = 0x11; + private static final byte SP = 0x20; + private static final byte NL = 0x0A; + private static final byte FF = 0x0C; + //打�?�机�?始化 + public static byte[] ESC_Init = new byte[]{ESC, '@'}; + + /** + * 打�?�命令 + */ + //打�?�并�?�行 + public static byte[] LF = new byte[]{NL}; + + //打�?�并走纸 + public static byte[] ESC_J = new byte[]{ESC, 'J', 0x00}; + public static byte[] ESC_d = new byte[]{ESC, 'd', 0x00}; + + //打�?�自检页 + public static byte[] US_vt_eot = new byte[]{US, DC1, 0x04}; + + //蜂鸣指令 + public static byte[] ESC_B_m_n = new byte[]{ESC, 'B', 0x00, 0x00}; + + //切刀指令 + public static byte[] GS_V_n = new byte[]{GS, 'V', 0x00}; + public static byte[] GS_V_m_n = new byte[]{GS, 'V', 'B', 0x00}; + public static byte[] GS_i = new byte[]{ESC, 'i'}; + public static byte[] GS_m = new byte[]{ESC, 'm'}; + + /** + * 字符设置命令 + */ + //设置字符�?�间�? + public static byte[] ESC_SP = new byte[]{ESC, SP, 0x00}; + + //设置字符打�?�字体格�? + public static byte[] ESC_ExclamationMark = new byte[]{ESC, '!', 0x00}; + + //设置字体�?高�?宽 + public static byte[] GS_ExclamationMark = new byte[]{GS, '!', 0x00}; + + //设置�??显打�?� + public static byte[] GS_B = new byte[]{GS, 'B', 0x00}; + + //�?�消/选择90度旋转打�?� + public static byte[] ESC_V = new byte[]{ESC, 'V', 0x00}; + + //选择字体字型(主�?是ASCII�?) + public static byte[] ESC_M = new byte[]{ESC, 'M', 0x00}; + + //选择/�?�消加粗指令 + public static byte[] ESC_G = new byte[]{ESC, 'G', 0x00}; + public static byte[] ESC_E = new byte[]{ESC, 'E', 0x00}; + + //选择/�?�消倒置打�?�模�? + public static byte[] ESC_LeftBrace = new byte[]{ESC, '{', 0x00}; + + //设置下划线点高度(字符) + public static byte[] ESC_Minus = new byte[]{ESC, 45, 0x00}; + + //字符模�? + public static byte[] FS_dot = new byte[]{FS, 46}; + + //汉字模�? + public static byte[] FS_and = new byte[]{FS, '&'}; + + //设置汉字打�?�模�? + public static byte[] FS_ExclamationMark = new byte[]{FS, '!', 0x00}; + + //设置下划线点高度(汉字) + public static byte[] FS_Minus = new byte[]{FS, 45, 0x00}; + + //设置汉字左�?�间�? + public static byte[] FS_S = new byte[]{FS, 'S', 0x00, 0x00}; + + //选择字符代�?页 + public static byte[] ESC_t = new byte[]{ESC, 't', 0x00}; + + /** + * 格�?设置指令 + */ + //设置默认行间�? + public static byte[] ESC_Two = new byte[]{ESC, 50}; + + //设置行间�? + public static byte[] ESC_Three = new byte[]{ESC, 51, 0x00}; + + //设置对�?模�? + public static byte[] ESC_Align = new byte[]{ESC, 'a', 0x00}; + + //设置左边�? + public static byte[] GS_LeftSp = new byte[]{GS, 'L', 0x00, 0x00}; + + //设置�?对打�?��?置 + //将当�?�?置设置到�?离行首（nL + nH x 256）处。 + //如果设置�?置在指定打�?�区域外，该命令被忽略 + public static byte[] ESC_Relative = new byte[]{ESC, '$', 0x00, 0x00}; + + //设置相对打�?��?置 + public static byte[] ESC_Absolute = new byte[]{ESC, 92, 0x00, 0x00}; + + //设置打�?�区域宽度 + public static byte[] GS_W = new byte[]{GS, 'W', 0x00, 0x00}; + + /** + * 状�?指令 + */ + //实时状�?传�?指令 + public static byte[] DLE_eot = new byte[]{DLE, 0x04, 0x00}; + + //实时弹钱箱指令 + public static byte[] DLE_DC4 = new byte[]{DLE, DC4, 0x00, 0x00, 0x00}; + + //标准弹钱箱指令 + public static byte[] ESC_p = new byte[]{ESC, 'F', 0x00, 0x00, 0x00}; + + /** + * �?��?设置指令 + */ + //选择HRI打�?�方�? + public static byte[] GS_H = new byte[]{GS, 'H', 0x00}; + + //设置�?��?高度 + public static byte[] GS_h = new byte[]{GS, 'h', (byte) 0xa2}; + + //设置�?��?宽度 + public static byte[] GS_w = new byte[]{GS, 'w', 0x00}; + + //设置HRI字符字体字型 + public static byte[] GS_f = new byte[]{GS, 'f', 0x00}; + + //�?��?左�??移指令 + public static byte[] GS_x = new byte[]{GS, 'x', 0x00}; + + //打�?��?��?指令 + public static byte[] GS_k = new byte[]{GS, 'k', 'A', FF}; + + //二维�?相关指令 + public static byte[] GS_k_m_v_r_nL_nH = new byte[]{ESC, 'Z', 0x03, 0x03, 0x08, 0x00, 0x00}; + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0cbf68cf9c62362a8cc84f0764abc6302629ef94.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0cbf68cf9c62362a8cc84f0764abc6302629ef94.svn-base new file mode 100644 index 0000000..8c371ec --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0c/0cbf68cf9c62362a8cc84f0764abc6302629ef94.svn-base @@ -0,0 +1,138 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d0d996b79260dc6cd49b1f6f418ef071660dcc3.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d0d996b79260dc6cd49b1f6f418ef071660dcc3.svn-base new file mode 100644 index 0000000..012eef7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d0d996b79260dc6cd49b1f6f418ef071660dcc3.svn-base @@ -0,0 +1,57 @@ +package com.adins.mss.svy.reassignment; + +import com.adins.mss.foundation.http.KeyValue; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +public class JsonResponseServer extends MssResponseType{ + @SerializedName("listResponseServer") + List listResponseServer; + + public List getListResponseServer() { + return listResponseServer; + } + public void setListResponseServer(List listResponseServer) { + this.listResponseServer = listResponseServer; + } + + + + public class ResponseServer extends KeyValue { + @SerializedName("flag") + String flag; + @SerializedName("subListResponseServer") + List subListResponseServer; + @SerializedName("formName") + String formName; + + public ResponseServer(String key, String value) { + super(key, value); + } + public String getFormName() { + return this.formName; + } + + public void setFormName(String value) { + this.formName = value; + } + + public String getFlag() { + return flag; + } + + public void setFlag(String flag) { + this.flag = flag; + } + + public List getSubListResponseServer() { + return subListResponseServer; + } + + public void setSubListResponseServer(List subListResponseServer) { + this.subListResponseServer = subListResponseServer; + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d34cc3807d119dc671bfc03a467d1552522cb5c.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d34cc3807d119dc671bfc03a467d1552522cb5c.svn-base new file mode 100644 index 0000000..a1ea22d --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d34cc3807d119dc671bfc03a467d1552522cb5c.svn-base @@ -0,0 +1,71 @@ +package com.adins.mss.foundation.db.dataaccess; + +import android.content.Context; + +import com.adins.mss.dao.DaoSession; +import com.adins.mss.dao.LogoPrint; +import com.adins.mss.dao.LogoPrintDao; +import com.adins.mss.foundation.db.DaoOpenHelper; + +import java.util.List; + +import de.greenrobot.dao.query.QueryBuilder; + +public class LogoPrintDataAccess { + + protected static DaoSession getDaoSession(Context context) { + return DaoOpenHelper.getDaoSession(context); + } + + protected static LogoPrintDao getLogoPrintDao(Context context) { + return getDaoSession(context).getLogoPrintDao(); + } + + public static void add(Context context, LogoPrint logoPrint) { + getLogoPrintDao(context).insert(logoPrint); + getDaoSession(context).clear(); + } + + public static void add(Context context, List logoPrintList) { + getLogoPrintDao(context).insertInTx(logoPrintList); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, LogoPrint logoPrint) { + getLogoPrintDao(context).insertOrReplaceInTx(logoPrint); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, List logoPrintList) { + getLogoPrintDao(context).insertOrReplaceInTx(logoPrintList); + getDaoSession(context).clear(); + } + + public static void clean(Context context) { + getLogoPrintDao(context).deleteAll(); + } + + public static void delete(Context context, LogoPrint logoPrint) { + getLogoPrintDao(context).delete(logoPrint); + getDaoSession(context).clear(); + } + + public static void update(Context context, LogoPrint logoPrint) { + getLogoPrintDao(context).update(logoPrint); + } + + public static LogoPrint getOne(Context context, String tenant) { + QueryBuilder qb = getLogoPrintDao(context).queryBuilder(); + qb.where(LogoPrintDao.Properties.Tenant.eq(tenant)); + qb.build().forCurrentThread(); + if (qb.list().size() == 0) + return null; + return qb.list().get(0); + } + + public static List getAll(Context context) { + QueryBuilder qb = getLogoPrintDao(context).queryBuilder(); + qb.build(); + return qb.list(); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d381d444d398c53f1cd3b8d0ada7ad3d129fcf4.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d381d444d398c53f1cd3b8d0ada7ad3d129fcf4.svn-base new file mode 100644 index 0000000..83305cc --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d381d444d398c53f1cd3b8d0ada7ad3d129fcf4.svn-base @@ -0,0 +1,74 @@ +/* + * Class copied from the Android Developers Blog: + * http://android-developers.blogspot.com/2011/03/identifying-app-installations.html + */ +package org.acra.util; + +import android.content.Context; + +import org.acra.ACRA; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.util.UUID; + +import static org.acra.ACRA.LOG_TAG; + +/** + *

+ * Creates a file storing a UUID on the first application start. This UUID can then be used as a identifier of this + * specific application installation. + *

+ *

+ *

+ * This was taken from the + * android developers blog. + *

+ */ +public class Installation { + + private static final String INSTALLATION = "ACRA-INSTALLATION"; + private static String sID; + + public synchronized static String id(Context context) { + if (sID == null) { + final File installation = new File(context.getFilesDir(), INSTALLATION); + try { + if (!installation.exists()) { + writeInstallationFile(installation); + } + sID = readInstallationFile(installation); + } catch (IOException e) { + ACRA.log.w(LOG_TAG, "Couldn't retrieve InstallationId for " + context.getPackageName(), e); + return "Couldn't retrieve InstallationId"; + } catch (RuntimeException e) { + ACRA.log.w(LOG_TAG, "Couldn't retrieve InstallationId for " + context.getPackageName(), e); + return "Couldn't retrieve InstallationId"; + } + } + return sID; + } + + private static String readInstallationFile(File installation) throws IOException { + final RandomAccessFile f = new RandomAccessFile(installation, "r"); + final byte[] bytes = new byte[(int) f.length()]; + try { + f.readFully(bytes); + } finally { + f.close(); + } + return new String(bytes); + } + + private static void writeInstallationFile(File installation) throws IOException { + final FileOutputStream out = new FileOutputStream(installation); + try { + final String id = UUID.randomUUID().toString(); + out.write(id.getBytes()); + } finally { + out.close(); + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d562e5fcb24f514683637fcf91404e00d893cfa.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d562e5fcb24f514683637fcf91404e00d893cfa.svn-base new file mode 100644 index 0000000..f8ef277 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d562e5fcb24f514683637fcf91404e00d893cfa.svn-base @@ -0,0 +1,413 @@ +package com.adins.mss.base.dynamicform.form.questions; + +import android.content.res.ColorStateList; +import android.graphics.Color; +import androidx.fragment.app.FragmentActivity; +import androidx.recyclerview.widget.RecyclerView; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.animation.AlphaAnimation; +import android.view.animation.Animation; +import android.view.animation.ScaleAnimation; + +import com.adins.mss.base.R; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.dynamicform.form.ScrollingLinearLayoutManager; +import com.adins.mss.base.dynamicform.form.questions.viewholder.ButtonTextUrlViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.DateTimeQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.DigitalReceiptQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.DrawingQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.DropdownQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.ExpandableRecyclerView; +import com.adins.mss.base.dynamicform.form.questions.viewholder.ImageQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.LocationQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.LookupDukcapilQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.LookupQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.LuOnlineQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.MultipleQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.QuestionGroupViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.RadioQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.TextOnlineViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.TextQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.TextWithSuggestionQuestionViewHolder; +import com.adins.mss.base.dynamicform.form.questions.viewholder.ValidationQuestionViewHolder; +import com.adins.mss.base.dynamictheme.DynamicTheme; +import com.adins.mss.base.dynamictheme.ThemeLoader; +import com.adins.mss.base.dynamictheme.ThemeUtility; +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.questiongenerator.QuestionBean; + +import java.util.LinkedHashMap; +import java.util.List; + +/** + * Created by gigin.ginanjar on 03/09/2016. + */ +public class QuestionViewAdapter extends ExpandableRecyclerView.Adapter implements ThemeLoader.ColorSetLoaderCallback { + private static final int FADE_DURATION = 750; // in milliseconds + private final LinkedHashMap> mValues; + private final List mGroups; + private final FragmentActivity mActivity; + private final int VIEW_TYPE_LOADING = 999; + public ScrollingLinearLayoutManager linearLayoutManager; + public ExpandableRecyclerView mRecyclerView; + private OnQuestionClickListener mListener; + private int lastPosition = -1; + + //Edittext colorstatelist object + public static ColorStateList etBorderColorStateList; + + public QuestionViewAdapter(FragmentActivity activity, ExpandableRecyclerView recyclerView, List groups, LinkedHashMap> items, OnQuestionClickListener listener) { + mActivity = activity; + mValues = items; + mListener = listener; + mGroups = groups; + mRecyclerView = recyclerView; + loadSavedTheme(); + } + + private void loadSavedTheme(){ + ThemeLoader themeLoader = new ThemeLoader(mActivity); + themeLoader.loadSavedColorSet(this); + } + + public static boolean IsTextQuestion(String answerType) { + return answerType.equals(Global.AT_TEXT) || + answerType.equals(Global.AT_TEXT_MULTILINE) || + answerType.equals(Global.AT_CURRENCY) || + answerType.equals(Global.AT_NUMERIC) || + answerType.equals(Global.AT_DECIMAL) || + answerType.equals(Global.AT_PDF); + } + + public static boolean IsDropdownQuestion(String answerType) { + return answerType.equals(Global.AT_DROPDOWN) || + answerType.equals(Global.AT_DROPDOWN_W_DESCRIPTION); + } + + public static boolean IsMultipleQuestion(String answerType) { + return answerType.equals(Global.AT_MULTIPLE) || + answerType.equals(Global.AT_MULTIPLE_ONE_DESCRIPTION) || + answerType.equals(Global.AT_MULTIPLE_W_DESCRIPTION); + } + + public static boolean IsRadioQuestion(String answerType) { + return answerType.equals(Global.AT_RADIO) || + answerType.equals(Global.AT_RADIO_W_DESCRIPTION); + } + + public static boolean IsImageQuestion(String answerType) { + return answerType.equals(Global.AT_IMAGE) || + answerType.equals(Global.AT_IMAGE_W_GPS_ONLY) || + answerType.equals(Global.AT_IMAGE_W_LOCATION) || + answerType.equals(Global.AT_ID_CARD_PHOTO); + } + + public static boolean IsLookupQuestion(String answerType) { + return answerType.equals(Global.AT_LOV) || + answerType.equals(Global.AT_LOV_W_FILTER) || + answerType.equals(Global.AT_LOOKUP) || + answerType.equals(Global.AT_LOOKUP_DUKCAPIL); + } + + public static boolean IsTextQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_TEXT) || + answerType == Integer.valueOf(Global.AT_TEXT_MULTILINE) || + answerType == Integer.valueOf(Global.AT_CURRENCY) || + answerType == Integer.valueOf(Global.AT_NUMERIC) || + answerType == Integer.valueOf(Global.AT_DECIMAL) || + answerType == Integer.valueOf(Global.AT_PDF); + } + + public static boolean IsDropdownQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_DROPDOWN) || + answerType == Integer.valueOf(Global.AT_DROPDOWN_W_DESCRIPTION); + } + + public static boolean IsMultipleQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_MULTIPLE) || + answerType == Integer.valueOf(Global.AT_MULTIPLE_ONE_DESCRIPTION) || + answerType == Integer.valueOf(Global.AT_MULTIPLE_W_DESCRIPTION); + } + + public static boolean IsRadioQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_RADIO) || + answerType == Integer.valueOf(Global.AT_RADIO_W_DESCRIPTION); + } + + public static boolean IsImageQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_IMAGE) || + answerType == Integer.valueOf(Global.AT_IMAGE_W_GPS_ONLY) || + answerType == Integer.valueOf(Global.AT_IMAGE_W_LOCATION) || + answerType == Integer.valueOf(Global.AT_ID_CARD_PHOTO); + } + + public static boolean IsDateTimeQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_DATE) || + answerType == Integer.valueOf(Global.AT_DATE_TIME) || + answerType == Integer.valueOf(Global.AT_TIME); + } + + public static boolean IsLocationQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_LOCATION); + } + + public static boolean IsDrawingQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_DRAWING); + } + + public static boolean IsTextWithSuggestionQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_TEXT_WITH_SUGGESTION); + } + + public static boolean IsLookupQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_LOV) || + answerType == Integer.valueOf(Global.AT_LOV_W_FILTER) || + answerType == Integer.valueOf(Global.AT_LOOKUP) || + answerType == Integer.valueOf(Global.AT_LOOKUP_DUKCAPIL); + } + + @Override + public int getGroupItemCount() { + return mGroups.size() - 1; + } + + @Override + public int getChildItemCount(int group) { + return mValues.get(mGroups.get(group)).size(); + } + + @Override + public String getGroupItem(int position) { + return mGroups.get(position); + } + + @Override + public QuestionBean getChildItem(int group, int position) { + return mValues.get(getGroupItem(group)).get(position); + } + + @Override + protected QuestionGroupViewHolder onCreateGroupViewHolder(ViewGroup parent) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_group_layout, parent, false); + return new QuestionGroupViewHolder(view); + } + + @Override + public void onBindGroupViewHolder(QuestionGroupViewHolder holder, int group) { + super.onBindGroupViewHolder(holder, group); + String qGroup = ""; + try { + qGroup = getGroupItem(group); + } catch (Exception e) { + FireCrash.log(e); + } + + holder.bind(qGroup); + setFadeAnimation2(holder.itemView); + } + + @Override + protected RecyclerView.ViewHolder onCreateChildViewHolder(ViewGroup parent, int viewType) { + if (IsTextQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_text_layout, parent, false); + return new TextQuestionViewHolder(mActivity, view, mRecyclerView); + } else if (IsDropdownQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_dropdown_layout, parent, false); + return new DropdownQuestionViewHolder(view, mActivity); + } else if (IsMultipleQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_multiple_layout, parent, false); + return new MultipleQuestionViewHolder(view, mActivity); + } else if (IsImageQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_image_layout, parent, false); + return new ImageQuestionViewHolder(view, mActivity, mListener); + } else if (IsRadioQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_radio_layout, parent, false); + return new RadioQuestionViewHolder(view, mActivity); + } else if (IsLocationQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_location_layout, parent, false); + return new LocationQuestionViewHolder(view, mActivity, mListener); + } else if (IsDrawingQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_drawing_layout, parent, false); + return new DrawingQuestionViewHolder(view, mActivity, mListener); + } else if (IsDateTimeQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_datetime_layout, parent, false); + return new DateTimeQuestionViewHolder(mActivity, view); + } else if (IsTextWithSuggestionQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_textwithsuggestion_layout, parent, false); + return new TextWithSuggestionQuestionViewHolder(view, mActivity); + } else if (IsLookupQuestion(viewType)) { + if(viewType == Integer.valueOf(Global.AT_LOOKUP_DUKCAPIL)){ + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_lookup_dukcapil_layout, parent, false); + return new LookupDukcapilQuestionViewHolder(view, mActivity, mListener); + } else{ + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.new_question_lookup_layout, parent, false); + return new LookupQuestionViewHolder(view, mActivity, mListener); + } + } else if (IsValidationQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_validation_layout, parent, false); + return new ValidationQuestionViewHolder(view, mActivity); + } else if (IsRvMobileQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_digitalreceipt_layout, parent, false); + return new DigitalReceiptQuestionViewHolder(view, mActivity); + } else if (isTextOnlineQuestion(viewType)){ + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_text_online_layout, parent, false); + return new TextOnlineViewHolder(view, mActivity); + } else if (IsLuOnlineQuestion(viewType)) { + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_lu_online_layout, parent, false); + return new LuOnlineQuestionViewHolder(view, mActivity); + } + else if(IsButtonViewUrlQuestion(viewType)){ + View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.question_button_text_url_layout, parent, false); + return new ButtonTextUrlViewHolder(view, mActivity); + } + + return null; + } + + @Override + public int getChildItemViewType(int group, int position) { + int viewType = Integer.valueOf(getChildItem(group, position).getAnswer_type()); + return getChildItem(group, position) == null ? VIEW_TYPE_LOADING : viewType; + } + + @Override + public void onBindChildViewHolder(RecyclerView.ViewHolder mHolder, int group, int position) { + super.onBindChildViewHolder(mHolder, group, position); + if (mHolder instanceof TextQuestionViewHolder) { + final TextQuestionViewHolder holder = (TextQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position),position + 1); + } else if (mHolder instanceof DropdownQuestionViewHolder) { + final DropdownQuestionViewHolder holder = (DropdownQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof RadioQuestionViewHolder) { + final RadioQuestionViewHolder holder = (RadioQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof MultipleQuestionViewHolder) { + final MultipleQuestionViewHolder holder = (MultipleQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof LocationQuestionViewHolder) { + final LocationQuestionViewHolder holder = (LocationQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), group, position + 1); + } else if (mHolder instanceof ImageQuestionViewHolder) { + final ImageQuestionViewHolder holder = (ImageQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), group, position + 1); + } else if (mHolder instanceof DrawingQuestionViewHolder) { + final DrawingQuestionViewHolder holder = (DrawingQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), group, position + 1); + } else if (mHolder instanceof TextWithSuggestionQuestionViewHolder) { + final TextWithSuggestionQuestionViewHolder holder = (TextWithSuggestionQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof DateTimeQuestionViewHolder) { + final DateTimeQuestionViewHolder holder = (DateTimeQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof LookupQuestionViewHolder) { + final LookupQuestionViewHolder holder = (LookupQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), group, position + 1); + }else if (mHolder instanceof LookupDukcapilQuestionViewHolder) { + final LookupDukcapilQuestionViewHolder holder = (LookupDukcapilQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), group, position + 1); + } else if (mHolder instanceof ValidationQuestionViewHolder) { + final ValidationQuestionViewHolder holder = (ValidationQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if(mHolder instanceof DigitalReceiptQuestionViewHolder) { + final DigitalReceiptQuestionViewHolder holder = (DigitalReceiptQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof TextOnlineViewHolder) { + final TextOnlineViewHolder holder = (TextOnlineViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } else if (mHolder instanceof LuOnlineQuestionViewHolder) { + final LuOnlineQuestionViewHolder holder = (LuOnlineQuestionViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } + else if(mHolder instanceof ButtonTextUrlViewHolder) { + final ButtonTextUrlViewHolder holder = (ButtonTextUrlViewHolder) mHolder; + holder.bind(getChildItem(group, position), position + 1); + } + setFadeAnimation(mHolder.itemView, position); + } + + @Override + public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) { + super.onViewDetachedFromWindow(holder); + holder.itemView.clearAnimation(); + } + + private void setFadeAnimation(View view, int position) { + if (position > lastPosition) { + lastPosition = position; + AlphaAnimation anim = new AlphaAnimation(0.0f, 1.0f); + anim.setDuration(FADE_DURATION); + view.startAnimation(anim); + } else if (lastPosition > getItemCount() - 1) { + lastPosition = getItemCount() - 1; + } else { +// setScaleAnimation(view); + setFadeAnimation2(view); + } + } + + private void setFadeAnimation2(View view) { + AlphaAnimation anim = new AlphaAnimation(0.0f, 1.0f); + anim.setDuration(FADE_DURATION / 2); + view.startAnimation(anim); + } + + private void setScaleAnimation(View view) { + ScaleAnimation anim = new ScaleAnimation(0.0f, 1.0f, 0.0f, 1.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f); + anim.setDuration(150); + view.startAnimation(anim); + } + + private void createEditTextBorderColorStateList(DynamicTheme dynamicTheme){ + if(dynamicTheme == null){ + return; + } + int etBorderFocusedColor = Color.parseColor(ThemeUtility.getColorItemValue(dynamicTheme,"et_border_focused")); + int etBorderDisabledColor = Color.parseColor(ThemeUtility.getColorItemValue(dynamicTheme,"et_border_disabled")); + int etBorderNormalColor = Color.parseColor(ThemeUtility.getColorItemValue(dynamicTheme,"et_border_normal")); + int[][] states = new int[][] { + new int[] { android.R.attr.state_focused}, // focused + new int[] {-android.R.attr.state_enabled}, //disabled + new int[] {} // normal + }; + + int[] etbordercolorlist = new int[]{ + etBorderFocusedColor,etBorderDisabledColor,etBorderNormalColor + }; + etBorderColorStateList = new ColorStateList(states,etbordercolorlist); + } + + @Override + public void onHasLoaded(DynamicTheme dynamicTheme) { + if(dynamicTheme != null && dynamicTheme.getThemeItemList().size() > 0){ + createEditTextBorderColorStateList(dynamicTheme); + } + } + + @Override + public void onHasLoaded(DynamicTheme dynamicTheme, boolean needUpdate) { + + } + + public static boolean IsValidationQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_VALIDATION); + } + + public static boolean IsRvMobileQuestion(int answerType) { + return answerType == Integer.valueOf(Global.AT_RV_MOBILE); + } + + public static boolean isTextOnlineQuestion(int answerType){ + return answerType == Integer.valueOf(Global.AT_TEXT_ONLINE); + } + + public static boolean IsButtonViewUrlQuestion(int answerType){ + return answerType == Integer.valueOf(Global.AT_BUTTON_VIEW_URL); + } + + public static boolean IsLuOnlineQuestion(int answerTYpe) { + return answerTYpe == Integer.valueOf(Global.AT_LOOKUP_ONLINE); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d5867b2fa52dd4d99cfba885616bec22ada8c60.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d5867b2fa52dd4d99cfba885616bec22ada8c60.svn-base new file mode 100644 index 0000000..976aa3e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d5867b2fa52dd4d99cfba885616bec22ada8c60.svn-base @@ -0,0 +1,205 @@ +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in C:\Users\gigin.ginanjar\AppData\Local\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 *; +#} + + +-optimizationpasses 5 + +#When not preverifing in a case-insensitive filing system, such as Windows. Because this tool unpacks your processed jars, you should then use: +-dontusemixedcaseclassnames + +#Specifies not to ignore non-public library classes. As of version 4.5, this is the default setting +-dontskipnonpubliclibraryclasses + +#Preverification is irrelevant for the dex compiler and the Dalvik VM, so we can switch it off with the -dontpreverify option. +-dontpreverify + +#Specifies to write out some more information during processing. If the program terminates with an exception, this option will print out the entire stack trace, instead of just the exception message. +-verbose + +#The -optimizations option disables some arithmetic simplifications that Dalvik 1.0 and 1.5 can't handle. Note that the Dalvik VM also can't handle aggressive overloading (of static fields). +#To understand or change this check http://proguard.sourceforge.net/index.html#/manual/optimizations.html +-optimizations !code/simplification/arithmetic,!field/*,!class/merging/* + +#To repackage classes on a single package +-repackageclasses '' + +#Uncomment if using annotations to keep them. +-keepattributes *Annotation*, Override +-keepattributes Signature +-keepattributes EnclosingMethod +-keepattributes InnerClasses + +-dontwarn javax.script.** +-dontwarn org.apache.commons.logging.** +-dontwarn java.beans.** +-dontwarn okio.** +-dontwarn com.androidquery.auth.TwitterHandle +-dontwarn org.bouncycastle.** + +-keep class javax.** {*;} +-keep class org.apache.commons.logging.** {*;} +-keep class java.beans.** {*;} +-keep class org.apache.commons.jexl2.** {*;} +-keep class org.bouncycastle.** {*;} +-keep class okio.** {*;} +-keep class oauth.signpost.** {*;} +-keep class org.apache.log4j.Logger {*;} +-keep class java.nio.** {*;} +-keep class junit..** {*;} +-keep class oauth.signpost.commonshttp.** {*;} +-keep class net.sqlcipher.** { + *; +} + +#Keep classes that are referenced on the AndroidManifest +#-keep public class * extends androidx.fragment.app.Fragment +-keep public class * extends androidx.appcompat.app.AppCompatActivity +-keep public class * extends com.adins.mss.base.MssFragmentActivity +-keep public class * extends androidx.fragment.app.Fragment +-keep public class * extends androidx.fragment.app.FragmentActivity +-keep public class * extends android.app.Activity +-keep public class * extends android.app.Application +-keep public class * extends android.app.Service +-keep public class * extends android.content.BroadcastReceiver +-keep public class * extends android.content.ContentProvider +-keep public class * extends com.adins.mss.foundation.http.MssRequestType +-keep public class * extends com.adins.mss.foundation.http.MssResponseType +-keep public class com.android.vending.licensing.ILicensingService +-keep class com.adins.**.*Request +-keep class com.adins.**.*Response +-keep class android.** { *; } +-keep class com.google.** { *; } +#To remove debug logs: +-assumenosideeffects class android.util.Log { + public static *** d(...); + public static *** v(...); + public static *** e(...); + public static *** i(...); +} + +#To avoid changing names of methods invoked on layout's onClick. +# Uncomment and add specific method names if using onClick on layouts +-keepclassmembers class * { + public void onClickButton(android.view.View); +} + +#Maintain java native methods +-keepclasseswithmembernames class * { + native ; +} + +#To maintain custom components names that are used on layouts XML. +#Uncomment if having any problem with the approach below +#-keep public class custom.components.package.and.name.** + +#To maintain custom components names that are used on layouts XML: +-keep public class * extends android.view.View { + public (android.content.Context); + public (android.content.Context, android.util.AttributeSet); + public (android.content.Context, android.util.AttributeSet, int); + public void set*(...); +} + +-keepclasseswithmembers class * { + public (android.content.Context, android.util.AttributeSet); +} + +-keepclasseswithmembers class * { + public (android.content.Context, android.util.AttributeSet, int); +} + +#Maintain enums +-keepclassmembers enum * { + public static **[] values(); + public static ** valueOf(java.lang.String); +} + +#To keep parcelable classes (to serialize - deserialize objects to sent through Intents) +-keep class * implements android.os.Parcelable { + public static final android.os.Parcelable$Creator *; +} + +#Keep the R +-keepclassmembers class **.R$* { + public static ; +} + +#Keep Interface +-keep interface * {*;} +-keep class sun.misc.Unsafe { *; } + +###### ADDITIONAL OPTIONS NOT USED NORMALLY + +#To keep callback calls. Uncomment if using any +#http://proguard.sourceforge.net/index.html#/manual/examples.html#callback +#-keep class mypackage.MyCallbackClass { +# void myCallbackMethod(java.lang.String); +#} + +#Uncomment if using Serializable +-keepclassmembers class * implements java.io.Serializable { + private static final java.io.ObjectStreamField[] serialPersistentFields; + private void writeObject(java.io.ObjectOutputStream); + private void readObject(java.io.ObjectInputStream); + java.lang.Object writeReplace(); + java.lang.Object readResolve(); +} + +-keep class * implements java.io.Serializable { + public protected ; +} + +#Keep fields for Gson transactions +-keep public class * extends com.adins.mss.foundation.http.MssRequestType{ + ; + } +-keep public class * extends com.adins.mss.foundation.http.MssResponseType{ + ; +} +-keep public class * extends com.adins.mss.foundation.http.KeyValue{ + ; +} + +-ignorewarnings + + +#Keep Class For MSS + +-keep class com.adins.mss.dao.** {*;} +-keep class com.adins.mss.base.login.DefaultLoginModel +-keep public class com.gadberry.** {*;} + +-keep public class com.adins.mss.base.authentication.AuthenticationResultBean{ + ; +} + +-keep public class com.adins.mss.foundation.formatter.DateFormatter{ + public ; +} + +-keep public class com.adins.mss.logger.Logger{ + public ; +} + +-keep class com.androidquery.AQuery { + public protected ; + public protected ; +} + +-keep class com.adins.mss.foundation.security.storepreferences.ObscuredSharedPreferences {*;} +-keep public class com.adins.mss.foundation.UserHelp.** {*;} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d7e7245a596fad336746835a67bcc61c65f84df.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d7e7245a596fad336746835a67bcc61c65f84df.svn-base new file mode 100644 index 0000000..cb8d4a7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d7e7245a596fad336746835a67bcc61c65f84df.svn-base @@ -0,0 +1,48 @@ +package com.adins.mss.base.syncfile; + +import android.content.Context; + +import com.adins.mss.dao.MobileDataFile; + +/** + * Created by loise on 10/18/2017. + */ + +/** + * class for holding parameters to pass in asynctask for db import process + */ +public class ImportDbParams { + public static Context context; + MobileDataFile metadata; + String message; + + public ImportDbParams(Context context, String message, MobileDataFile metadata) { + this.context = context; + this.metadata = metadata; + this.message = message; + } + + public Context getContext() { + return context; + } + + public void setContext(Context context) { + this.context = context; + } + + public MobileDataFile getMetadata() { + return metadata; + } + + public void setMetadata(MobileDataFile metadata) { + this.metadata = metadata; + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9295454bc05c6d86cb9a5f7cba7fb47b6400a0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9295454bc05c6d86cb9a5f7cba7fb47b6400a0.svn-base new file mode 100644 index 0000000..b3c755a --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9295454bc05c6d86cb9a5f7cba7fb47b6400a0.svn-base @@ -0,0 +1,121 @@ +package com.adins.mss.base.syncfile; + + +import android.util.Log; + +import com.adins.mss.base.crashlytics.FireCrash; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.List; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; +import java.util.zip.ZipOutputStream; + +/** + * Created by shaladin on 9/2/17. + */ + +/** + * class untuk compress dan extract file zip + */ +public class ArchiveManager { + + private String ext = ".zip"; + + /** + * Method for archiving file + * + * @param _files ArrayList source file to be archived + * @param archiveName Destination File without extension (path + filename) + */ + public void archive(ArrayList _files, String archiveName) { + try (FileOutputStream dest = new FileOutputStream(new File(archiveName + ext)); + ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest))) { + + byte[] data = new byte[8192]; + + for (int i = 0; i < _files.size(); i++) { + try (FileInputStream fin = new FileInputStream(_files.get(i)); + BufferedInputStream origin = new BufferedInputStream(fin, 8192)) { + Log.i("ArchiveManager","Adding: " + _files.get(i)); + ZipEntry zen = new ZipEntry(new File(_files.get(i)).getName()); + out.putNextEntry(zen); + + int count; + while ((count = origin.read(data, 0, 8192)) != -1) { + out.write(data, 0, count); + } + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + /** + * Method for extracting archive + * + * @param archiveFile source archive file to be extracted + * @param targetLocation target location extracted file + */ + public void extract(String archiveFile, String targetLocation) { + + File sourceArchiveFile = new File(archiveFile); + try (ZipFile zipFile = new ZipFile(sourceArchiveFile, ZipFile.OPEN_READ)){ + int BUFFER = 2048; + List zipFiles = new ArrayList<>(); + File destinationPath = new File(targetLocation); + + Enumeration zipFileEntries = zipFile.entries(); + String sourceCanonicalName = sourceArchiveFile.getCanonicalPath(); + if (!sourceCanonicalName.startsWith(archiveFile)){ + SecurityException securityException= new SecurityException("Kesalahan Security Terkait Tranversal ZIP"); + throw securityException; + }else { + while (zipFileEntries.hasMoreElements()) { + ZipEntry entry = (ZipEntry) zipFileEntries.nextElement(); + String currentEntry = entry.getName(); + + File destFile = new File(destinationPath, currentEntry); + if (currentEntry.endsWith(".zip")) { + zipFiles.add(destFile.getAbsolutePath()); + } + + File destinationParent = destFile.getParentFile(); + destinationParent.mkdirs(); + + try (FileOutputStream fos = new FileOutputStream(destFile); + BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER)) { + if (!entry.isDirectory()) { + BufferedInputStream is = new BufferedInputStream(zipFile.getInputStream(entry)); + int currentByte; + byte[] data = new byte[BUFFER]; + + while ((currentByte = is.read(data, 0, BUFFER)) != -1) { + dest.write(data, 0, currentByte); + } + + dest.flush(); + is.close(); + } + } catch (IOException io) { + io.printStackTrace(); + } + } + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9489b73376f81cb9f3d4e6bbd4f461ce945d5d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9489b73376f81cb9f3d4e6bbd4f461ce945d5d.svn-base new file mode 100644 index 0000000..09cf12d --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9489b73376f81cb9f3d4e6bbd4f461ce945d5d.svn-base @@ -0,0 +1,87 @@ +package com.adins.mss.base.dynamicform; + +import com.adins.mss.foundation.questiongenerator.QuestionBean; + +import java.util.List; + +/** + * Temporary Data for Dynamic Question Form + */ +public class DataForDynamicQuestion { + + /** + * Property selectedForm + */ + FormBean selectedForm; + + /** + * Property listOfQuestion + */ + List listOfQuestion; + + /** + * Property selectedHeader + */ + SurveyHeaderBean selectedHeader; + + /** + * Property mode + */ + int mode; + + /** + * Gets the selectedForm + */ + public FormBean getSelectedForm() { + return this.selectedForm; + } + + /** + * Sets the selectedForm + */ + public void setSelectedForm(FormBean value) { + this.selectedForm = value; + } + + /** + * Gets the listOfQuestion + */ + public List getListOfQuestion() { + return this.listOfQuestion; + } + + /** + * Sets the listOfQuestion + */ + public void setListOfQuestion(List value) { + this.listOfQuestion = value; + } + + /** + * Gets the selectedHeader + */ + public SurveyHeaderBean getSelectedHeader() { + return this.selectedHeader; + } + + /** + * Sets the selectedHeader + */ + public void setSelectedHeader(SurveyHeaderBean value) { + this.selectedHeader = value; + } + + /** + * Gets the mode + */ + public int getMode() { + return this.mode; + } + + /** + * Sets the mode + */ + public void setMode(int value) { + this.mode = value; + } +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9efb1093c321b160588a1be3e2ecf6c0c28ae7.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9efb1093c321b160588a1be3e2ecf6c0c28ae7.svn-base new file mode 100644 index 0000000..d4d677c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0d9efb1093c321b160588a1be3e2ecf6c0c28ae7.svn-base @@ -0,0 +1,353 @@ +/* + * Copyright 2010 Emmanuel Astier & Kevin Gaudin + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.acra; + +import android.app.Application; +import android.content.SharedPreferences; +import android.content.SharedPreferences.OnSharedPreferenceChangeListener; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.preference.PreferenceManager; + +import com.adins.mss.base.crashlytics.FireCrash; + +import org.acra.annotation.ReportsCrashes; +import org.acra.log.ACRALog; +import org.acra.log.AndroidLogDelegate; + +/** + * Use this class to initialize the crash reporting feature using + * {@link #init(Application)} as soon as possible in your {@link Application} + * subclass {@link Application#onCreate()} method. Configuration items must have + * been set by using {@link ReportsCrashes} above the declaration of your + * {@link Application} subclass. + * + * @author Kevin Gaudin + */ +public class ACRA { + + public static final boolean DEV_LOGGING = false; // Should be false for + // release. + public static final String LOG_TAG = ACRA.class.getSimpleName(); + /** + * The key of the application default SharedPreference where you can put a + * 'true' Boolean value to disable ACRA. + */ + public static final String PREF_DISABLE_ACRA = "acra.disable"; + /** + * Alternatively, you can use this key if you prefer your users to have the + * checkbox ticked to enable crash reports. If both acra.disable and + * acra.enable are set, the value of acra.disable takes over the other. + */ + public static final String PREF_ENABLE_ACRA = "acra.enable"; + /** + * The key of the SharedPreference allowing the user to disable sending + * content of logcat/dropbox. System logs collection is also dependent of + * the READ_LOGS permission. + */ + public static final String PREF_ENABLE_SYSTEM_LOGS = "acra.syslog.enable"; + /** + * The key of the SharedPreference allowing the user to disable sending his + * device id. Device ID collection is also dependent of the READ_PHONE_STATE + * permission. + */ + public static final String PREF_ENABLE_DEVICE_ID = "acra.deviceid.enable"; + /** + * The key of the SharedPreference allowing the user to always include his + * email address. + */ + public static final String PREF_USER_EMAIL_ADDRESS = "acra.user.email"; + /** + * The key of the SharedPreference allowing the user to automatically accept + * sending reports. + */ + public static final String PREF_ALWAYS_ACCEPT = "acra.alwaysaccept"; + /** + * The version number of the application the last time ACRA was started. + * This is used to determine whether unsent reports should be discarded + * because they are old and out of date. + */ + public static final String PREF_LAST_VERSION_NR = "acra.lastVersionNr"; + public static ACRALog log = new AndroidLogDelegate(); + private static Application mApplication; + + // Accessible via ACRA#getErrorReporter(). + private static ErrorReporter errorReporterSingleton; + + // NB don't convert to a local field because then it could be garbage + // collected and then we would have no PreferenceListener. + private static OnSharedPreferenceChangeListener mPrefListener; + private static ACRAConfiguration configProxy; + + /** + *

+ * Initialize ACRA for a given Application. The call to this method should + * be placed as soon as possible in the {@link Application#onCreate()} + * method. + *

+ * + * @param app Your Application class. + * @throws IllegalStateException if it is called more than once. + */ + public static void init(Application app) { + final ReportsCrashes reportsCrashes = app.getClass().getAnnotation(ReportsCrashes.class); + if (reportsCrashes == null) { + log.e(LOG_TAG, + "ACRA#init called but no ReportsCrashes annotation on Application " + app.getPackageName()); + return; + } + init(app, new ACRAConfiguration(reportsCrashes)); + } + + /** + *

+ * Initialize ACRA for a given Application. The call to this method should + * be placed as soon as possible in the {@link Application#onCreate()} + * method. + *

+ * + * @param app Your Application class. + * @param config ACRAConfiguration to manually set up ACRA configuration. + * @throws IllegalStateException if it is called more than once. + */ + public static void init(Application app, ACRAConfiguration config) { + init(app, config, true); + } + + /** + *

+ * Initialize ACRA for a given Application. The call to this method should + * be placed as soon as possible in the {@link Application#onCreate()} + * method. + *

+ * + * @param app Your Application class. + * @param config ACRAConfiguration to manually set up ACRA configuration. + * @param checkReportsOnApplicationStart Whether to invoke + * ErrorReporter.checkReportsOnApplicationStart(). Apps which adjust the + * ReportSenders should set this to false and call + * checkReportsOnApplicationStart() themselves to prevent a potential + * race with the SendWorker and list of ReportSenders. + * @throws IllegalStateException if it is called more than once. + */ + public static void init(Application app, ACRAConfiguration config, boolean checkReportsOnApplicationStart) { + + if (mApplication != null) { + log.w(LOG_TAG, "ACRA#init called more than once. Won't do anything more."); + return; + } + mApplication = app; + + if (config == null) { + log.e(LOG_TAG, "ACRA#init called but no ACRAConfiguration provided"); + return; + } + setConfig(config); + + final SharedPreferences prefs = getACRASharedPreferences(); + + try { + checkCrashResources(config); + + log.d(LOG_TAG, "ACRA is enabled for " + mApplication.getPackageName() + ", initializing..."); + + // Initialize ErrorReporter with all required data + final boolean enableAcra = !shouldDisableACRA(prefs); + final ErrorReporter errorReporter = new ErrorReporter(mApplication, prefs, enableAcra); + + // Append ReportSenders. + errorReporter.setDefaultReportSenders(); + + errorReporterSingleton = errorReporter; + + // Check for pending reports + if (checkReportsOnApplicationStart) { + errorReporter.checkReportsOnApplicationStart(); + } + + } catch (ACRAConfigurationException e) { + log.w(LOG_TAG, "Error : ", e); + } + + // We HAVE to keep a reference otherwise the listener could be garbage + // collected: + // http://stackoverflow.com/questions/2542938/sharedpreferences-onsharedpreferencechangelistener-not-being-called-consistently/3104265#3104265 + mPrefListener = new OnSharedPreferenceChangeListener() { + + @Override + public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { + if (PREF_DISABLE_ACRA.equals(key) || PREF_ENABLE_ACRA.equals(key)) { + final boolean enableAcra = !shouldDisableACRA(sharedPreferences); + getErrorReporter().setEnabled(enableAcra); + } + } + }; + + // This listener has to be set after initAcra is called to avoid a + // NPE in ErrorReporter.disable() because + // the context could be null at this moment. + prefs.registerOnSharedPreferenceChangeListener(mPrefListener); + } + + /** + * @return the current instance of ErrorReporter. + * @throws IllegalStateException if {@link ACRA#init(android.app.Application)} has not yet + * been called. + */ + public static ErrorReporter getErrorReporter() { + if (errorReporterSingleton == null) { + throw new IllegalStateException("Cannot access ErrorReporter before ACRA#init"); + } + return errorReporterSingleton; + } + + /** + * Check if the application default shared preferences contains true for the + * key "acra.disable", do not activate ACRA. Also checks the alternative + * opposite setting "acra.enable" if "acra.disable" is not found. + * + * @param prefs SharedPreferences to check to see whether ACRA should be + * disabled. + * @return true if prefs indicate that ACRA should be disabled. + */ + private static boolean shouldDisableACRA(SharedPreferences prefs) { + boolean disableAcra = false; + try { + final boolean enableAcra = prefs.getBoolean(PREF_ENABLE_ACRA, true); + disableAcra = prefs.getBoolean(PREF_DISABLE_ACRA, !enableAcra); + } catch (Exception e) { + FireCrash.log(e); + // In case of a ClassCastException + } + return disableAcra; + } + + /** + * Checks that mandatory configuration items have been provided. + * + * @throws ACRAConfigurationException if required values are missing. + */ + static void checkCrashResources(ReportsCrashes conf) throws ACRAConfigurationException { + switch (conf.mode()) { + case TOAST: + if (conf.resToastText() == 0) { + throw new ACRAConfigurationException( + "TOAST mode: you have to define the resToastText parameter in your application @ReportsCrashes() annotation."); + } + break; + case NOTIFICATION: + if (conf.resNotifTickerText() == 0 || conf.resNotifTitle() == 0 || conf.resNotifText() == 0) { + throw new ACRAConfigurationException( + "NOTIFICATION mode: you have to define at least the resNotifTickerText, resNotifTitle, resNotifText parameters in your application @ReportsCrashes() annotation."); + } + if (CrashReportDialog.class.equals(conf.reportDialogClass()) && conf.resDialogText() == 0) { + throw new ACRAConfigurationException( + "NOTIFICATION mode: using the (default) CrashReportDialog requires you have to define the resDialogText parameter in your application @ReportsCrashes() annotation."); + } + break; + case DIALOG: + if (CrashReportDialog.class.equals(conf.reportDialogClass()) && conf.resDialogText() == 0) { + throw new ACRAConfigurationException( + "DIALOG mode: using the (default) CrashReportDialog requires you to define the resDialogText parameter in your application @ReportsCrashes() annotation."); + } + break; + default: + break; + } + } + + /** + * Retrieves the {@link SharedPreferences} instance where user adjustable + * settings for ACRA are stored. Default are the Application default + * SharedPreferences, but you can provide another SharedPreferences name + * with {@link ReportsCrashes#sharedPreferencesName()}. + * + * @return The Shared Preferences where ACRA will retrieve its user + * adjustable setting. + */ + public static SharedPreferences getACRASharedPreferences() { + ReportsCrashes conf = getConfig(); + if (!"".equals(conf.sharedPreferencesName())) { + return mApplication.getSharedPreferences(conf.sharedPreferencesName(), conf.sharedPreferencesMode()); + } else { + return PreferenceManager.getDefaultSharedPreferences(mApplication); + } + } + + /** + * Provides the current ACRA configuration. + * + * @return Current ACRA {@link ReportsCrashes} configuration instance. + */ + public static ACRAConfiguration getConfig() { + if (configProxy == null) { + if (mApplication == null) { + log.w(LOG_TAG, + "Calling ACRA.getConfig() before ACRA.init() gives you an empty configuration instance. You might prefer calling ACRA.getNewDefaultConfig(Application) to get an instance with default values taken from a @ReportsCrashes annotation."); + } + configProxy = getNewDefaultConfig(mApplication); + } + return configProxy; + } + + /** + * Sets the whole ACRA configuration. + * + * @param conf ACRAConfiguration to use as a proxy for config info. + */ + public static void setConfig(ACRAConfiguration conf) { + configProxy = conf; + } + + /** + * @param app Your Application class. + * @return new {@link ACRAConfiguration} instance with values initialized + * from the {@link ReportsCrashes} annotation. + */ + public static ACRAConfiguration getNewDefaultConfig(Application app) { + if (app != null) { + return new ACRAConfiguration(app.getClass().getAnnotation(ReportsCrashes.class)); + } else { + return new ACRAConfiguration(null); + } + } + + /** + * Returns true if the application is debuggable. + * + * @return true if the application is debuggable. + */ + static boolean isDebuggable() { + PackageManager pm = mApplication.getPackageManager(); + try { + return ((pm.getApplicationInfo(mApplication.getPackageName(), 0).flags & ApplicationInfo.FLAG_DEBUGGABLE) > 0); + } catch (NameNotFoundException e) { + return false; + } + } + + static Application getApplication() { + return mApplication; + } + + public static void setLog(ACRALog log) { + if (log == null) { + throw new NullPointerException("ACRALog cannot be null"); + } + ACRA.log = log; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbab06c62578f48655154b648c550f4791f78cb.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbab06c62578f48655154b648c550f4791f78cb.svn-base new file mode 100644 index 0000000..2db15bc --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbab06c62578f48655154b648c550f4791f78cb.svn-base @@ -0,0 +1,5 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbe214f2d786c6baccb2dd9b1a46f72218c3184.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbe214f2d786c6baccb2dd9b1a46f72218c3184.svn-base new file mode 100644 index 0000000..4ae7a5c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0d/0dbe214f2d786c6baccb2dd9b1a46f72218c3184.svn-base @@ -0,0 +1,38 @@ +package com.adins.mss.coll.loyalti.barchart; + +import com.adins.mss.coll.models.loyaltymodels.GroupPointData; +import com.adins.mss.coll.models.loyaltymodels.PointDetail; +import com.github.mikephil.charting.data.BarDataSet; +import com.github.mikephil.charting.data.BarEntry; + +import java.util.ArrayList; +import java.util.List; + +public class LoyaltyBarDataSet extends BarDataSet { + + List pointDetailsDataSet = new ArrayList<>(); + List pointCategories = new ArrayList<>(); + + public LoyaltyBarDataSet(List pointDetails,List pointCategories,List yVals, String label) { + super(yVals, label); + pointDetailsDataSet = pointDetails; + this.pointCategories = pointCategories; + } + + @Override + public int getColor(int index) { + if(index >= pointDetailsDataSet.size()) + return pointCategories.get(0).colorValue; + + PointDetail currentPointDetail = pointDetailsDataSet.get(index); + int selectedColor = -1; + for (PointDetail category:pointCategories) { + if(category.rewardProgram.equals(currentPointDetail.rewardProgram)){ + selectedColor = category.colorValue; + break; + } + } + + return selectedColor; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e03f6b8d765ee1f3d39d5fb9f9a1260e69e35e8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e03f6b8d765ee1f3d39d5fb9f9a1260e69e35e8.svn-base new file mode 100644 index 0000000..74d1859 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e03f6b8d765ee1f3d39d5fb9f9a1260e69e35e8.svn-base @@ -0,0 +1,506 @@ +package com.adins.mss.coll.loyalti.pointacquisitionmonthly; + +import android.app.ProgressDialog; +import android.content.Context; +import android.graphics.Color; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.constraintlayout.widget.ConstraintLayout; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentTransaction; +import androidx.core.widget.NestedScrollView; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.coll.R; +import com.adins.mss.coll.fragments.DashBoardFragment; +import com.adins.mss.coll.loyalti.barchart.LoyaltyBarChartRenderer; +import com.adins.mss.coll.loyalti.barchart.LoyaltyBarDataSet; +import com.adins.mss.coll.loyalti.barchart.LoyaltyXLabelFormatter; +import com.adins.mss.coll.loyalti.barchart.NonScrollListView; +import com.adins.mss.coll.loyalti.barchart.PointClickMarker; +import com.adins.mss.coll.loyalti.barchart.pointlegends.PointLegendsAdapter; +import com.adins.mss.coll.loyalti.barchart.ranklegends.RankLegendsAdapter; +import com.adins.mss.coll.loyalti.pointacquisitiondaily.DailyPointsChartView; +import com.adins.mss.coll.loyalti.pointacquisitionmonthly.contracts.ILoyaltyPointsDataSource; +import com.adins.mss.coll.loyalti.pointacquisitionmonthly.contracts.MonthlyPointContract; +import com.adins.mss.coll.models.loyaltymodels.GroupPointData; +import com.adins.mss.coll.models.loyaltymodels.LoyaltyPointsRequest; +import com.adins.mss.coll.models.loyaltymodels.PointDetail; +import com.adins.mss.coll.models.loyaltymodels.RankDetail; +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.UserHelp.Bean.Dummy.UserHelpViewDummy; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpView; +import com.adins.mss.foundation.UserHelp.UserHelp; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.github.mikephil.charting.charts.BarChart; +import com.github.mikephil.charting.components.LimitLine; +import com.github.mikephil.charting.components.XAxis; +import com.github.mikephil.charting.components.YAxis; +import com.github.mikephil.charting.data.BarData; +import com.github.mikephil.charting.data.BarDataSet; +import com.github.mikephil.charting.data.BarEntry; +import com.github.mikephil.charting.listener.ChartTouchListener; +import com.github.mikephil.charting.listener.OnChartGestureListener; +import com.github.mikephil.charting.utils.MPPointD; + +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.List; + +/** + * A simple {@link Fragment} subclass. + */ +public class MonthlyPointsChartView extends Fragment implements MonthlyPointContract.View,OnChartGestureListener { + + //android views + private ConstraintLayout chartContent; + private ConstraintLayout legendContainer; + private BarChart barChart; + private NonScrollListView rankLegends; + private NonScrollListView pointLegends; + private TextView totalPointsV; + private ProgressDialog progressDialog; + private NiftyDialogBuilder dialogBuilder; + private NestedScrollView scrollView; + + //presenter + private MonthlyPointContract.Presenter presenter; + + //chart data + private int averagePoint; + private int maxPoint; + private int initialIdx; + private float[][] pointDataSet; + private RankDetail[][] rankDataSet; + private List rankDetails; + private List pointDetailsDataSet; + private List pointDetails; + private LoyaltyXLabelFormatter xLabelFormatter; + + //legend colors + int[] pointDetailColors = {Color.parseColor("#FBBA72") + ,Color.parseColor("#F86624"), + Color.parseColor("#BA5624") , + Color.parseColor("#8F250C")}; + + int[] rankColors = {Color.parseColor("#FF0000"), + Color.parseColor("#000000"), + Color.parseColor("#32CD32"), + Color.parseColor("#0000FF")}; + private Handler handler; + + public MonthlyPointsChartView() { + // Required empty public constructor + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View view = inflater.inflate(R.layout.fragment_point_acquisition, container, false); + chartContent = view.findViewById(R.id.chartContent); + barChart = view.findViewById(R.id.monthlyChart); + rankLegends = view.findViewById(R.id.legendRanks); + pointLegends = view.findViewById(R.id.legendPoints); + totalPointsV = view.findViewById(R.id.totalPoint); + scrollView = view.findViewById(R.id.scrollView); + legendContainer = view.findViewById(R.id.legendsContainer); + return view; + } + + @Override + public void onViewCreated(@NonNull final View view, @Nullable Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + + String programName = getArguments()!=null?getArguments().getString("MembershipProgramName"):getString(R.string.monthly_point_page_title); + String programStartDate = getArguments()!=null?getArguments().getString("ProgramStartDate"):""; + getActivity().setTitle(programName); + handler = new Handler(Looper.getMainLooper()); + + Global.positionStack.push(1); + chartContent.setVisibility(View.GONE); + + ILoyaltyPointsDataSource dataSource = new LoyaltyPointsDataSource(getActivity().getApplication()); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(new Date()); + MonthlyPointsLogic monthlyPointsLogic = new MonthlyPointsLogic(dataSource,programStartDate,calendar.get(Calendar.YEAR)); + MonthlyPointsPresenter presenter = new MonthlyPointsPresenter(this,monthlyPointsLogic); + setPresenter(presenter); + if(needShowUserHelp()){ + showUserhelp(); + } + else { + loadMonthlyPointsData(); + } + } + + @Override + public void onAttach(Context context) { + super.onAttach(context); + setHasOptionsMenu(true); + } + + @Override + public void onPrepareOptionsMenu(final Menu menu) { + super.onPrepareOptionsMenu(menu); + if(checkUserHelpAvailability()){ + menu.findItem(R.id.mnGuide).setVisible(true); + } + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + if(item.getItemId() == com.adins.mss.base.R.id.mnGuide){ + if(!Global.BACKPRESS_RESTRICTION) { + UserHelp.reloadUserHelp(getActivity(), DummyMonthlyPointView.class.getSimpleName()); + if(needShowUserHelp()){ + showUserhelp(); + } + } + } + return super.onOptionsItemSelected(item); + } + + @Override + public void setPresenter(MonthlyPointContract.Presenter presenter) { + this.presenter = presenter; + } + + //kode request poin bulanan + private void loadMonthlyPointsData() { + progressDialog = ProgressDialog.show(getActivity(), "", getString(R.string.please_wait_dialog), true); + + //dummy request + LoyaltyPointsRequest request = new LoyaltyPointsRequest(); + request.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + request.addImeiAndroidIdToUnstructured(); + String loginid = GlobalData.getSharedGlobalData().getUser().getLogin_id(); + String[] loginIdSplit = loginid.split("@"); + request.loginId = loginIdSplit[0]; + String programCode = ""; + Bundle bundle = getArguments(); + if(bundle!=null) + programCode = bundle.getString("MembershipProgramCode"); + request.membershipProgramId = programCode; + + presenter.getMonthlyPointsData(request); + } + + //callback data poin bulanan + @Override + public void onDataReceived(float[][] pointDataSet, RankDetail[][] rankDataSet, List pointDetailsDataSet) { + chartContent.setVisibility(View.VISIBLE); + if (progressDialog.isShowing()){ + progressDialog.dismiss(); + } + if(pointDataSet.length < 3){ + //padding data to avoid large bar width + float[][] newDataSet = paddingDataSet(pointDataSet,3-pointDataSet.length); + for(int i = pointDataSet.length; i rankDetails) { + this.rankDetails = rankDetails; + } + + private void setPointsLegend(List pointDetails) { + for(int i=0; i 0){ + String[] padMonthLabels = new String[monthLabels.length + padData]; + for(int i=0; i userHelpViews = Global.userHelpGuide.get(DummyMonthlyPointView.class.getSimpleName()); + return Global.ENABLE_USER_HELP && userHelpViews != null && userHelpViews.size() > 0; + } + + private void showUserhelp(){ + FragmentTransaction transaction = getActivity().getSupportFragmentManager().beginTransaction(); + Fragment dummyChart = new DummyMonthlyPointView(); + transaction.replace(R.id.content_frame,dummyChart); + transaction.addToBackStack(null); + transaction.commit(); + } + + private void drawChart(){ + if(pointDataSet == null || pointDataSet.length == 0) + return; + + //set chart pointDataSet + List barEntryList = new ArrayList<>(); + for(int i = 0; i< pointDataSet.length; i++){ + barEntryList.add(new BarEntry(i, pointDataSet[i])); + } + + int[] stackBarColor = new int[pointDetails.size()]; + for(int i=0; i pointDataSet.length - 1){ + initialIdx = 0; + } + barChart.moveViewToX(initialIdx - 0.7f); + //chart viewport range + barChart.setVisibleXRangeMaximum(4f); + } + + @Override + public void onChartSingleTapped(MotionEvent me) { + float tappedX = me.getX(); + float tappedY = me.getY(); + MPPointD point = barChart.getTransformer(YAxis.AxisDependency.LEFT).getValuesByTouchPoint(tappedX, tappedY); + if(point.y < 0){ + int idx = (int)Math.round(point.x); + int xLabelSize = barChart.getXAxis().getLabelCount(); + if(idx < 0 || idx >= xLabelSize) + return; + + GroupPointData pointData = presenter.getPointDataAt(idx); + if(pointData != null) + goToDailyPointsChart(pointData); + } + } + + private void goToDailyPointsChart(GroupPointData groupPointData){ + Bundle bundle = new Bundle(); + bundle.putString("GroupPoint",groupPointData.groupPoint); + String programCode = getArguments()!=null?getArguments().getString("MembershipProgramCode"):""; + bundle.putString("MembershipProgramCode",programCode); + String programName = getArguments()!=null?getArguments().getString("MembershipProgramName"):""; + bundle.putString("MembershipProgramName",programName); + String programStartDate = getArguments()!=null?getArguments().getString("ProgramStartDate"):""; + bundle.putString("ProgramStartDate",programStartDate); + + //fragment transaction + DailyPointsChartView dailyPointsChart = new DailyPointsChartView(); + dailyPointsChart.setArguments(bundle); + + FragmentTransaction transaction = getActivity().getSupportFragmentManager().beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate,R.anim.activity_close_scale,R.anim.activity_open_scale,R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, dailyPointsChart); + transaction.addToBackStack(null); + transaction.commit(); + } + + //below chart listener implementation not used for now + @Override + public void onChartGestureStart(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) { + + } + + @Override + public void onChartGestureEnd(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) { + + } + + @Override + public void onChartLongPressed(MotionEvent me) { + + } + + @Override + public void onChartDoubleTapped(MotionEvent me) { + + } + + @Override + public void onChartFling(MotionEvent me1, MotionEvent me2, float velocityX, float velocityY) { + + } + + @Override + public void onChartScale(MotionEvent me, float scaleX, float scaleY) { + + } + + @Override + public void onChartTranslate(MotionEvent me, float dX, float dY) { + + } + + private boolean checkUserHelpAvailability() { + List userHelpViews = Global.userHelpGuide.get(DummyMonthlyPointView.class.getSimpleName()); + return Global.ENABLE_USER_HELP && userHelpViews != null; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e39ef00fa8b3c4c33c998a26a2e9d68296cdfe3.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e39ef00fa8b3c4c33c998a26a2e9d68296cdfe3.svn-base new file mode 100644 index 0000000..53a10ce --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e39ef00fa8b3c4c33c998a26a2e9d68296cdfe3.svn-base @@ -0,0 +1,311 @@ +package com.adins.mss.dao; + +import java.util.List; +import java.util.ArrayList; +import android.database.Cursor; + +import de.greenrobot.dao.AbstractDao; +import de.greenrobot.dao.Property; +import de.greenrobot.dao.internal.SqlUtils; +import de.greenrobot.dao.internal.DaoConfig; +import de.greenrobot.dao.database.Database; +import de.greenrobot.dao.database.DatabaseStatement; +import de.greenrobot.dao.query.Query; +import de.greenrobot.dao.query.QueryBuilder; + +import com.adins.mss.dao.MobileContentD; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. +/** + * DAO for table "TR_MOBILECONTENT_D". +*/ +public class MobileContentDDao extends AbstractDao { + + public static final String TABLENAME = "TR_MOBILECONTENT_D"; + + /** + * Properties of entity MobileContentD.
+ * Can be used for QueryBuilder and for referencing column names. + */ + public static class Properties { + public final static Property Uuid_mobile_content_d = new Property(0, String.class, "uuid_mobile_content_d", true, "UUID_MOBILE_CONTENT_D"); + public final static Property Menu_id = new Property(1, String.class, "menu_id", false, "MENU_ID"); + public final static Property Content = new Property(2, byte[].class, "content", false, "CONTENT"); + public final static Property Content_type = new Property(3, String.class, "content_type", false, "CONTENT_TYPE"); + public final static Property Sequence = new Property(4, Integer.class, "sequence", false, "SEQUENCE"); + public final static Property Usr_crt = new Property(5, String.class, "usr_crt", false, "USR_CRT"); + public final static Property Dtm_crt = new Property(6, java.util.Date.class, "dtm_crt", false, "DTM_CRT"); + public final static Property Usr_upd = new Property(7, String.class, "usr_upd", false, "USR_UPD"); + public final static Property Uuid_mobile_content_h = new Property(8, String.class, "uuid_mobile_content_h", false, "UUID_MOBILE_CONTENT_H"); + public final static Property Start_date = new Property(9, java.util.Date.class, "start_date", false, "START_DATE"); + public final static Property End_date = new Property(10, java.util.Date.class, "end_date", false, "END_DATE"); + }; + + private DaoSession daoSession; + + private Query mobileContentH_MobileContentDListQuery; + + public MobileContentDDao(DaoConfig config) { + super(config); + } + + public MobileContentDDao(DaoConfig config, DaoSession daoSession) { + super(config, daoSession); + this.daoSession = daoSession; + } + + /** Creates the underlying database table. */ + public static void createTable(Database db, boolean ifNotExists) { + String constraint = ifNotExists? "IF NOT EXISTS ": ""; + db.execSQL("CREATE TABLE " + constraint + "\"TR_MOBILECONTENT_D\" (" + // + "\"UUID_MOBILE_CONTENT_D\" TEXT PRIMARY KEY NOT NULL ," + // 0: uuid_mobile_content_d + "\"MENU_ID\" TEXT," + // 1: menu_id + "\"CONTENT\" BLOB," + // 2: content + "\"CONTENT_TYPE\" TEXT," + // 3: content_type + "\"SEQUENCE\" INTEGER," + // 4: sequence + "\"USR_CRT\" TEXT," + // 5: usr_crt + "\"DTM_CRT\" INTEGER," + // 6: dtm_crt + "\"USR_UPD\" TEXT," + // 7: usr_upd + "\"UUID_MOBILE_CONTENT_H\" TEXT," + // 8: uuid_mobile_content_h + "\"START_DATE\" INTEGER," + // 9: start_date + "\"END_DATE\" INTEGER);"); // 10: end_date + } + + /** Drops the underlying database table. */ + public static void dropTable(Database db, boolean ifExists) { + String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"TR_MOBILECONTENT_D\""; + db.execSQL(sql); + } + + /** @inheritdoc */ + @Override + protected void bindValues(DatabaseStatement stmt, MobileContentD entity) { + stmt.clearBindings(); + stmt.bindString(1, entity.getUuid_mobile_content_d()); + + String menu_id = entity.getMenu_id(); + if (menu_id != null) { + stmt.bindString(2, menu_id); + } + + byte[] content = entity.getContent(); + if (content != null) { + stmt.bindBlob(3, content); + } + + String content_type = entity.getContent_type(); + if (content_type != null) { + stmt.bindString(4, content_type); + } + + Integer sequence = entity.getSequence(); + if (sequence != null) { + stmt.bindLong(5, sequence); + } + + String usr_crt = entity.getUsr_crt(); + if (usr_crt != null) { + stmt.bindString(6, usr_crt); + } + + java.util.Date dtm_crt = entity.getDtm_crt(); + if (dtm_crt != null) { + stmt.bindLong(7, dtm_crt.getTime()); + } + + String usr_upd = entity.getUsr_upd(); + if (usr_upd != null) { + stmt.bindString(8, usr_upd); + } + + String uuid_mobile_content_h = entity.getUuid_mobile_content_h(); + if (uuid_mobile_content_h != null) { + stmt.bindString(9, uuid_mobile_content_h); + } + + java.util.Date start_date = entity.getStart_date(); + if (start_date != null) { + stmt.bindLong(10, start_date.getTime()); + } + + java.util.Date end_date = entity.getEnd_date(); + if (end_date != null) { + stmt.bindLong(11, end_date.getTime()); + } + } + + @Override + protected void attachEntity(MobileContentD entity) { + super.attachEntity(entity); + entity.__setDaoSession(daoSession); + } + + /** @inheritdoc */ + @Override + public String readKey(Cursor cursor, int offset) { + return cursor.getString(offset + 0); + } + + /** @inheritdoc */ + @Override + public MobileContentD readEntity(Cursor cursor, int offset) { + MobileContentD entity = new MobileContentD( // + cursor.getString(offset + 0), // uuid_mobile_content_d + cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // menu_id + cursor.isNull(offset + 2) ? null : cursor.getBlob(offset + 2), // content + cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3), // content_type + cursor.isNull(offset + 4) ? null : cursor.getInt(offset + 4), // sequence + cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5), // usr_crt + cursor.isNull(offset + 6) ? null : new java.util.Date(cursor.getLong(offset + 6)), // dtm_crt + cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7), // usr_upd + cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8), // uuid_mobile_content_h + cursor.isNull(offset + 9) ? null : new java.util.Date(cursor.getLong(offset + 9)), // start_date + cursor.isNull(offset + 10) ? null : new java.util.Date(cursor.getLong(offset + 10)) // end_date + ); + return entity; + } + + /** @inheritdoc */ + @Override + public void readEntity(Cursor cursor, MobileContentD entity, int offset) { + entity.setUuid_mobile_content_d(cursor.getString(offset + 0)); + entity.setMenu_id(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1)); + entity.setContent(cursor.isNull(offset + 2) ? null : cursor.getBlob(offset + 2)); + entity.setContent_type(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3)); + entity.setSequence(cursor.isNull(offset + 4) ? null : cursor.getInt(offset + 4)); + entity.setUsr_crt(cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5)); + entity.setDtm_crt(cursor.isNull(offset + 6) ? null : new java.util.Date(cursor.getLong(offset + 6))); + entity.setUsr_upd(cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7)); + entity.setUuid_mobile_content_h(cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8)); + entity.setStart_date(cursor.isNull(offset + 9) ? null : new java.util.Date(cursor.getLong(offset + 9))); + entity.setEnd_date(cursor.isNull(offset + 10) ? null : new java.util.Date(cursor.getLong(offset + 10))); + } + + /** @inheritdoc */ + @Override + protected String updateKeyAfterInsert(MobileContentD entity, long rowId) { + return entity.getUuid_mobile_content_d(); + } + + /** @inheritdoc */ + @Override + public String getKey(MobileContentD entity) { + if(entity != null) { + return entity.getUuid_mobile_content_d(); + } else { + return null; + } + } + + /** @inheritdoc */ + @Override + protected boolean isEntityUpdateable() { + return true; + } + + /** Internal query to resolve the "mobileContentDList" to-many relationship of MobileContentH. */ + public List _queryMobileContentH_MobileContentDList(String uuid_mobile_content_h) { + synchronized (this) { + if (mobileContentH_MobileContentDListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Uuid_mobile_content_h.eq(null)); + mobileContentH_MobileContentDListQuery = queryBuilder.build(); + } + } + Query query = mobileContentH_MobileContentDListQuery.forCurrentThread(); + query.setParameter(0, uuid_mobile_content_h); + return query.list(); + } + + private String selectDeep; + + protected String getSelectDeep() { + if (selectDeep == null) { + StringBuilder builder = new StringBuilder("SELECT "); + SqlUtils.appendColumns(builder, "T", getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T0", daoSession.getMobileContentHDao().getAllColumns()); + builder.append(" FROM TR_MOBILECONTENT_D T"); + builder.append(" LEFT JOIN TR_MOBILECONTENT_H T0 ON T.\"UUID_MOBILE_CONTENT_H\"=T0.\"UUID_MOBILE_CONTENT_H\""); + builder.append(' '); + selectDeep = builder.toString(); + } + return selectDeep; + } + + protected MobileContentD loadCurrentDeep(Cursor cursor, boolean lock) { + MobileContentD entity = loadCurrent(cursor, 0, lock); + int offset = getAllColumns().length; + + MobileContentH mobileContentH = loadCurrentOther(daoSession.getMobileContentHDao(), cursor, offset); + entity.setMobileContentH(mobileContentH); + + return entity; + } + + public MobileContentD loadDeep(Long key) { + assertSinglePk(); + if (key == null) { + return null; + } + + StringBuilder builder = new StringBuilder(getSelectDeep()); + builder.append("WHERE "); + SqlUtils.appendColumnsEqValue(builder, "T", getPkColumns()); + String sql = builder.toString(); + + String[] keyArray = new String[] { key.toString() }; + Cursor cursor = db.rawQuery(sql, keyArray); + + try { + boolean available = cursor.moveToFirst(); + if (!available) { + return null; + } else if (!cursor.isLast()) { + throw new IllegalStateException("Expected unique result, but count was " + cursor.getCount()); + } + return loadCurrentDeep(cursor, true); + } finally { + cursor.close(); + } + } + + /** Reads all available rows from the given cursor and returns a list of new ImageTO objects. */ + public List loadAllDeepFromCursor(Cursor cursor) { + int count = cursor.getCount(); + List list = new ArrayList(count); + + if (cursor.moveToFirst()) { + if (identityScope != null) { + identityScope.lock(); + identityScope.reserveRoom(count); + } + try { + do { + list.add(loadCurrentDeep(cursor, false)); + } while (cursor.moveToNext()); + } finally { + if (identityScope != null) { + identityScope.unlock(); + } + } + } + return list; + } + + protected List loadDeepAllAndCloseCursor(Cursor cursor) { + try { + return loadAllDeepFromCursor(cursor); + } finally { + cursor.close(); + } + } + + + /** A raw-style query where you can pass any WHERE clause and arguments. */ + public List queryDeep(String where, String... selectionArg) { + Cursor cursor = db.rawQuery(getSelectDeep() + where, selectionArg); + return loadDeepAllAndCloseCursor(cursor); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3a9c55e77d1f2609cfff691e8f767d765636fe.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3a9c55e77d1f2609cfff691e8f767d765636fe.svn-base new file mode 100644 index 0000000..9c8bcab --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3a9c55e77d1f2609cfff691e8f767d765636fe.svn-base @@ -0,0 +1,9 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3aebe3bda38e69bc4dc2b781abc917d56c5f37.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3aebe3bda38e69bc4dc2b781abc917d56c5f37.svn-base new file mode 100644 index 0000000..21c51bc --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3aebe3bda38e69bc4dc2b781abc917d56c5f37.svn-base @@ -0,0 +1,257 @@ +package com.adins.mss.dao; + +import java.util.List; +import java.util.ArrayList; +import android.database.Cursor; + +import de.greenrobot.dao.AbstractDao; +import de.greenrobot.dao.Property; +import de.greenrobot.dao.internal.SqlUtils; +import de.greenrobot.dao.internal.DaoConfig; +import de.greenrobot.dao.database.Database; +import de.greenrobot.dao.database.DatabaseStatement; +import de.greenrobot.dao.query.Query; +import de.greenrobot.dao.query.QueryBuilder; + +import com.adins.mss.dao.Logger; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. +/** + * DAO for table "TR_APPLICATION_LOG". +*/ +public class LoggerDao extends AbstractDao { + + public static final String TABLENAME = "TR_APPLICATION_LOG"; + + /** + * Properties of entity Logger.
+ * Can be used for QueryBuilder and for referencing column names. + */ + public static class Properties { + public final static Property Uuid_log = new Property(0, String.class, "uuid_log", true, "UUID_LOG"); + public final static Property Screen = new Property(1, String.class, "screen", false, "SCREEN"); + public final static Property Timestamp = new Property(2, java.util.Date.class, "timestamp", false, "TIMESTAMP"); + public final static Property Detail = new Property(3, String.class, "detail", false, "DETAIL"); + public final static Property Uuid_user = new Property(4, String.class, "uuid_user", false, "UUID_USER"); + }; + + private DaoSession daoSession; + + private Query user_LoggerListQuery; + + public LoggerDao(DaoConfig config) { + super(config); + } + + public LoggerDao(DaoConfig config, DaoSession daoSession) { + super(config, daoSession); + this.daoSession = daoSession; + } + + /** Creates the underlying database table. */ + public static void createTable(Database db, boolean ifNotExists) { + String constraint = ifNotExists? "IF NOT EXISTS ": ""; + db.execSQL("CREATE TABLE " + constraint + "\"TR_APPLICATION_LOG\" (" + // + "\"UUID_LOG\" TEXT PRIMARY KEY NOT NULL ," + // 0: uuid_log + "\"SCREEN\" TEXT," + // 1: screen + "\"TIMESTAMP\" INTEGER," + // 2: timestamp + "\"DETAIL\" TEXT," + // 3: detail + "\"UUID_USER\" TEXT);"); // 4: uuid_user + } + + /** Drops the underlying database table. */ + public static void dropTable(Database db, boolean ifExists) { + String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"TR_APPLICATION_LOG\""; + db.execSQL(sql); + } + + /** @inheritdoc */ + @Override + protected void bindValues(DatabaseStatement stmt, Logger entity) { + stmt.clearBindings(); + stmt.bindString(1, entity.getUuid_log()); + + String screen = entity.getScreen(); + if (screen != null) { + stmt.bindString(2, screen); + } + + java.util.Date timestamp = entity.getTimestamp(); + if (timestamp != null) { + stmt.bindLong(3, timestamp.getTime()); + } + + String detail = entity.getDetail(); + if (detail != null) { + stmt.bindString(4, detail); + } + + String uuid_user = entity.getUuid_user(); + if (uuid_user != null) { + stmt.bindString(5, uuid_user); + } + } + + @Override + protected void attachEntity(Logger entity) { + super.attachEntity(entity); + entity.__setDaoSession(daoSession); + } + + /** @inheritdoc */ + @Override + public String readKey(Cursor cursor, int offset) { + return cursor.getString(offset + 0); + } + + /** @inheritdoc */ + @Override + public Logger readEntity(Cursor cursor, int offset) { + Logger entity = new Logger( // + cursor.getString(offset + 0), // uuid_log + cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // screen + cursor.isNull(offset + 2) ? null : new java.util.Date(cursor.getLong(offset + 2)), // timestamp + cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3), // detail + cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4) // uuid_user + ); + return entity; + } + + /** @inheritdoc */ + @Override + public void readEntity(Cursor cursor, Logger entity, int offset) { + entity.setUuid_log(cursor.getString(offset + 0)); + entity.setScreen(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1)); + entity.setTimestamp(cursor.isNull(offset + 2) ? null : new java.util.Date(cursor.getLong(offset + 2))); + entity.setDetail(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3)); + entity.setUuid_user(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); + } + + /** @inheritdoc */ + @Override + protected String updateKeyAfterInsert(Logger entity, long rowId) { + return entity.getUuid_log(); + } + + /** @inheritdoc */ + @Override + public String getKey(Logger entity) { + if(entity != null) { + return entity.getUuid_log(); + } else { + return null; + } + } + + /** @inheritdoc */ + @Override + protected boolean isEntityUpdateable() { + return true; + } + + /** Internal query to resolve the "loggerList" to-many relationship of User. */ + public List _queryUser_LoggerList(String uuid_user) { + synchronized (this) { + if (user_LoggerListQuery == null) { + QueryBuilder queryBuilder = queryBuilder(); + queryBuilder.where(Properties.Uuid_user.eq(null)); + user_LoggerListQuery = queryBuilder.build(); + } + } + Query query = user_LoggerListQuery.forCurrentThread(); + query.setParameter(0, uuid_user); + return query.list(); + } + + private String selectDeep; + + protected String getSelectDeep() { + if (selectDeep == null) { + StringBuilder builder = new StringBuilder("SELECT "); + SqlUtils.appendColumns(builder, "T", getAllColumns()); + builder.append(','); + SqlUtils.appendColumns(builder, "T0", daoSession.getUserDao().getAllColumns()); + builder.append(" FROM TR_APPLICATION_LOG T"); + builder.append(" LEFT JOIN MS_USER T0 ON T.\"UUID_USER\"=T0.\"UUID_USER\""); + builder.append(' '); + selectDeep = builder.toString(); + } + return selectDeep; + } + + protected Logger loadCurrentDeep(Cursor cursor, boolean lock) { + Logger entity = loadCurrent(cursor, 0, lock); + int offset = getAllColumns().length; + + User user = loadCurrentOther(daoSession.getUserDao(), cursor, offset); + entity.setUser(user); + + return entity; + } + + public Logger loadDeep(Long key) { + assertSinglePk(); + if (key == null) { + return null; + } + + StringBuilder builder = new StringBuilder(getSelectDeep()); + builder.append("WHERE "); + SqlUtils.appendColumnsEqValue(builder, "T", getPkColumns()); + String sql = builder.toString(); + + String[] keyArray = new String[] { key.toString() }; + Cursor cursor = db.rawQuery(sql, keyArray); + + try { + boolean available = cursor.moveToFirst(); + if (!available) { + return null; + } else if (!cursor.isLast()) { + throw new IllegalStateException("Expected unique result, but count was " + cursor.getCount()); + } + return loadCurrentDeep(cursor, true); + } finally { + cursor.close(); + } + } + + /** Reads all available rows from the given cursor and returns a list of new ImageTO objects. */ + public List loadAllDeepFromCursor(Cursor cursor) { + int count = cursor.getCount(); + List list = new ArrayList(count); + + if (cursor.moveToFirst()) { + if (identityScope != null) { + identityScope.lock(); + identityScope.reserveRoom(count); + } + try { + do { + list.add(loadCurrentDeep(cursor, false)); + } while (cursor.moveToNext()); + } finally { + if (identityScope != null) { + identityScope.unlock(); + } + } + } + return list; + } + + protected List loadDeepAllAndCloseCursor(Cursor cursor) { + try { + return loadAllDeepFromCursor(cursor); + } finally { + cursor.close(); + } + } + + + /** A raw-style query where you can pass any WHERE clause and arguments. */ + public List queryDeep(String where, String... selectionArg) { + Cursor cursor = db.rawQuery(getSelectDeep() + where, selectionArg); + return loadDeepAllAndCloseCursor(cursor); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3b3cc91e6955a373ef11e9794cb26ecc868d9d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3b3cc91e6955a373ef11e9794cb26ecc868d9d.svn-base new file mode 100644 index 0000000..fdf6c14 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e3b3cc91e6955a373ef11e9794cb26ecc868d9d.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e414177587e69b40776eff699f80d747f925cfc.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e414177587e69b40776eff699f80d747f925cfc.svn-base new file mode 100644 index 0000000..528121b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e414177587e69b40776eff699f80d747f925cfc.svn-base @@ -0,0 +1,16 @@ +package com.adins.mss.base.dynamicform; + +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +public class JsonResponseTextOnline extends MssResponseType { + @SerializedName("value") private String answer; + + public String getAnswer() { + return answer; + } + + public void setAnswer(String answer) { + this.answer = answer; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e561f41d33f9deb88dbe522ee4117206a398402.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e561f41d33f9deb88dbe522ee4117206a398402.svn-base new file mode 100644 index 0000000..b308a02 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e561f41d33f9deb88dbe522ee4117206a398402.svn-base @@ -0,0 +1,7 @@ +package com.adins.mss.base.todolist.todayplanrepository; + +import com.adins.mss.foundation.http.MssResponseType; + +public class ResponseChangePlan extends MssResponseType { + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e6de0af1570116e277cfdbe804b4655ce4ade65.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e6de0af1570116e277cfdbe804b4655ce4ade65.svn-base new file mode 100644 index 0000000..d2dbfc4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/0e/0e6de0af1570116e277cfdbe804b4655ce4ade65.svn-base @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/1962f35b03bea5a212e41b257a9463bd92b7cc68.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/1962f35b03bea5a212e41b257a9463bd92b7cc68.svn-base new file mode 100644 index 0000000..036a342 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/1962f35b03bea5a212e41b257a9463bd92b7cc68.svn-base @@ -0,0 +1,32 @@ +/* + * Copyright 2013, Edmodo, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with the License. + * You may obtain a copy of the License in the LICENSE file, or at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" + * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language + * governing permissions and limitations under the License. + */ + +package com.edmodo.cropper.cropwindow.edge; + +/** + * Simple class to hold a pair of Edges. + */ +public class EdgePair { + + // Member Variables //////////////////////////////////////////////////////// + + public Edge primary; + public Edge secondary; + + // Constructor ///////////////////////////////////////////////////////////// + + public EdgePair(Edge edge1, Edge edge2) { + primary = edge1; + secondary = edge2; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/196d0ee7e322d5b21fb47395020a8f6f7e7fa785.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/196d0ee7e322d5b21fb47395020a8f6f7e7fa785.svn-base new file mode 100644 index 0000000..1fd5d9b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/19/196d0ee7e322d5b21fb47395020a8f6f7e7fa785.svn-base @@ -0,0 +1,134 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22bdac3f785c392e755228912d1b870ae796ad80.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22bdac3f785c392e755228912d1b870ae796ad80.svn-base new file mode 100644 index 0000000..1a8b19a --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22bdac3f785c392e755228912d1b870ae796ad80.svn-base @@ -0,0 +1,46 @@ +package com.adins.mss.svy.reassignment; + +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import com.adins.mss.constant.Global; + +import org.acra.ACRA; + +public class OrderReassignmentActivity extends CheckOrderActivity{ + private int taskType; + private Bundle mArguments; + @Override + public void onAttach(Context activity) { + super.onAttach(activity); + setHasOptionsMenu(false); + ACRA.getErrorReporter().putCustomData("LAST_CLASS_ACCESSED", getClass().getSimpleName()); + mArguments = getArguments(); + taskType = mArguments.getInt(Global.BUND_KEY_TASK_TYPE, 0); + } + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + super.onCreateView(inflater, container, savedInstanceState); + return view; + } + + @Override + protected Intent getNextActivityIntent() { + // TODO Auto-generated method stub + super.getNextActivityIntent(); + Intent fragment = new Intent(getActivity(), OrderReassignmentResult.class); + Bundle args = new Bundle(); + args.putString("startDate", txtStartDate.getText().toString()); + args.putString("endDate", txtEndDate.getText().toString()); + args.putString("nomorOrder", txtNomorOrder.getText().toString()); + args.putString("status", "1"); + fragment.putExtras(args); + return fragment; + } + + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22be6dacbc2b2cd8571d2812ac396ce154c8ca8f.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22be6dacbc2b2cd8571d2812ac396ce154c8ca8f.svn-base new file mode 100644 index 0000000..a192b0e Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22be6dacbc2b2cd8571d2812ac396ce154c8ca8f.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22e7bae98c9ecab68cafddeeb97f41632c0e57c0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22e7bae98c9ecab68cafddeeb97f41632c0e57c0.svn-base new file mode 100644 index 0000000..9270b15 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22e7bae98c9ecab68cafddeeb97f41632c0e57c0.svn-base @@ -0,0 +1,47 @@ +/* + * Copyright 2010 Kevin Gaudin + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.acra.sender; + +/** + * This exception is thrown when an error ocurred while sending crash data in a + * {@link ReportSender} implementation. + * + * @author Kevin Gaudin + */ +@SuppressWarnings("serial") +public class ReportSenderException extends Exception { + + /** + * Creates a new {@link ReportSenderException} instance. You can provide a + * detailed message to explain what went wrong. + * + * @param detailMessage A message to explain the cause of this exception. + * @param throwable An optional throwable which caused this Exception. + */ + public ReportSenderException(String detailMessage, Throwable throwable) { + super(detailMessage, throwable); + } + + /** + * Creates a new {@link ReportSenderException} instance. You can provide a + * detailed message to explain what went wrong. + * + * @param detailMessage A message to explain the cause of this exception. + **/ + public ReportSenderException(String detailMessage) { + super(detailMessage); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22f482b66fcc95e47b85665797c7f6846bf01b95.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22f482b66fcc95e47b85665797c7f6846bf01b95.svn-base new file mode 100644 index 0000000..3314912 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/22/22f482b66fcc95e47b85665797c7f6846bf01b95.svn-base @@ -0,0 +1,122 @@ +package com.adins.mss.foundation.db.dataaccess; + +import android.content.Context; + +import com.adins.mss.dao.DaoSession; +import com.adins.mss.dao.ReceiptHistory; +import com.adins.mss.dao.ReceiptHistoryDao; +import com.adins.mss.foundation.db.DaoOpenHelper; + +import java.util.List; + +import de.greenrobot.dao.query.QueryBuilder; + +public class ReceiptHistoryDataAccess { + + /** + * use to generate dao session that you can access modelDao + * + * @param context --> context from activity + * @return + */ + protected static DaoSession getDaoSession(Context context) { + return DaoOpenHelper.getDaoSession(context); + } + + /** + * get receiptHistory dao and you can access the DB + * + * @param context + * @return + */ + protected static ReceiptHistoryDao getReceiptHistoryDao(Context context) { + return getDaoSession(context).getReceiptHistoryDao(); + } + + /** + * Clear session, close db and set daoOpenHelper to null + */ + public static void closeAll() { + DaoOpenHelper.closeAll(); + } + + /** + * add collectionActivity as entity + * + * @param context + * @param ReceiptHistory + */ + public static void add(Context context, ReceiptHistory ReceiptHistory) { + getReceiptHistoryDao(context).insertInTx(ReceiptHistory); + getDaoSession(context).clear(); + } + + /** + * add collectionActivity as list entity + * + * @param context + * @param receiptHistoryList + */ + public static void add(Context context, List receiptHistoryList) { + getReceiptHistoryDao(context).insertInTx(receiptHistoryList); + getDaoSession(context).clear(); + } + + /** + * delete all content in table. + * + * @param context + */ + public static void clean(Context context) { + getReceiptHistoryDao(context).deleteAll(); + getDaoSession(context).clear(); + } + + /** + * @param context + * @param receiptHistory + */ + public static void delete(Context context, ReceiptHistory receiptHistory) { + getReceiptHistoryDao(context).delete(receiptHistory); + getDaoSession(context).clear(); + } + + public static void delete(Context context, String uuidTaskH) { + QueryBuilder qb = getReceiptHistoryDao(context).queryBuilder(); + qb.where(ReceiptHistoryDao.Properties.Uuid_task_h.eq(uuidTaskH)); + qb.build(); + if (qb.list().size() > 0) { + getReceiptHistoryDao(context).deleteInTx(qb.list()); + } + getDaoSession(context).clear(); + } + + /** + * @param context + * @param receiptHistory + */ + public static void update(Context context, ReceiptHistory receiptHistory) { + getReceiptHistoryDao(context).update(receiptHistory); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, ReceiptHistory receiptHistory) { + getReceiptHistoryDao(context).insertOrReplaceInTx(receiptHistory); + getDaoSession(context).clear(); + } + + public static void addOrReplace(Context context, List receiptHistories) { + getReceiptHistoryDao(context).insertOrReplaceInTx(receiptHistories); + getDaoSession(context).clear(); + } + + public static List getAllByTask(Context context, String uuidTaskH) { + QueryBuilder qb = getReceiptHistoryDao(context).queryBuilder(); + qb.where(ReceiptHistoryDao.Properties.Uuid_task_h.eq(uuidTaskH)); + qb.build(); + if (!qb.list().isEmpty()) + return qb.list(); + else return null; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23232aed54f3cbfe752b454e88416b08b4203462.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23232aed54f3cbfe752b454e88416b08b4203462.svn-base new file mode 100644 index 0000000..cd2edaf --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23232aed54f3cbfe752b454e88416b08b4203462.svn-base @@ -0,0 +1,104 @@ +package com.adins.mss.odr.opportunities; + +import android.content.Context; +import android.os.Bundle; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentActivity; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import com.adins.mss.base.util.Utility; +import com.adins.mss.dao.Account; +import com.adins.mss.dao.GroupTask; +import com.adins.mss.dao.Product; +import com.adins.mss.foundation.db.dataaccess.AccountDataAccess; +import com.adins.mss.foundation.db.dataaccess.GroupTaskDataAccess; +import com.adins.mss.odr.R; +import com.google.firebase.analytics.FirebaseAnalytics; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Created by muhammad.aap on 11/30/2018. + */ + +public class FragmentOpportunities extends Fragment { + private FragmentActivity activity; + private List productList; + private RecyclerView list; + private OpportunityMenuListAdapter adapter; + private List accountList; + private List uuidAccount; + private List groupTasks; + private FirebaseAnalytics screenName; + + private List>> listTaskHistory = new ArrayList<>(); + Map> oneListTaskHistory = new HashMap>(); + + @Override + public void onAttach(Context context) { + super.onAttach(context); + setHasOptionsMenu(true); + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + Utility.freeMemory(); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + screenName = FirebaseAnalytics.getInstance(getActivity()); + View view = inflater.inflate(R.layout.fragment_opportunities, container, false); + + list = (RecyclerView) view.findViewById(R.id.opportunityList); + list.setLayoutManager(new LinearLayoutManager(getActivity())); + list.setHasFixedSize(true); + + List listAcc = AccountDataAccess.getAll(getActivity()); + accountList=new ArrayList<>(); + if (listAcc != null){ + for(int i=0;i(); + for(int i=0;i + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/236dbf384465e107aae74eb9f33b08b7bfb305f8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/236dbf384465e107aae74eb9f33b08b7bfb305f8.svn-base new file mode 100644 index 0000000..757cdc6 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/236dbf384465e107aae74eb9f33b08b7bfb305f8.svn-base @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/2378a9d65fac4df33d35db535ddedb3b2dfb5c4d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/2378a9d65fac4df33d35db535ddedb3b2dfb5c4d.svn-base new file mode 100644 index 0000000..5fb5010 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/2378a9d65fac4df33d35db535ddedb3b2dfb5c4d.svn-base @@ -0,0 +1,10 @@ +package com.adins.mss.base.models; + +import com.adins.mss.foundation.http.MssResponseType; + +/** + * Created by adityapurwa on 30/03/15. + */ +public class ChangePasswordResponseModel extends MssResponseType { + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23b1fe54a2605df8be239d205df0fe71c7fcfdf7.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23b1fe54a2605df8be239d205df0fe71c7fcfdf7.svn-base new file mode 100644 index 0000000..e81af56 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23b1fe54a2605df8be239d205df0fe71c7fcfdf7.svn-base @@ -0,0 +1,343 @@ +package com.adins.mss.base.todolist.form; + +import android.app.ProgressDialog; +import android.content.Context; +import android.os.AsyncTask; +import android.os.Bundle; +import androidx.annotation.Keep; +import androidx.fragment.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.R; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.dynamicform.CustomerFragment; +import com.adins.mss.base.dynamicform.JsonRequestSubmitTask; +import com.adins.mss.base.dynamicform.JsonResponseSubmitTask; +import com.adins.mss.base.mainmenu.MainMenuActivity; +import com.adins.mss.base.timeline.TimelineManager; +import com.adins.mss.base.todolist.ToDoList; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.base.util.Utility; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.adins.mss.foundation.formatter.Formatter; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.http.HttpConnectionResult; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.androidquery.AQuery; +import com.github.jjobes.slidedatetimepicker.SlideDateTimeListener; +import com.github.jjobes.slidedatetimepicker.SlideDateTimePicker; +import com.google.firebase.perf.FirebasePerformance; +import com.google.firebase.perf.metrics.HttpMetric; + +import org.acra.ACRA; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.Date; + +public class RescheduleFragment extends Fragment { + public static final String TASK_RESCHEDULE = "TASK_RESCHEDULE"; + protected View view; + protected AQuery query; + private String taskID; + private String pts_date; + private SlideDateTimeListener listener = new SlideDateTimeListener() { + + @Override + public void onDateTimeSet(Date date) { + date.setSeconds(0); + SimpleDateFormat mFormatter = new SimpleDateFormat(Global.DATE_TIME_STR_FORMAT); + SimpleDateFormat gsonFormatter = new SimpleDateFormat(Global.DATE_STR_FORMAT_GSON); + String result = mFormatter.format(date); + pts_date = gsonFormatter.format(date); + query.id(R.id.txtDtm).text(result); + } + + // Optional cancel listener + @Override + public void onDateTimeCancel() { + //EMPTY + } + }; + + @Override + public void onAttach(Context activity) { + super.onAttach(activity); + setHasOptionsMenu(true); + ACRA.getErrorReporter().putCustomData("LAST_CLASS_ACCESSED", + getClass().getSimpleName()); + taskID = getArguments().getString("taskId"); + } + + @Override + public void onDestroyView() { + super.onDestroyView(); + Utility.freeMemory(); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + if (view != null) { + ViewGroup parent = (ViewGroup) view.getParent(); + if (parent != null) + parent.removeView(view); + } + try { + view = inflater.inflate(R.layout.reschedule_layout, container, + false); + query = new AQuery(view); + query.id(R.id.btnCancel).clicked(this, "cancel_Click"); + query.id(R.id.btnReschedule).clicked(this, "reschedule_Click"); + query.id(R.id.btnDtm).clicked(this, "dtm_Click"); + } catch (Exception e) { + FireCrash.log(e); + } + return view; + } + + @Keep + public void cancel_Click(View view) { + CustomerFragment.doBack(getActivity()); + } + + @Keep + public void reschedule_Click(View view) { + if (query.id(R.id.txtDtm).getText().toString().length() == 0) { + Toast.makeText(getActivity(), getActivity().getString(R.string.select_reschedule_time), + Toast.LENGTH_SHORT).show(); + } else { + Date dateSelected = null; + try { + dateSelected = Formatter.parseDate2(pts_date, Global.DATE_STR_FORMAT_GSON); + } catch (ParseException e) { + e.printStackTrace(); + } + Date nowtime = Tool.getSystemDate(); + Calendar cal = Calendar.getInstance(); + cal.setTime(nowtime); + cal.add(Calendar.DATE, 1); + nowtime = cal.getTime(); + if (dateSelected != null && dateSelected.before(nowtime)) { + Toast.makeText(getActivity(), getActivity().getString(R.string.date_after_today), + Toast.LENGTH_SHORT).show(); + } else { + new SubmitRescheduleTask().execute(taskID, pts_date); + } + } + } + + @Keep + public void dtm_Click(View view) { + showDateTimePicker(); + } + + public void showDateTimePicker() { + Date nowtime = Tool.getSystemDate(); + Calendar cal = Calendar.getInstance(); + cal.setTime(nowtime); + cal.add(Calendar.DATE, 1); + nowtime = cal.getTime(); + new SlideDateTimePicker.Builder(getActivity().getSupportFragmentManager()) + .setListener(listener) + .setInitialDate(new Date()) + .setMinDate(nowtime) + .setIs24HourTime(true) + .build() + .show(); + } + + private class SubmitRescheduleTask extends AsyncTask { + String taskId; + TaskH taskH; + String size; + String sec; + String ptsDate; + private ProgressDialog progressDialog; + private String errMessage; + + @Override + protected String doInBackground(String... params) { + String result = null; + if (Tool.isInternetconnected(getActivity())) { + try { + taskId = params[0]; + ptsDate = params[1]; + taskH = TaskHDataAccess.getOneTaskHeader(getActivity(), taskID); + SimpleDateFormat formatter = new SimpleDateFormat(Global.DATE_STR_FORMAT_GSON); + Date date = null; + try { + date = formatter.parse(ptsDate); + } catch (ParseException e1) { + e1.printStackTrace(); + } + taskH.setPts_date(date); + String uuidScheme = taskH.getUuid_scheme(); + String uuidUser = taskH.getUuid_user(); + TaskH h = TaskHDataAccess.getOneTaskHeader(getActivity(), taskId); + h.setUser(null); + h.setScheme(null); + h.setUuid_user(uuidUser); + h.setUuid_scheme(uuidScheme); + + h.setSubmit_date(Tool.getSystemDateTime()); + + JsonRequestSubmitTask task = new JsonRequestSubmitTask(); + task.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + task.addImeiAndroidIdToUnstructured(); + task.setTaskH(h); + task.setTaskD(null); + + String json = GsonHelper.toJson(task); + String url = GlobalData.getSharedGlobalData().getURL_SUBMIT_RESCHEDULE(); + + size = String.valueOf(json.getBytes().length); + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + HttpCryptedConnection httpConn = new HttpCryptedConnection(getActivity(), encrypt, decrypt); + HttpConnectionResult serverResult = null; + Date startTime = Tool.getSystemDateTime(); + + //Firebase Performance Trace HTTP Request + HttpMetric networkMetric = + FirebasePerformance.getInstance().newHttpMetric(url, FirebasePerformance.HttpMethod.POST); + Utility.metricStart(networkMetric, json); + + try { + serverResult = httpConn.requestToServer(url, json, + Global.DEFAULTCONNECTIONTIMEOUT); + Utility.metricStop(networkMetric, serverResult); + } catch (Exception e) { + FireCrash.log(e); + if (Global.IS_DEV) { + e.printStackTrace(); + } + } + if(serverResult == null){ + getActivity().getString(R.string.request_error); + return null; + } + + if (serverResult.isOK()) { + String resultvalue = serverResult.getResult(); + JsonResponseSubmitTask responseSubmitTask = GsonHelper.fromJson( + resultvalue, JsonResponseSubmitTask.class); + if (responseSubmitTask.getStatus().getCode() == 0) { + String status = responseSubmitTask.getResult(); + Date finishTime = Tool.getSystemDateTime(); + long time = finishTime.getTime() - startTime.getTime(); + sec = String.valueOf((int) Math.ceil((double)time / 1000)); + if (status == null) + status = "Success"; + if (status.equalsIgnoreCase("Success")) { + result = status; + if (responseSubmitTask.getTaskId() != null) + taskId = responseSubmitTask.getTaskId(); + } else { + result = status; + } + } else { + if (Global.IS_DEV) { + if (responseSubmitTask.getStatus().getMessage() == null) + System.out.println("AutoSendTaskThread server code :" + + responseSubmitTask.getStatus().getCode()); + else + System.out.println("AutoSendTaskThread server code :" + + responseSubmitTask.getStatus().getCode() + + ":" + + responseSubmitTask.getStatus().getCode()); + } + result = String.valueOf(responseSubmitTask.getStatus() + .getCode()); + } + } + } catch (Exception e) { + FireCrash.log(e); + + errMessage = "Rescheduling task " + + taskH.getCustomer_name() + " " + getActivity().getString(R.string.failed); + } + } else { + errMessage = getString(R.string.no_internet_connection); + } + + return result; + } + + @Override + protected void onPostExecute(String result) { + if (progressDialog.isShowing()) { + try { + progressDialog.dismiss(); + } catch (Exception e) { + FireCrash.log(e); + } + } + if (errMessage != null) { + Toast.makeText(getActivity(), errMessage, Toast.LENGTH_SHORT).show(); + } else { + if (result != null && result.equalsIgnoreCase("Success")) { + if (taskId != null && taskId.length() > 0 + && !taskId.contains("~")) { + + taskH.setStatus(TaskHDataAccess.STATUS_SEND_SENT); + ToDoList.removeSurveyFromList(taskId); + + taskH.setSubmit_date(Tool.getSystemDateTime()); + taskH.setSubmit_duration(sec); + taskH.setSubmit_size(size); + taskH.setSubmit_result(result); + taskH.setTask_id(taskId); + taskH.setLast_saved_question(1); + taskH.setIs_prepocessed(RescheduleFragment.TASK_RESCHEDULE); + TaskHDataAccess.addOrReplace(getActivity(), taskH); + + TaskHDataAccess.doBackup(getActivity(), taskH); + + TimelineManager.insertTimeline(getActivity(), taskH); + } + } else { + String txtResult = getActivity().getString(R.string.reschedule_failed, taskH.getCustomer_name()); + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder + .getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.warning_capital)).withMessage(txtResult) + .withButton1Text(getActivity().getString(R.string.btnClose)) + .setButton1Click(new OnClickListener() { + + @Override + public void onClick(View paramView) { + dialogBuilder.dismiss(); + CustomerFragment.doBack(getActivity()); + } + }).isCancelable(true).show(); + } + try { + MainMenuActivity.setDrawerCounter(); + } catch (Exception e) { + FireCrash.log(e); + } + } + + } + + @Override + protected void onPreExecute() { + progressDialog = ProgressDialog.show(getActivity(), "", + getActivity().getString(R.string.sending_reschedule_progress), true); + } + + @Override + protected void onProgressUpdate(Void... values) { + //EMPTY + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23e9b8b9ebe6b9496102c12c7ca5180c89008322.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23e9b8b9ebe6b9496102c12c7ca5180c89008322.svn-base new file mode 100644 index 0000000..cce4edd --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/23/23e9b8b9ebe6b9496102c12c7ca5180c89008322.svn-base @@ -0,0 +1,112 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24035c75321e58b5467da2d7813036243eec261c.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24035c75321e58b5467da2d7813036243eec261c.svn-base new file mode 100644 index 0000000..845ecb2 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24035c75321e58b5467da2d7813036243eec261c.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24185b6e2b09d7946e686428c40f4eabecddcbb4.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24185b6e2b09d7946e686428c40f4eabecddcbb4.svn-base new file mode 100644 index 0000000..1151e3f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24185b6e2b09d7946e686428c40f4eabecddcbb4.svn-base @@ -0,0 +1,20 @@ +package com.adins.mss.coll.models; + +import com.adins.mss.coll.models.loyaltymodels.DocumentListDetail; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +public class DocumentListResponse extends MssResponseType { + @SerializedName("listGuideline") + private List documentList; + + public List getDocumentList() { + return documentList; + } + + public void setDocumentList(List documentList) { + this.documentList = documentList; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24271bd8e3f8bedaf7147320dfb6716f87c84740.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24271bd8e3f8bedaf7147320dfb6716f87c84740.svn-base new file mode 100644 index 0000000..5d383f4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24271bd8e3f8bedaf7147320dfb6716f87c84740.svn-base @@ -0,0 +1,34 @@ +/*** + * Excerpted from "Hello, Android", + * published by The Pragmatic Bookshelf. + * Copyrights apply to this code. It may not be used to create training material, + * courses, books, articles, and the like. Contact us if you are in doubt. + * We make no guarantees that this code is fit for any purpose. + * Visit http://www.pragmaticprogrammer.com/titles/eband3 for more book information. + ***/ +package com.adins.mss.foundation.image; + +import android.view.MotionEvent; + +public class EclairMotionEvent extends WrapMotionEvent { + + protected EclairMotionEvent(MotionEvent event) { + super(event); + } + + public float getX(int pointerIndex) { + return event.getX(pointerIndex); + } + + public float getY(int pointerIndex) { + return event.getY(pointerIndex); + } + + public int getPointerCount() { + return event.getPointerCount(); + } + + public int getPointerId(int pointerIndex) { + return event.getPointerId(pointerIndex); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24342c3790f5ed432101e5bb908ff3f34d09c59d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24342c3790f5ed432101e5bb908ff3f34d09c59d.svn-base new file mode 100644 index 0000000..10957e2 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24342c3790f5ed432101e5bb908ff3f34d09c59d.svn-base @@ -0,0 +1,910 @@ +package com.adins.mss.foundation.UserHelp; + +import android.app.Activity; +import android.app.ProgressDialog; +import android.content.Context; +import android.graphics.Color; +import android.os.AsyncTask; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentManager; +import androidx.recyclerview.widget.RecyclerView; +import android.view.View; +import android.widget.ListView; +import android.widget.Toast; + + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.R; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.depositreport.GetImageTask; +import com.adins.mss.base.util.Utility; +import com.adins.mss.constant.Global; +import com.adins.mss.foundation.UserHelp.Bean.Dummy.UserHelpGuideDummy; +import com.adins.mss.foundation.UserHelp.Bean.Dummy.UserHelpIconDummy; +import com.adins.mss.foundation.UserHelp.Bean.Dummy.UserHelpViewDummy; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpBean; +import com.adins.mss.foundation.UserHelp.Bean.Dummy.UserHelpPropertiesDummy; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpGuide; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpProperties; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpView; +import com.adins.mss.foundation.security.storepreferences.ObscuredSharedPreferences; +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import uk.co.deanwild.materialshowcaseview.MaterialShowcaseSequence; +import uk.co.deanwild.materialshowcaseview.MaterialShowcaseView; +import uk.co.deanwild.materialshowcaseview.ShowcaseConfig; + +import static com.adins.mss.constant.Global.activeUserHelpGuide; +import static com.adins.mss.constant.Global.user; +import static com.adins.mss.constant.Global.userHelpDummyGuide; +import static com.adins.mss.constant.Global.userHelpGuide; + + +public class UserHelp { + private static int viewCounter = 0; + private static int counter = 0; + public static boolean isActive = false; + + private static final String TOOLTIP = "TOOLTIP"; + private static final String TOOLTIP_DUMMY = "TOOLTIP_DUMMY"; + private static final String LAST_TOOLTIP = "LAST_TOOLTIP"; + private static final String GLOBAL_DATA = "GlobalData"; + + public static void showUserHelp(Activity activity, View id, String text){ + Global.BACKPRESS_RESTRICTION = true; + new MaterialShowcaseView.Builder(activity) + .setTarget(id) + .setDismissText(activity.getApplicationContext().getString(R.string.btnOk)) + .setContentText(text) + .setDismissBackground(R.drawable.button_background) + .setMaskColour(Color.parseColor("#dd000000")) + .withRectangleShape() + .setSkipText("") + .show(); + } + public static void showAllUserHelp(Activity activity, String idSequence) { + if(Global.ENABLE_USER_HELP) { + ArrayList tempTooltip = new ArrayList<>(); + ShowcaseConfig config = new ShowcaseConfig(); + config.setDelay(0); + config.setFadeDuration(100); + + MaterialShowcaseSequence sequence = new MaterialShowcaseSequence(activity); + sequence.setConfig(config); + try { + Global.BACKPRESS_RESTRICTION = true; + if(!isActive) { + counter = 0; + viewCounter = 0; + isActive = true; + for (UserHelpView userHelpView : userHelpGuide.get(idSequence)) { + int viewId = Utility.getViewById(activity, userHelpView.getViewid()); + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + if (!userHelpProperties.isRecycled()) { + if (viewId == R.id.customer_fragment_form && GlobalData.getSharedGlobalData().getApplication().equals(Global.APPLICATION_COLLECTION)) { + continue; + } + try { + final View layout = activity.findViewById(viewId); + addSequenceUserHelp(activity, sequence, userHelpView, layout, tempTooltip); + } catch (Exception ex) { + ex.printStackTrace(); + tempTooltip.add(userHelpView); + } + } + } + } + } catch (Exception ex) { + FireCrash.log(ex); + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + return; + } + if(counter>0) + Global.BACKPRESS_RESTRICTION = true; + else { + isActive = false; + Global.BACKPRESS_RESTRICTION = false; + } + userHelpGuide.put(idSequence, tempTooltip); + try { + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(activity.getApplicationContext(), GLOBAL_DATA, Context.MODE_PRIVATE); + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(LAST_TOOLTIP, gson.toJson(userHelpGuide)).apply(); + } catch (Exception e) { + } + sequence.start(); + } + } + + public static void showAllUserHelp(Activity activity, String idSequence,OnShowSequenceFinish finishCallback) { + if(Global.ENABLE_USER_HELP) { + ArrayList tempTooltip = new ArrayList<>(); + ShowcaseConfig config = new ShowcaseConfig(); + config.setDelay(0); + config.setFadeDuration(100); + + MaterialShowcaseSequence sequence = new MaterialShowcaseSequence(activity); + sequence.setConfig(config); + try { + Global.BACKPRESS_RESTRICTION = true; + if(!isActive) { + counter = 0; + viewCounter = 0; + isActive = true; + activeUserHelpGuide = userHelpGuide.get(idSequence); + for (UserHelpView userHelpView : activeUserHelpGuide) { + int viewId = Utility.getViewById(activity, userHelpView.getViewid()); + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + if (!userHelpProperties.isRecycled()) { + if (viewId == R.id.customer_fragment_form && GlobalData.getSharedGlobalData().getApplication().equals(Global.APPLICATION_COLLECTION)) { + continue; + } + try { + final View layout = activity.findViewById(viewId); + addSequenceUserHelp(activity, sequence, userHelpView, layout, tempTooltip,null, finishCallback); + } catch (Exception ex) { + ex.printStackTrace(); + tempTooltip.add(userHelpView); + } + } + } + } + } catch (Exception ex) { + FireCrash.log(ex); + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + return; + } + if(counter>0) + Global.BACKPRESS_RESTRICTION = true; + else { + isActive = false; + Global.BACKPRESS_RESTRICTION = false; + } + userHelpGuide.put(idSequence, tempTooltip); + try { + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(activity.getApplicationContext(), GLOBAL_DATA, Context.MODE_PRIVATE); + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(LAST_TOOLTIP, gson.toJson(userHelpGuide)).apply(); + } catch (Exception e) { + } + sequence.start(); + } + } + + public static void showAllUserHelp(Activity activity, String idSequence,RecyclerView recyclerView + ,OnSequenceShowed showCallback,OnShowSequenceFinish finishCallback) { + if(Global.ENABLE_USER_HELP) { + ArrayList tempTooltip = new ArrayList<>(); + ShowcaseConfig config = new ShowcaseConfig(); + config.setDelay(0); + config.setFadeDuration(100); + + MaterialShowcaseSequence sequence = new MaterialShowcaseSequence(activity); + sequence.setConfig(config); + try { + Global.BACKPRESS_RESTRICTION = true; + if(!isActive) { + counter = 0; + viewCounter = 0; + isActive = true; + activeUserHelpGuide = userHelpGuide.get(idSequence); + for (UserHelpView userHelpView : activeUserHelpGuide) { + int viewId = Utility.getViewById(activity, userHelpView.getViewid()); + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + View layout = null; + if (!userHelpProperties.isRecycled()) { + if (viewId == R.id.customer_fragment_form && GlobalData.getSharedGlobalData().getApplication().equals(Global.APPLICATION_COLLECTION)) { + continue; + } + try { + layout = activity.findViewById(viewId); + } catch (Exception ex) { + ex.printStackTrace(); + tempTooltip.add(userHelpView); + } + } + else { + if(recyclerView == null) + continue; + + RecyclerView.ViewHolder viewHolder = recyclerView.findViewHolderForLayoutPosition(userHelpProperties.getViewHolderPos()); + if(viewHolder != null){ + layout = viewHolder.itemView.findViewById(viewId); + } + } + + if(layout == null) + continue; + + addSequenceUserHelp(activity ,sequence, userHelpView + , layout, tempTooltip, showCallback, finishCallback); + } + } + } catch (Exception ex) { + FireCrash.log(ex); + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + activeUserHelpGuide.clear(); + return; + } + if(counter>0) + Global.BACKPRESS_RESTRICTION = true; + else { + isActive = false; + activeUserHelpGuide.clear(); + Global.BACKPRESS_RESTRICTION = false; + } + userHelpGuide.put(idSequence, tempTooltip); + try { + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(activity.getApplicationContext(), GLOBAL_DATA, Context.MODE_PRIVATE); + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(LAST_TOOLTIP, gson.toJson(userHelpGuide)).apply(); + } catch (Exception e) { + } + sequence.start(); + } + } + + public static void showAllUserHelpWithRecycler(Activity activity, String idSequence, RecyclerView recyclerView, int position) { + if(Global.ENABLE_USER_HELP) { + ArrayList tempTooltip = new ArrayList<>(); + ShowcaseConfig config = new ShowcaseConfig(); + config.setDelay(0); + config.setFadeDuration(100); + + MaterialShowcaseSequence sequence = new MaterialShowcaseSequence(activity); + sequence.setConfig(config); + try { + Global.BACKPRESS_RESTRICTION = true; + if(!isActive) { + counter = 0; + viewCounter = 0; + isActive = true; + for (UserHelpView userHelpView : userHelpGuide.get(idSequence)) { + int viewId = Utility.getViewById(activity, userHelpView.getViewid()); + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + View layout; + if (!userHelpProperties.isRecycled()) { + layout = activity.findViewById(viewId); + } else { + if (recyclerView.findViewHolderForLayoutPosition(position) != null) { + layout = recyclerView.findViewHolderForLayoutPosition(position).itemView.findViewById(viewId); + recyclerView.smoothScrollToPosition(position); + } else { + tempTooltip.add(userHelpView); + continue; + } + } + addSequenceUserHelp(activity, sequence, userHelpView, layout, tempTooltip); + } + } + } catch (Exception ex) { + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + FireCrash.log(ex); + } + if(counter>0) + Global.BACKPRESS_RESTRICTION = true; + else { + isActive = false; + Global.BACKPRESS_RESTRICTION = false; + } + userHelpGuide.put(idSequence, tempTooltip); + + try { + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(activity.getApplicationContext(), GLOBAL_DATA, Context.MODE_PRIVATE); + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(LAST_TOOLTIP, gson.toJson(userHelpGuide)).apply(); + } catch (Exception e) { + } + sequence.start(); + } + } + + public static void showAllUserHelpWithListView(Activity activity, String idSequence, ListView listView, int position) { + if(Global.ENABLE_USER_HELP) { + ArrayList tempTooltip = new ArrayList<>(); + ShowcaseConfig config = new ShowcaseConfig(); + config.setDelay(0); + config.setFadeDuration(100); + + MaterialShowcaseSequence sequence = new MaterialShowcaseSequence(activity); + sequence.setConfig(config); + try { + Global.BACKPRESS_RESTRICTION = true; + if(!isActive) { + counter = 0; + viewCounter = 0; + isActive = true; + for (UserHelpView userHelpView : userHelpGuide.get(idSequence)) { + int viewId = Utility.getViewById(activity, userHelpView.getViewid()); + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + View layout; + if (!userHelpProperties.isRecycled()) { + layout = activity.findViewById(viewId); + } else { + if (listView.getChildAt(position) != null) + layout = listView.getChildAt(position).findViewById(viewId); + else { + tempTooltip.add(userHelpView); + continue; + } + } + addSequenceUserHelp(activity, sequence, userHelpView, layout, tempTooltip); + } + } + }catch (Exception e){ + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + e.printStackTrace(); + } + if(counter>0) + Global.BACKPRESS_RESTRICTION = true; + else { + isActive = false; + Global.BACKPRESS_RESTRICTION = false; + } + userHelpGuide.put(idSequence, tempTooltip); + try { + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(activity.getApplicationContext(), GLOBAL_DATA, Context.MODE_PRIVATE); + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(LAST_TOOLTIP, gson.toJson(userHelpGuide)).apply(); + } catch (Exception e) { + } + sequence.start(); + } + } + + public static void addSequenceUserHelp(final Activity activity, final MaterialShowcaseSequence sequence, + UserHelpView userHelpView, final View layout, ArrayList tempTooltip){ + if(Global.ENABLE_USER_HELP) { + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + try { + if (layout.getVisibility() == View.VISIBLE) { + counter++; + if (!userHelpProperties.isSquare()) + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setMaskColour(Color.parseColor("#dd000000")) + .setSkipText("SKIP >") + .build()); + else { + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setMaskColour(Color.parseColor("#dd000000")) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setSkipText("SKIP >") + .withRectangleShape() + .build()); + } + } else { + tempTooltip.add(userHelpView); + } + sequence.setOnItemDismissedListener(new MaterialShowcaseSequence.OnSequenceItemDismissedListener() { + @Override + public void onDismiss(MaterialShowcaseView materialShowcaseView, int i) { + viewCounter++; + if(viewCounter >= counter){ + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + } + } + }); + sequence.setOnItemSkippedListener(new MaterialShowcaseSequence.OnSequenceItemSkippedListener() { + @Override + public void onSkip() { + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + } + }); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + Global.BACKPRESS_RESTRICTION = false; + tempTooltip.add(userHelpView); + } + } + } + + public interface OnShowSequenceFinish{ + void onSequenceFinish(); + } + + public interface OnSequenceShowed{ + void onSequenceShowed(String prevUserHelp,String currentShowUserHelp,int index); + } + + public static void addSequenceUserHelp(final Activity activity, final MaterialShowcaseSequence sequence, + final UserHelpView userHelpView, final View layout, ArrayList tempTooltip + , final OnSequenceShowed showCallback, final OnShowSequenceFinish finishCallback){ + if(Global.ENABLE_USER_HELP) { + UserHelpProperties userHelpProperties = userHelpView.getProperties(); + try { + counter++; + if (!userHelpProperties.isSquare()) + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setMaskColour(Color.parseColor("#dd000000")) + .setSkipText("SKIP >") + .build()); + else { + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setMaskColour(Color.parseColor("#dd000000")) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setSkipText("SKIP >") + .withRectangleShape() + .build()); + } + + sequence.setOnItemShownListener(new MaterialShowcaseSequence.OnSequenceItemShownListener() { + @Override + public void onShow(final MaterialShowcaseView materialShowcaseView, int i) { + if(showCallback == null) + return; + + UserHelpView currUserHelp = activeUserHelpGuide.get(viewCounter); + //get previous user help + int prevIndex = viewCounter - 1; + UserHelpView prevUserHelp = null; + if(prevIndex >= 0) + prevUserHelp = activeUserHelpGuide.get(prevIndex); + + if(prevUserHelp != null) + showCallback.onSequenceShowed(prevUserHelp.getViewid(),currUserHelp.getViewid(),prevIndex); + else + showCallback.onSequenceShowed(null,currUserHelp.getViewid(),prevIndex); + } + }); + + sequence.setOnItemDismissedListener(new MaterialShowcaseSequence.OnSequenceItemDismissedListener() { + @Override + public void onDismiss(MaterialShowcaseView materialShowcaseView, int i) { + viewCounter++; + if(viewCounter >= counter){ + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + activeUserHelpGuide.clear(); + if(finishCallback != null){ + finishCallback.onSequenceFinish(); + } + } + } + }); + sequence.setOnItemSkippedListener(new MaterialShowcaseSequence.OnSequenceItemSkippedListener() { + @Override + public void onSkip() { + Global.BACKPRESS_RESTRICTION = false; + isActive = false; + activeUserHelpGuide.clear(); + if(finishCallback != null){ + finishCallback.onSequenceFinish(); + } + } + }); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + activeUserHelpGuide.clear(); + Global.BACKPRESS_RESTRICTION = false; + tempTooltip.add(userHelpView); + } + } + } + + public static void addSequenceUserHelpDummy(Activity activity, MaterialShowcaseSequence sequence, + UserHelpIconDummy userHelpIconDummy,UserHelpViewDummy userHelpViewDummy, + View layout, ArrayList tempTooltip){ + Global.BACKPRESS_RESTRICTION = true; + viewCounter = 0; + if(Global.ENABLE_USER_HELP) { + UserHelpPropertiesDummy userHelpProperties = userHelpIconDummy.getProperties(); + try { + if (layout.getVisibility() == View.VISIBLE) { + if (!userHelpProperties.isSquare()) + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setMaskColour(Color.parseColor("#dd000000")) + .setSkipText("SKIP >") + .build()); + else { + sequence.addSequenceItem(new MaterialShowcaseView.Builder(activity) + .setTarget(layout) + .setDismissText("OK") + .setContentText(userHelpProperties.getText()) + .setMaskColour(Color.parseColor("#dd000000")) + .setDismissBackground(R.drawable.button_background) + .setSkipBackground(R.drawable.button_outline_background) + .setSkipText("SKIP >") + .withRectangleShape() + .build()); + } + } else { + tempTooltip.add(userHelpViewDummy); + } + + sequence.setOnItemSkippedListener(new MaterialShowcaseSequence.OnSequenceItemSkippedListener() { + @Override + public void onSkip() { + Global.BACKPRESS_RESTRICTION = false; + } + }); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + tempTooltip.add(userHelpViewDummy); + } + } + } + + public static void initializeUserHelp(Context context, String commonUserHelpUrl, String appUserHelpUrl){ + GetUserGuide getUserGuide = new GetUserGuide(context, commonUserHelpUrl, appUserHelpUrl); + + try { + getUserGuide.execute(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static void reloadUserHelp(Context context, FragmentManager fragmentManager){ + for(Fragment fragment: fragmentManager.getFragments()){ + String fragmentName = fragment.getClass().getSimpleName(); + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(context, GLOBAL_DATA, Context.MODE_PRIVATE); + String tooltipString = sharedPref.getString(TOOLTIP,null); + String tooltipDummyString = sharedPref.getString(TOOLTIP_DUMMY,null); + Gson gson = new Gson(); + + Map> tempTooltip; + Map> tempDummyTooltip; + java.lang.reflect.Type type = new TypeToken>>(){}.getType(); + java.lang.reflect.Type typeDummy = new TypeToken>>(){}.getType(); + tempTooltip = gson.fromJson(tooltipString,type); + tempDummyTooltip = gson.fromJson(tooltipDummyString,typeDummy); + + Global.userHelpGuide.put(fragmentName,tempTooltip.get(fragmentName)); + Global.userHelpDummyGuide.put(fragmentName,tempDummyTooltip.get(fragmentName)); + } + } + + public static void reloadUserHelp(Context context, Activity activity){ + String activityName = activity.getClass().getSimpleName(); + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(context, GLOBAL_DATA, Context.MODE_PRIVATE); + String tooltipString = sharedPref.getString(TOOLTIP,null); + String tooltipDummyString = sharedPref.getString(TOOLTIP_DUMMY,null); + Gson gson = new Gson(); + + Map> tempTooltip; + Map> tempDummyTooltip; + java.lang.reflect.Type type = new TypeToken>>(){}.getType(); + java.lang.reflect.Type typeDummy = new TypeToken>>(){}.getType(); + tempTooltip = gson.fromJson(tooltipString,type); + tempDummyTooltip = gson.fromJson(tooltipDummyString,typeDummy); + + Global.userHelpGuide.put(activityName,tempTooltip.get(activityName)); + Global.userHelpDummyGuide.put(activityName,tempDummyTooltip.get(activityName)); + } + + public static void reloadUserHelp(Context context, String sequenceId){ + ObscuredSharedPreferences sharedPref = + ObscuredSharedPreferences.getPrefs(context, GLOBAL_DATA, Context.MODE_PRIVATE); + String tooltipString = sharedPref.getString(TOOLTIP,null); + String tooltipDummyString = sharedPref.getString(TOOLTIP_DUMMY,null); + Gson gson = new Gson(); + + Map> tempTooltip; + Map> tempDummyTooltip; + java.lang.reflect.Type type = new TypeToken>>(){}.getType(); + java.lang.reflect.Type typeDummy = new TypeToken>>(){}.getType(); + tempTooltip = gson.fromJson(tooltipString,type); + tempDummyTooltip = gson.fromJson(tooltipDummyString,typeDummy); + + Global.userHelpGuide.put(sequenceId,tempTooltip.get(sequenceId)); + Global.userHelpDummyGuide.put(sequenceId,tempDummyTooltip.get(sequenceId)); + } + + public static class GetUserGuide extends AsyncTask { + private ProgressDialog pDialog; + private Activity activity; + Map> tempUserHelp = new LinkedHashMap<>(); + Map> tempUserHelpDummy = new LinkedHashMap<>(); + ObscuredSharedPreferences sharedPref; + String commonUserHelpUrl; + String appUserHelpUrl; + + public GetUserGuide(Context activity, String commonUserHelpUrl, String appUserHelpUrl) { + this.activity = (Activity) activity; + this.commonUserHelpUrl = commonUserHelpUrl; + this.appUserHelpUrl = appUserHelpUrl; + this.sharedPref = ObscuredSharedPreferences.getPrefs(activity, GLOBAL_DATA, Context.MODE_PRIVATE); + } + + @Override + protected void onPreExecute() { + super.onPreExecute(); + if (!activity.isFinishing() && !activity.isDestroyed()) { + pDialog = new ProgressDialog(activity); + pDialog.setMessage(activity.getString(R.string.updating_apk)); + pDialog.setIndeterminate(false); + pDialog.setMax(0); + pDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); + pDialog.setCancelable(false); + pDialog.show(); + } + } + + @Override + protected String doInBackground(Void... voids) { + HttpURLConnection httpConn = null; + String json = ""; + String[] name; + try { + URL url = new URL(commonUserHelpUrl); + name = url.getPath().split("/"); + httpConn = (HttpURLConnection) url.openConnection(); + int responseCode = httpConn.getResponseCode(); + + // always check HTTP response code first + if (responseCode == HttpURLConnection.HTTP_OK) { + InputStreamReader inputStreamReader = new InputStreamReader(httpConn.getInputStream()); + BufferedReader bufferedReader = new BufferedReader(inputStreamReader); + StringBuilder builder = new StringBuilder(); + String line; + while ((line = bufferedReader.readLine()) != null){ + builder.append(line); + } + bufferedReader.close(); + json = builder.toString(); + } + else { + return activity.getResources().getString(R.string.userhelp_download_error) + name[name.length - 1]; + } + + UserHelpBean userHelpBean = new Gson().fromJson(json, UserHelpBean.class); + for(UserHelpGuide userHelpGuide: userHelpBean.getGuide()){ + tempUserHelp.put(userHelpGuide.getActivity(), + (ArrayList) userHelpGuide.getView()); + } + + if(userHelpBean.getGuideDummy()!=null) { + for (UserHelpGuideDummy userHelpGuideDummy : userHelpBean.getGuideDummy()) { + tempUserHelpDummy.put(userHelpGuideDummy.getActivity(), + (ArrayList) userHelpGuideDummy.getView()); + } + } + + url = new URL(appUserHelpUrl); + httpConn = (HttpURLConnection) url.openConnection(); + responseCode = httpConn.getResponseCode(); + + // always check HTTP response code first + if (responseCode == HttpURLConnection.HTTP_OK) { + InputStreamReader inputStreamReader = new InputStreamReader(httpConn.getInputStream()); + BufferedReader bufferedReader = new BufferedReader(inputStreamReader); + StringBuilder builder = new StringBuilder(); + String line; + while ((line = bufferedReader.readLine()) != null){ + builder.append(line); + } + bufferedReader.close(); + json = builder.toString(); + } else { + return activity.getResources().getString(R.string.userhelp_download_error) + name[name.length - 1]; + } + + userHelpBean = new Gson().fromJson(json, UserHelpBean.class); + for(UserHelpGuide userHelpGuide: userHelpBean.getGuide()){ + ArrayList userHelpView = tempUserHelp.get(userHelpGuide.getActivity()); + if(userHelpView!=null){ + userHelpView.addAll(userHelpGuide.getView()); + tempUserHelp.put(userHelpGuide.getActivity(),userHelpView); + } else{ + tempUserHelp.put(userHelpGuide.getActivity(), + (ArrayList) userHelpGuide.getView()); + } + } + + if(userHelpBean.getGuideDummy()!=null) { + for (UserHelpGuideDummy userHelpGuideDummy : userHelpBean.getGuideDummy()) { + ArrayList userHelpViewDummies = tempUserHelpDummy.get(userHelpGuideDummy.getActivity()); + if(userHelpViewDummies!=null){ + userHelpViewDummies.addAll(userHelpGuideDummy.getView()); + tempUserHelpDummy.put(userHelpGuideDummy.getActivity(),userHelpViewDummies); + } else{ + tempUserHelpDummy.put(userHelpGuideDummy.getActivity(), + (ArrayList)userHelpGuideDummy.getView()); + } + } + } + } catch (Exception e) { + e.printStackTrace(); + if(httpConn != null) + httpConn.disconnect(); + return activity.getResources().getString(R.string.userhelp_exception); + } finally { + if(httpConn != null) + httpConn.disconnect(); + } + + return null; + } + + @Override + protected void onPostExecute(String error) { + super.onPostExecute(error); + try { + if (null != pDialog && pDialog.isShowing()) { + pDialog.dismiss(); + pDialog = null; + } + } catch (Exception e) { + FireCrash.log(e); + } + + if(error!=null){ + Toast.makeText(activity, error,Toast.LENGTH_SHORT).show(); + } else { + if(sharedPref.getString(LAST_TOOLTIP,null)!= null){ + Gson gson = new Gson(); + String tooltipString = sharedPref.getString(LAST_TOOLTIP,null); + Map> tempTooltip; + java.lang.reflect.Type type = new TypeToken>>(){}.getType(); + tempTooltip = gson.fromJson(tooltipString,type); + + Global.userHelpGuide = tempTooltip; + } + + if(sharedPref.getString("LAST_TOOLTIP_DUMMY",null)!= null){ + Gson gson = new Gson(); + String tooltipString = sharedPref.getString("LAST_TOOLTIP_DUMMY",null); + Map> tempTooltip; + java.lang.reflect.Type type = new TypeToken>>(){}.getType(); + tempTooltip = gson.fromJson(tooltipString,type); + userHelpDummyGuide = tempTooltip; + } + + if(sharedPref.getString(TOOLTIP, null) != null) { + for (Map.Entry> entry : tempUserHelp.entrySet()) { + if(null != entry.getValue() && !entry.getValue().isEmpty()) { + for (UserHelpView view : entry.getValue()) { + if (userHelpGuide.containsKey(entry.getKey())) { + UserHelpProperties properties = view.getProperties(); + if (userHelpGuide.get(entry.getKey()).contains(view)) { + userHelpGuide.get(entry.getKey()).get(userHelpGuide.get(entry.getKey()).indexOf(view)).setProperties(properties); + } + } + } + } + } + + for (Map.Entry> entry : tempUserHelp.entrySet()) { + if(null != entry.getValue() && !entry.getValue().isEmpty()) { + Collections.sort(entry.getValue(), new Comparator() { + @Override + public int compare(UserHelpView t1, UserHelpView t2) { + if (t1.getProperties().getSequence() > t2.getProperties().getSequence()) + return 1; + else if (t1.getProperties().getSequence() < t2.getProperties().getSequence()) + return -1; + return 0; + } + }); + } + } + + for (Map.Entry> entry : tempUserHelpDummy.entrySet()) { + if (null != entry.getValue() && !entry.getValue().isEmpty()) { + for (UserHelpViewDummy viewDummy : entry.getValue()) { + ArrayList needDelete = new ArrayList<>(); + for (UserHelpIconDummy iconDummy : viewDummy.getIconid()) { + if (userHelpDummyGuide.containsKey(entry.getKey())) { + UserHelpPropertiesDummy properties = iconDummy.getProperties(); + List icon = new ArrayList<>(); + if (userHelpDummyGuide.get(entry.getKey()).contains(viewDummy)) { + icon = userHelpDummyGuide.get(entry.getKey()) + .get(userHelpDummyGuide.get(entry.getKey()).indexOf(viewDummy)).getIconid(); + if (userHelpDummyGuide.get(entry.getKey()) + .get(userHelpDummyGuide.get(entry.getKey()).indexOf(viewDummy)).getIconid() + .contains(iconDummy)) { + icon.get(icon.indexOf(iconDummy)).setProperties(properties); + } + } + if (iconDummy.getProperties().getJobStatus() != null + && !iconDummy.getProperties().getJobStatus().equalsIgnoreCase(user.getFlag_job())) { + icon.remove(iconDummy); + needDelete.add(iconDummy); + } + } + } + viewDummy.getIconid().removeAll(needDelete); + } + } + } + } else { + for (Map.Entry> entry : tempUserHelpDummy.entrySet()) { + if(null != entry.getValue() && !entry.getValue().isEmpty()) { + for (UserHelpViewDummy viewDummy : entry.getValue()) { + ArrayList iconDelete = new ArrayList<>(); + for (UserHelpIconDummy iconDummy : viewDummy.getIconid()) { + if (iconDummy.getProperties().getJobStatus() != null + && !iconDummy.getProperties().getJobStatus().equalsIgnoreCase(user.getFlag_job())) { + iconDelete.add(iconDummy); + } + } + viewDummy.getIconid().removeAll(iconDelete); + } + } + } + + for (Map.Entry> entry : tempUserHelp.entrySet()) { + if(null != entry.getValue() && !entry.getValue().isEmpty()) { + Collections.sort(entry.getValue(), new Comparator() { + @Override + public int compare(UserHelpView t1, UserHelpView t2) { + if (t1.getProperties().getSequence() > t2.getProperties().getSequence()) + return 1; + else if (t1.getProperties().getSequence() < t2.getProperties().getSequence()) + return -1; + return 0; + } + }); + } + } + + userHelpGuide = tempUserHelp; + userHelpDummyGuide = tempUserHelpDummy; + } + + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + Gson gson = new Gson(); + sharedPrefEditor.putString(TOOLTIP, gson.toJson(tempUserHelp)).apply(); + sharedPrefEditor.putString(TOOLTIP_DUMMY, gson.toJson(tempUserHelpDummy)).apply(); + } + } + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249a5985108f27990b292fd7872afe7722423fe8.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249a5985108f27990b292fd7872afe7722423fe8.svn-base new file mode 100644 index 0000000..d44dc06 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249a5985108f27990b292fd7872afe7722423fe8.svn-base @@ -0,0 +1,22 @@ +package com.adins.mss.base.dynamicform; + +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +/** + * Created by noerhayati.dm on 8/2/2018. + */ + +public class JsonResponseDigitalReceipt extends MssResponseType { + + @SerializedName("rvNumberMobile") + private String rvNumberMobile; + + public String getRvNumberMobile() { + return rvNumberMobile; + } + + public void setRvNumberMobile(String rvNumberMobile) { + this.rvNumberMobile = rvNumberMobile; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249fd07bb5b5e67678e62f5be85f8b3192ef813f.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249fd07bb5b5e67678e62f5be85f8b3192ef813f.svn-base new file mode 100644 index 0000000..60f5194 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/249fd07bb5b5e67678e62f5be85f8b3192ef813f.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24ca16253c23351d4f79d2b2ee488c6583872ca6.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24ca16253c23351d4f79d2b2ee488c6583872ca6.svn-base new file mode 100644 index 0000000..f52f00e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24ca16253c23351d4f79d2b2ee488c6583872ca6.svn-base @@ -0,0 +1,15 @@ +package com.adins.mss.base; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +/** + * To work on unit tests, switch the Test Artifact in the Build Variants view. + */ +public class ExampleUnitTest { + @Test + public void addition_isCorrect() throws Exception { + assertEquals(4, 2 + 2); + } +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24d9bbffe32ad7e82efcdcb325b765ec1010593c.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24d9bbffe32ad7e82efcdcb325b765ec1010593c.svn-base new file mode 100644 index 0000000..c9e87a6 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24d9bbffe32ad7e82efcdcb325b765ec1010593c.svn-base @@ -0,0 +1,180 @@ +package com.adins.mss.dao; + +import com.adins.mss.base.util.ExcludeFromGson; +import com.google.gson.annotations.SerializedName; + +// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. Enable "keep" sections if you want to edit. +/** + * Entity mapped to table "MS_PRODUCT". + */ +public class Product { + + /** Not-null value. */ + @SerializedName("uuid_product") + private String uuid_product; + @SerializedName("product_code") + private String product_code; + @SerializedName("product_name") + private String product_name; + @SerializedName("product_desc") + private String product_desc; + @SerializedName("product_value") + private Integer product_value; + @SerializedName("product_inctv_prctg") + private Integer product_inctv_prctg; + @SerializedName("lob_image") + private byte[] lob_image; + @SerializedName("usr_crt") + private String usr_crt; + @SerializedName("dtm_crt") + private java.util.Date dtm_crt; + @SerializedName("is_active") + private String is_active; + @SerializedName("brand") + private String brand; + @SerializedName("type") + private String type; + @SerializedName("model") + private String model; + @SerializedName("product_file") + private String product_file; + + public Product() { + } + + public Product(String uuid_product) { + this.uuid_product = uuid_product; + } + + public Product(String uuid_product, String product_code, String product_name, String product_desc, Integer product_value, Integer product_inctv_prctg, byte[] lob_image, String usr_crt, java.util.Date dtm_crt, String is_active, String brand, String type, String model, String product_file) { + this.uuid_product = uuid_product; + this.product_code = product_code; + this.product_name = product_name; + this.product_desc = product_desc; + this.product_value = product_value; + this.product_inctv_prctg = product_inctv_prctg; + this.lob_image = lob_image; + this.usr_crt = usr_crt; + this.dtm_crt = dtm_crt; + this.is_active = is_active; + this.brand = brand; + this.type = type; + this.model = model; + this.product_file = product_file; + } + + /** Not-null value. */ + public String getUuid_product() { + return uuid_product; + } + + /** Not-null value; ensure this value is available before it is saved to the database. */ + public void setUuid_product(String uuid_product) { + this.uuid_product = uuid_product; + } + + public String getProduct_code() { + return product_code; + } + + public void setProduct_code(String product_code) { + this.product_code = product_code; + } + + public String getProduct_name() { + return product_name; + } + + public void setProduct_name(String product_name) { + this.product_name = product_name; + } + + public String getProduct_desc() { + return product_desc; + } + + public void setProduct_desc(String product_desc) { + this.product_desc = product_desc; + } + + public Integer getProduct_value() { + return product_value; + } + + public void setProduct_value(Integer product_value) { + this.product_value = product_value; + } + + public Integer getProduct_inctv_prctg() { + return product_inctv_prctg; + } + + public void setProduct_inctv_prctg(Integer product_inctv_prctg) { + this.product_inctv_prctg = product_inctv_prctg; + } + + public byte[] getLob_image() { + return lob_image; + } + + public void setLob_image(byte[] lob_image) { + this.lob_image = lob_image; + } + + public String getUsr_crt() { + return usr_crt; + } + + public void setUsr_crt(String usr_crt) { + this.usr_crt = usr_crt; + } + + public java.util.Date getDtm_crt() { + return dtm_crt; + } + + public void setDtm_crt(java.util.Date dtm_crt) { + this.dtm_crt = dtm_crt; + } + + public String getIs_active() { + return is_active; + } + + public void setIs_active(String is_active) { + this.is_active = is_active; + } + + public String getBrand() { + return brand; + } + + public void setBrand(String brand) { + this.brand = brand; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getModel() { + return model; + } + + public void setModel(String model) { + this.model = model; + } + + public String getProduct_file() { + return product_file; + } + + public void setProduct_file(String product_file) { + this.product_file = product_file; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24e037d4ca1128fcb2e24a91a9880a3ad77b07af.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24e037d4ca1128fcb2e24a91a9880a3ad77b07af.svn-base new file mode 100644 index 0000000..ab8c715 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/24/24e037d4ca1128fcb2e24a91a9880a3ad77b07af.svn-base @@ -0,0 +1,17 @@ +package org.acra.util; + +import android.content.Context; + +import org.apache.http.conn.scheme.SocketFactory; + +/** + * Factory that creates an instance of a Https SocketFactory. + */ +public interface HttpsSocketFactoryFactory { + + /** + * @param context Android context for which to create the SocketFactory. + * @return SocketFactory that was created. + */ + public SocketFactory create(Context context); +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25283ba673cffe46c349bfd30929802fbd2b7148.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25283ba673cffe46c349bfd30929802fbd2b7148.svn-base new file mode 100644 index 0000000..bed0cb2 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25283ba673cffe46c349bfd30929802fbd2b7148.svn-base @@ -0,0 +1,49 @@ +package com.adins.mss.base.dynamicform; + +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +public class JsonResponsePdfDocument extends MssResponseType { + + @SerializedName("success") + private String success; + @SerializedName("status_code") + private String statusCode; + @SerializedName("message") + private String message; + @SerializedName("data") + private String data; + + public String getSuccess() { + return success; + } + + public void setSuccess(String success) { + this.success = success; + } + + public String getStatusCode() { + return statusCode; + } + + public void setStatusCode(String statusCode) { + this.statusCode = statusCode; + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public String getData() { + return data; + } + + public void setData(String data) { + this.data = data; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/253878d91fb67ae85477e0127ad2d40246827d07.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/253878d91fb67ae85477e0127ad2d40246827d07.svn-base new file mode 100644 index 0000000..2303d9f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/253878d91fb67ae85477e0127ad2d40246827d07.svn-base @@ -0,0 +1,18 @@ +package com.adins.mss.odr.common; + +import android.app.AlertDialog; +import android.content.Context; + +/** + * Created by Aditya Purwa on 3/4/2015. + */ +public class Dialogger { + public static void error(Context context, Exception ex, String extraReason) { + new AlertDialog.Builder(context) + .setTitle("Error") + .setMessage(ex.getMessage() + "\r\n" + extraReason) + .setIcon(android.R.drawable.ic_dialog_alert) + .create() + .show(); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25883877e64134a0fdc7e7476b94b4e948b8ca5e.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25883877e64134a0fdc7e7476b94b4e948b8ca5e.svn-base new file mode 100644 index 0000000..d67e500 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25883877e64134a0fdc7e7476b94b4e948b8ca5e.svn-base @@ -0,0 +1,13 @@ + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/2597ee73a26f32c4321415a50d6f7d57cadc0fae.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/2597ee73a26f32c4321415a50d6f7d57cadc0fae.svn-base new file mode 100644 index 0000000..3b6828f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/2597ee73a26f32c4321415a50d6f7d57cadc0fae.svn-base @@ -0,0 +1,191 @@ +package com.adins.mss.base.dynamictheme; + +import android.content.Context; +import android.os.Handler; +import android.os.Looper; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.dao.*; +import com.adins.mss.foundation.db.dataaccess.ThemeDataAccess; +import com.adins.mss.foundation.db.dataaccess.ThemeItemDataAccess; +import com.google.gson.Gson; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.List; + +/** + * Created by intishar.fa on 04/09/2018. + */ + +public class ThemeLoader { + + private Context context; + Thread loadThread; + Handler handler; + DynamicTheme serverTheme; + + public interface ColorSetLoaderCallback{ + void onHasLoaded(DynamicTheme dynamicTheme); + void onHasLoaded(DynamicTheme dynamicTheme, boolean needUpdate); + } + + public ThemeLoader(Context context) { + //mRemoteConfig = FirebaseRemoteConfig.getInstance(); + this.context = context; + /*// Create a Remote Config Setting to enable developer mode, which you can use to increase + // the number of fetches available per hour during development. See Best Practices in the + // README for more information. + // [START enable_dev_mode] + FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder() + .setDeveloperModeEnabled(true) + .build(); + mRemoteConfig.setConfigSettings(configSettings);*/ + } + + public void loadThemeFromUrl(final String themeUrl, final ColorSetLoaderCallback callbackObj) { + if(themeUrl == null) { + callbackObj.onHasLoaded(null,false); + return; + } + + handler = new Handler(Looper.getMainLooper()); + loadThread = new Thread(new Runnable() { + @Override + public void run() { + HttpURLConnection httpConn = null; + try { + URL url = new URL(themeUrl); + httpConn = (HttpURLConnection) url.openConnection(); + int responseCode = httpConn.getResponseCode(); + + // always check HTTP response code first + if (responseCode == HttpURLConnection.HTTP_OK) { + InputStreamReader inputStreamReader = new InputStreamReader(httpConn.getInputStream()); + BufferedReader bufferedReader = new BufferedReader(inputStreamReader); + StringBuilder builder = new StringBuilder(); + String line; + while ((line = bufferedReader.readLine()) != null){ + builder.append(line); + } + bufferedReader.close(); + String jsonTheme = builder.toString(); + serverTheme = new Gson().fromJson(jsonTheme,DynamicTheme.class); + + handler.post(new Runnable() {//run on main thread + @Override + public void run() { + if(loadThread != null) + loadThread.interrupt(); + checkVersion(serverTheme,callbackObj);//execute in main thread + } + }); + } + else { + handler.post(new Runnable() {//run on main thread + @Override + public void run() { + if(loadThread != null) + loadThread.interrupt(); + callbackObj.onHasLoaded(null,false); + } + }); + } + } catch (Exception e) { + e.printStackTrace(); + if(httpConn != null) + httpConn.disconnect(); + handler.post(new Runnable() {//run on main thread + @Override + public void run() { + if(loadThread != null) + loadThread.interrupt(); + callbackObj.onHasLoaded(null,false); + } + }); + } + finally { + if(httpConn != null) + httpConn.disconnect(); + } + } + }); + loadThread.start(); + /*long cacheExpiration = 0; + + //expire the cache immediately for development mode. + if (mRemoteConfig.getInfo().getConfigSettings().isDeveloperModeEnabled()) { + cacheExpiration = 0; + } + + mRemoteConfig.fetch(cacheExpiration) + .addOnCompleteListener(new OnCompleteListener() { + @Override + public void onComplete(Task task) { + if (task.isSuccessful()) { + // task successful. Activate the fetched data + mRemoteConfig.activateFetched(); + String colorSetJson = mRemoteConfig.getString("color_set_config"); + DynamicTheme serverTheme = new Gson().fromJson(colorSetJson,DynamicTheme.class); + checkVersion(serverTheme,callbackObj); + } else { + System.out.println("Cannot fetch remote config."); + } + } + });*/ + + } + + private void checkVersion(DynamicTheme serverColorSet, ColorSetLoaderCallback callbackObj){ + List themeList = ThemeDataAccess.getThemeByApplicationType(context, + GlobalData.getSharedGlobalData().getApplication()); + int savedVersion = -1; + if(themeList != null && themeList.size() > 0){ + savedVersion = Integer.parseInt(themeList.get(0).getVersion()); + } + boolean needUpdate; + + //check version from server, compare with saved dynamictheme version + int serverVersion = serverColorSet.getVersion(); + if(serverVersion > savedVersion){//if there is new version from server + saveColorSet(serverColorSet);//overwrite current saved dynamictheme + needUpdate = true; + } + else{ + needUpdate = false; + } + callbackObj.onHasLoaded(serverColorSet,needUpdate); + } + + public void saveColorSet(DynamicTheme dynamicTheme){ + Theme themeObj = DynamicTheme.toThemeDao(context,dynamicTheme); + List themeItemList = DynamicTheme.toThemeItemList(context,themeObj.getUuid_theme() + ,dynamicTheme.getThemeItemList()); + ThemeItemDataAccess.deleteAllItemByUuidTheme(context, + themeObj.getUuid_theme());//first, delete all theme item corresponded to uuid_theme + ThemeDataAccess.addOrReplace(context,themeObj); + ThemeItemDataAccess.addOrReplace(context,themeItemList); + } + + public void loadSavedColorSet(ColorSetLoaderCallback callbackObj){ + DynamicTheme colorSet = null; + List themeList = null; + String applicationType = GlobalData.getSharedGlobalData().getApplication(); + if(applicationType != null && !applicationType.equals("")) + themeList = ThemeDataAccess.getThemeByApplicationType(context,applicationType); + else + themeList = ThemeDataAccess.getAll(context); + if(themeList != null && themeList.size() > 0){ + String uuid_theme = themeList.get(0).getUuid_theme(); + List themeItemList = ThemeItemDataAccess.getAllByUuidTheme(context,uuid_theme); + if(themeItemList != null && themeItemList.size() > 0){ + Theme theme = themeItemList.get(0).getTheme(); + colorSet = new DynamicTheme(theme,themeItemList); + } + } + callbackObj.onHasLoaded(colorSet); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25e37389328a9b2d8e830d7e926d94c9aceb53e6.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25e37389328a9b2d8e830d7e926d94c9aceb53e6.svn-base new file mode 100644 index 0000000..889e90a --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25e37389328a9b2d8e830d7e926d94c9aceb53e6.svn-base @@ -0,0 +1,27 @@ +package com.adins.mss.foundation.print; + +public class SentencesSato { + String sentence; + int lenghtSentemce; + + public SentencesSato() { + + } + + public String getSentence() { + return sentence; + } + + public void setSentence(String sentence) { + this.sentence = sentence; + } + + public int getLenghtSentemce() { + return lenghtSentemce; + } + + public void setLenghtSentemce(int lenghtSentemce) { + this.lenghtSentemce = lenghtSentemce; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25ed9d086c4338e74f33a58132fd44be7f3e2d73.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25ed9d086c4338e74f33a58132fd44be7f3e2d73.svn-base new file mode 100644 index 0000000..c5ca658 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/25/25ed9d086c4338e74f33a58132fd44be7f3e2d73.svn-base @@ -0,0 +1,370 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/261dd8668242d0dd1b97a370bd29e7aa3eda4f68.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/261dd8668242d0dd1b97a370bd29e7aa3eda4f68.svn-base new file mode 100644 index 0000000..64a3e36 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/261dd8668242d0dd1b97a370bd29e7aa3eda4f68.svn-base @@ -0,0 +1,11 @@ + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265bdaaa02701fe88b888399d6334a6d94dd5396.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265bdaaa02701fe88b888399d6334a6d94dd5396.svn-base new file mode 100644 index 0000000..591f567 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265bdaaa02701fe88b888399d6334a6d94dd5396.svn-base @@ -0,0 +1,103 @@ +package com.adins.mss.foundation.camera; + +import android.app.Activity; +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.hardware.Camera.Parameters; +import android.widget.ImageView; +import android.widget.Toast; + +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.util.ByteFormatter; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.LocationInfo; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.location.LocationTrackingManager; +import com.adins.mss.foundation.questiongenerator.QuestionBean; + +import java.util.Date; + +public class FormCamera extends Camera { + + private QuestionBean questionInFocus; + private ImageView thumbInFocus; + + public FormCamera(Context context, Activity activity, + android.hardware.Camera camera, Parameters params, QuestionBean questionInFocus) { + super(context, activity, camera, params); + this.questionInFocus = questionInFocus; + thumbInFocus = new ImageView(context); + } + + @Override + protected void processImage(byte[] dataPicWithExif, LocationInfo locationInfo) { + // delegate + this.imageCallBack.onPictureTaken(dataPicWithExif, locationInfo); + + LocationTrackingManager ltm = Global.LTM; + saveImage(dataPicWithExif); + + boolean getGPS = true; + boolean isGeoTagged = Global.AT_IMAGE_W_LOCATION.equals(questionInFocus.getAnswer_type()); + boolean isGeoTaggedGPSOnly = Global.AT_IMAGE_W_GPS_ONLY.equals(questionInFocus.getAnswer_type()); + + //Glen 7 Oct 2014, create timestamp, copy logic from MSMTOW, as default value if not using location + try { + long date = (new Date()).getTime(); + getQuestionInFocus().setLovId(String.valueOf(date)); + } catch (Exception e) { + FireCrash.log(e); + getQuestionInFocus().setLovId("0"); + } + + + if (isGeoTagged && ltm != null) { + LocationInfo locInfo = ltm.getCurrentLocation(Global.FLAG_LOCATION_CAMERA); + getQuestionInFocus().setAnswer(locationInfoToSubmitString(locInfo)); + } + + if (isGeoTaggedGPSOnly && ltm != null) { + LocationInfo locInfo = ltm.getCurrentLocation(Global.FLAG_LOCATION_CAMERA); + //Glen 7 Oct 2014, add timestamp + if (Double.parseDouble(locInfo.getLatitude()) == 0.0 || Double.parseDouble(locInfo.getLongitude()) == 0.0) { + if (getQuestionInFocus().isMandatory() || getQuestionInFocus().isRelevantMandatory()) { + String[] msg = {"Can't get GPS location"}; + String alert2 = Tool.implode(msg, "\n"); + Toast.makeText(getContext(), alert2, Toast.LENGTH_LONG).show(); + saveImage(null); + getGPS = false; + } + } else { + getQuestionInFocus().setAnswer(locationInfoToSubmitString(locInfo)); + } + } + // set thumbnail + if (thumbInFocus != null && getGPS) { + Bitmap bm = BitmapFactory.decodeByteArray(dataPicWithExif, 0, dataPicWithExif.length); + + int[] res = Tool.getThumbnailResolution(bm.getWidth(), bm.getHeight()); + Bitmap thumbnail = Bitmap.createScaledBitmap(bm, res[0], res[1], true); + setThumb(thumbnail); + + //Glen 21 Oct 2014, format byte + long size = getQuestionInFocus().getImgAnswer().length; + String formattedSize = ByteFormatter.formatByteSize(size); + setTxtDetail(" " + bm.getWidth() + " x " + bm.getHeight() + ". Size " + formattedSize); + + questionInFocus = null; + } + } + + private QuestionBean getQuestionInFocus() { + return questionInFocus; + } + + private void setThumb(Bitmap bitmap) { + thumbInFocus.setImageBitmap(bitmap); + } + + private void saveImage(byte[] imgAnswer) { + questionInFocus.setImgAnswer(imgAnswer); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265e7d3ea96d2a2b601a2c3a9e95d6c7fb940970.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265e7d3ea96d2a2b601a2c3a9e95d6c7fb940970.svn-base new file mode 100644 index 0000000..6aa2b5f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/26/265e7d3ea96d2a2b601a2c3a9e95d6c7fb940970.svn-base @@ -0,0 +1,182 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288025193fcca0414236a36558c473231b02558f.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288025193fcca0414236a36558c473231b02558f.svn-base new file mode 100644 index 0000000..d544977 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288025193fcca0414236a36558c473231b02558f.svn-base @@ -0,0 +1,19 @@ +package com.adins.mss.foundation.camera; + +import android.hardware.Camera; +import android.hardware.Camera.Face; + +import com.adins.mss.foundation.camerainapp.helper.Logger; + +public class FaceDetectionListener implements android.hardware.Camera.FaceDetectionListener { + + @Override + public void onFaceDetection(Face[] faces, Camera camera) { + // TODO Auto-generated method stub + if (faces.length > 0) { + Logger.d("FaceDetection", "face detected: " + faces.length + + " Face 1 Location X: " + faces[0].rect.centerX() + + "Y: " + faces[0].rect.centerY()); + } + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288b3197e89415a72d478912c0878b22a59a7967.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288b3197e89415a72d478912c0878b22a59a7967.svn-base new file mode 100644 index 0000000..b1cc740 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/288b3197e89415a72d478912c0878b22a59a7967.svn-base @@ -0,0 +1,94 @@ +package com.adins.mss.foundation.security; + +import org.bouncycastle.crypto.digests.SHA1Digest; +import org.bouncycastle.crypto.params.KeyParameter; +import org.bouncycastle.crypto.params.ParametersWithIV; +import org.bouncycastle.util.encoders.Base64Encoder; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.security.SecureRandom; + +public class SHA1KeyGenerator { + SecureRandom sr = new SecureRandom(); + + public SHA1KeyGenerator() { + super(); + } + + public byte[] generateSHA1(byte[] ClearText) { + + SHA1Digest dSHA1 = new SHA1Digest(); + byte[] outSHA1 = new byte[dSHA1.getDigestSize()]; + dSHA1.update(ClearText, 0, ClearText.length); + dSHA1.doFinal(outSHA1, 0); + return outSHA1; + + } + + public ParametersWithIV generateKeyParameter() { + byte[] iv128 = new byte[128 / 8]; + byte[] key128 = new byte[128 / 8]; + sr.nextBytes(key128); + KeyParameter keyAES = new KeyParameter(key128); + sr.nextBytes(iv128); + ParametersWithIV paramsWithIV = new ParametersWithIV(keyAES, iv128); + return paramsWithIV; + + } + + public byte[] customSha1() { + String Messagestr = "admin"; + String postfix = "Caesar"; + byte[] Messagestrbyte = Messagestr.getBytes(); + byte[] postfixbyte = postfix.getBytes(); + SHA1Digest digest = new SHA1Digest(); + digest.update(Messagestrbyte, 0, Messagestrbyte.length); + digest.update(postfixbyte, 0, postfixbyte.length); + byte[] hash = new byte[digest.getDigestSize()]; + digest.doFinal(hash, 0); + return hash; + } + + public byte[] customSha1Calculate(String received) { + int separation = received.indexOf('\n'); + String receivedHash = received.substring(separation + 1); + String message = ""; + if (separation == -1) { + message = received; + } else { + message = received.substring(0, separation); + } + byte[] messagebyte = message.getBytes(); + String postfix = "Caesar"; + byte[] postfixbyte = postfix.getBytes(); + SHA1Digest digest = new SHA1Digest(); + int plaintextLength = messagebyte.length - 20; + byte[] plaintext = new byte[plaintextLength]; + byte[] hash = new byte[20]; + System.arraycopy(messagebyte, 0, plaintext, 0, plaintextLength); + System.arraycopy(messagebyte, plaintextLength, hash, 0, 20); + + SHA1Digest digest2 = new SHA1Digest(); + digest2.update(plaintext, 0, plaintext.length); + byte[] hash2 = new byte[digest2.getDigestSize()]; + digest2.doFinal(hash2, 0); + + digest.update(messagebyte, 0, messagebyte.length); + digest.update(postfixbyte, 0, postfixbyte.length); + byte[] calculatedhash = new byte[digest.getDigestSize()]; + digest.doFinal(calculatedhash, 0); + + ByteArrayOutputStream output = new ByteArrayOutputStream(); + Base64Encoder base64 = new Base64Encoder(); + try { + base64.decode(receivedHash, output); + + } catch (IOException e) { + e.printStackTrace(); + } + + byte[] receivedHashbyte = output.toByteArray(); + return receivedHashbyte; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28a57348a8807871ec261f10fc11fafce089b4b2.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28a57348a8807871ec261f10fc11fafce089b4b2.svn-base new file mode 100644 index 0000000..b89a5f4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28a57348a8807871ec261f10fc11fafce089b4b2.svn-base @@ -0,0 +1,9 @@ + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28c3b38ca761bd2c44d502d964d6fbabf7468fab.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28c3b38ca761bd2c44d502d964d6fbabf7468fab.svn-base new file mode 100644 index 0000000..1bd1e58 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28c3b38ca761bd2c44d502d964d6fbabf7468fab.svn-base @@ -0,0 +1,39 @@ +/* + * Copyright 2013 Chris Banes + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package uk.co.senab.actionbarpulltorefresh.library.viewdelegates; + +import android.view.View; + +/** + * ViewDelegates are what are used to de-couple the Attacher from the different types of + * scrollable views. + */ +public interface ViewDelegate { + + /** + * Allows you to provide support for View which do not have built-in + * support. In this method you should cast view to it's + * native class, and check if it is scrolled to the top. + * + * @param view The view which has should be checked against. + * @param x The X co-ordinate of the touch event + * @param y The Y co-ordinate of the touch event + * @return true if view is scrolled to the top. + */ + public boolean isReadyForPull(View view, float x, float y); + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28dc3797c5f7fbd66f8a10ebf2665b73198acacf.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28dc3797c5f7fbd66f8a10ebf2665b73198acacf.svn-base new file mode 100644 index 0000000..199204f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28dc3797c5f7fbd66f8a10ebf2665b73198acacf.svn-base @@ -0,0 +1,45 @@ +package com.adins.mss.odr; + +import android.content.Intent; +import android.os.Bundle; + +import com.adins.mss.base.SynchronizeActivity; +import com.google.firebase.analytics.FirebaseAnalytics; +import com.google.firebase.perf.FirebasePerformance; +import com.google.firebase.perf.metrics.Trace; + +public class MOSynchronizeActivity extends SynchronizeActivity{ + + private Trace synchronizeOrdTrace; + private FirebaseAnalytics screenName; + + @Override + protected Intent getIntentMainMenu() { + // TODO Auto-generated method stub + return new Intent(this, NewMOMainActivity.class); + } + + @Override + protected void onCreate(Bundle savedInstanceState) { + // TODO Auto-generated method stub + screenName = FirebaseAnalytics.getInstance(this); + synchronizeOrdTrace = FirebasePerformance.getInstance().newTrace(getString(R.string.synchronize_trace_order)); + activity = this; + super.onCreate(savedInstanceState); + } + + @Override + protected void onResume() { + //Set Firebase screen name + screenName.setCurrentScreen(this,getString(com.adins.mss.base.R.string.screen_name_odr_synchronize),null); + synchronizeOrdTrace.start(); + super.onResume(); + } + + @Override + protected void onPause() { + synchronizeOrdTrace.stop(); + super.onPause(); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28e05f3319365120af902bebf13c6aa66b02a609.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28e05f3319365120af902bebf13c6aa66b02a609.svn-base new file mode 100644 index 0000000..96cc43e --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28e05f3319365120af902bebf13c6aa66b02a609.svn-base @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28eb3256e394e6f316ceb108775a556f91b6a2a7.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28eb3256e394e6f316ceb108775a556f91b6a2a7.svn-base new file mode 100644 index 0000000..7050280 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28eb3256e394e6f316ceb108775a556f91b6a2a7.svn-base @@ -0,0 +1,27 @@ +package com.adins.mss.base.syncfile; + +import com.adins.mss.foundation.http.MssRequestType; + +import java.io.Serializable; +import java.util.Date; + +/** + * Created by loise on 10/16/2017. + */ + +/** + * json request template for getting list of files to be downloaded from server + */ +public class SyncFileRequest extends MssRequestType implements Serializable { + private java.util.Date dtm_upd; + + public Date getDtm_upd() { + return dtm_upd; + } + + public void setDtm_upd(Date dtm_upd) { + this.dtm_upd = dtm_upd; + } + + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f4a7ac6bb42e5653da99cefb1512de1056f84a.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f4a7ac6bb42e5653da99cefb1512de1056f84a.svn-base new file mode 100644 index 0000000..21fd421 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f4a7ac6bb42e5653da99cefb1512de1056f84a.svn-base @@ -0,0 +1,8 @@ +package com.adins.mss.foundation.sync.api; + +/** + * Created by adityapurwa on 12/03/15. + */ +public interface SynchronizationMapper { + public void map(String property, String value, T target); +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f9f96d3c7f0ae28953d76185b16e2c6ca8810d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f9f96d3c7f0ae28953d76185b16e2c6ca8810d.svn-base new file mode 100644 index 0000000..516b413 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28f9f96d3c7f0ae28953d76185b16e2c6ca8810d.svn-base @@ -0,0 +1,15 @@ +package com.adins.mss.svy; + +import org.junit.Test; + +import static org.junit.Assert.*; + +/** + * To work on unit tests, switch the Test Artifact in the Build Variants view. + */ +public class ExampleUnitTest { + @Test + public void addition_isCorrect() throws Exception { + assertEquals(4, 2 + 2); + } +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28fd243b977ee602d0aab19091fc9d7d77661d09.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28fd243b977ee602d0aab19091fc9d7d77661d09.svn-base new file mode 100644 index 0000000..134fdc5 Binary files /dev/null and b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/28/28fd243b977ee602d0aab19091fc9d7d77661d09.svn-base differ diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2902ade254cd9752cc156da879326e991cc38e17.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2902ade254cd9752cc156da879326e991cc38e17.svn-base new file mode 100644 index 0000000..c0ff74b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2902ade254cd9752cc156da879326e991cc38e17.svn-base @@ -0,0 +1,477 @@ +/* + * Copyright 2012 Kevin Gaudin + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.acra.collector; + +import android.Manifest; +import android.content.Context; +import android.content.SharedPreferences; +import android.content.pm.PackageInfo; +import android.os.Environment; + +import org.acra.ACRA; +import org.acra.ReportField; +import org.acra.util.Installation; +import org.acra.util.PackageManagerWrapper; +import org.acra.util.ReportUtils; + +import java.io.IOException; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.io.Writer; +import java.util.Calendar; +import java.util.GregorianCalendar; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import static org.acra.ACRA.LOG_TAG; +import static org.acra.ReportField.ANDROID_VERSION; +import static org.acra.ReportField.APPLICATION_LOG; +import static org.acra.ReportField.APP_VERSION_CODE; +import static org.acra.ReportField.APP_VERSION_NAME; +import static org.acra.ReportField.AVAILABLE_MEM_SIZE; +import static org.acra.ReportField.BRAND; +import static org.acra.ReportField.BUILD; +import static org.acra.ReportField.BUILD_CONFIG; +import static org.acra.ReportField.CRASH_CONFIGURATION; +import static org.acra.ReportField.CUSTOM_DATA; +import static org.acra.ReportField.DEVICE_FEATURES; +import static org.acra.ReportField.DEVICE_ID; +import static org.acra.ReportField.DISPLAY; +import static org.acra.ReportField.DROPBOX; +import static org.acra.ReportField.DUMPSYS_MEMINFO; +import static org.acra.ReportField.ENVIRONMENT; +import static org.acra.ReportField.EVENTSLOG; +import static org.acra.ReportField.FILE_PATH; +import static org.acra.ReportField.INITIAL_CONFIGURATION; +import static org.acra.ReportField.INSTALLATION_ID; +import static org.acra.ReportField.IS_SILENT; +import static org.acra.ReportField.LOGCAT; +import static org.acra.ReportField.MEDIA_CODEC_LIST; +import static org.acra.ReportField.PACKAGE_NAME; +import static org.acra.ReportField.PHONE_MODEL; +import static org.acra.ReportField.PRODUCT; +import static org.acra.ReportField.RADIOLOG; +import static org.acra.ReportField.REPORT_ID; +import static org.acra.ReportField.SETTINGS_GLOBAL; +import static org.acra.ReportField.SETTINGS_SECURE; +import static org.acra.ReportField.SETTINGS_SYSTEM; +import static org.acra.ReportField.SHARED_PREFERENCES; +import static org.acra.ReportField.STACK_TRACE; +import static org.acra.ReportField.STACK_TRACE_HASH; +import static org.acra.ReportField.THREAD_DETAILS; +import static org.acra.ReportField.TOTAL_MEM_SIZE; +import static org.acra.ReportField.USER_CRASH_DATE; +import static org.acra.ReportField.USER_EMAIL; +import static org.acra.ReportField.USER_IP; + +/** + * Responsible for creating the CrashReportData for an Exception. + *

+ * Also responsible for holding the custom data to send with each report. + *

+ * + * @author William Ferguson + * @since 4.3.0 + */ +public final class CrashReportDataFactory { + + private final Context context; + private final SharedPreferences prefs; + private final Map customParameters = new LinkedHashMap(); + private final GregorianCalendar appStartDate; + private final String initialConfiguration; + + public CrashReportDataFactory(Context context, SharedPreferences prefs, GregorianCalendar appStartDate, + String initialConfiguration) { + this.context = context; + this.prefs = prefs; + this.appStartDate = appStartDate; + this.initialConfiguration = initialConfiguration; + } + + /** + *

+ * Adds a custom key and value to be reported with the generated + * CashReportData. + *

+ *

+ * The key/value pairs will be stored in the "custom" column, as a text + * containing one 'key = value' pair on each line. + *

+ * + * @param key A key for your custom data. + * @param value The value associated to your key. + * @return The previous value for this key if there was one, or null. + */ + public String putCustomData(String key, String value) { + return customParameters.put(key, value); + } + + /** + * Removes a key/value pair from the custom data field. + * + * @param key The key of the data to be removed. + * @return The value for this key before removal. + */ + public String removeCustomData(String key) { + return customParameters.remove(key); + } + + /** + * Removes all key/value pairs from the custom data field. + */ + public void clearCustomData() { + customParameters.clear(); + } + + /** + * Gets the current value for a key in the custom data field. + * + * @param key The key of the data to be retrieved. + * @return The value for this key. + */ + public String getCustomData(String key) { + return customParameters.get(key); + } + + /** + * Collects crash data. + * + * @param msg A message to be associated with the crash report. + * @param th Throwable that caused the crash. + * @param customData Custom key/value pairs to be associated with the crash report. + * @param isSilentReport Whether to report this report as being sent silently. + * @param brokenThread Thread on which the error occurred. + * @return CrashReportData representing the current state of the application + * at the instant of the Exception. + */ + public CrashReportData createCrashData(String msg, Throwable th, Map customData, boolean isSilentReport, Thread brokenThread) { + final CrashReportData crashReportData = new CrashReportData(); + try { + final List crashReportFields = ACRA.getConfig().getReportFields(); + + // Make every entry here bullet proof and move any slightly dodgy + // ones to the end. + // This ensures that we collect as much info as possible before + // something crashes the collection process. + + crashReportData.put(STACK_TRACE, getStackTrace(msg, th)); + crashReportData.put(ReportField.USER_APP_START_DATE, ReportUtils.getTimeString(appStartDate)); + + if (isSilentReport) { + crashReportData.put(IS_SILENT, "true"); + } + + // StackTrace hash + if (crashReportFields.contains(STACK_TRACE_HASH)) { + crashReportData.put(ReportField.STACK_TRACE_HASH, getStackTraceHash(th)); + } + + // Generate report uuid + if (crashReportFields.contains(REPORT_ID)) { + crashReportData.put(ReportField.REPORT_ID, UUID.randomUUID().toString()); + } + + // Installation unique ID + if (crashReportFields.contains(INSTALLATION_ID)) { + crashReportData.put(INSTALLATION_ID, Installation.id(context)); + } + + // Device Configuration when crashing + if (crashReportFields.contains(INITIAL_CONFIGURATION)) { + crashReportData.put(INITIAL_CONFIGURATION, initialConfiguration); + } + if (crashReportFields.contains(CRASH_CONFIGURATION)) { + crashReportData.put(CRASH_CONFIGURATION, ConfigurationCollector.collectConfiguration(context)); + } + + // Collect meminfo + if (!(th instanceof OutOfMemoryError) && crashReportFields.contains(DUMPSYS_MEMINFO)) { + crashReportData.put(DUMPSYS_MEMINFO, DumpSysCollector.collectMemInfo()); + } + + // Application Package name + if (crashReportFields.contains(PACKAGE_NAME)) { + crashReportData.put(PACKAGE_NAME, context.getPackageName()); + } + + // Android OS Build details + if (crashReportFields.contains(BUILD)) { + crashReportData.put(BUILD, ReflectionCollector.collectConstants(android.os.Build.class) + ReflectionCollector.collectConstants(android.os.Build.VERSION.class, "VERSION")); + } + + // Device model + if (crashReportFields.contains(PHONE_MODEL)) { + crashReportData.put(PHONE_MODEL, android.os.Build.MODEL); + } + // Android version + if (crashReportFields.contains(ANDROID_VERSION)) { + crashReportData.put(ANDROID_VERSION, android.os.Build.VERSION.RELEASE); + } + + // Device Brand (manufacturer) + if (crashReportFields.contains(BRAND)) { + crashReportData.put(BRAND, android.os.Build.BRAND); + } + if (crashReportFields.contains(PRODUCT)) { + crashReportData.put(PRODUCT, android.os.Build.PRODUCT); + } + + // Device Memory + if (crashReportFields.contains(TOTAL_MEM_SIZE)) { + crashReportData.put(TOTAL_MEM_SIZE, Long.toString(ReportUtils.getTotalInternalMemorySize())); + } + if (crashReportFields.contains(AVAILABLE_MEM_SIZE)) { + crashReportData.put(AVAILABLE_MEM_SIZE, Long.toString(ReportUtils.getAvailableInternalMemorySize())); + } + + // Application file path + if (crashReportFields.contains(FILE_PATH)) { + crashReportData.put(FILE_PATH, ReportUtils.getApplicationFilePath(context)); + } + + // Main display details + if (crashReportFields.contains(DISPLAY)) { + crashReportData.put(DISPLAY, DisplayManagerCollector.collectDisplays(context)); + } + + // User crash date with local timezone + if (crashReportFields.contains(USER_CRASH_DATE)) { + final GregorianCalendar curDate = new GregorianCalendar(); + curDate.setTimeInMillis(Calendar.getInstance().getTimeInMillis()); + crashReportData.put(USER_CRASH_DATE, ReportUtils.getTimeString(curDate)); + } + + // Add custom info, they are all stored in a single field + if (crashReportFields.contains(CUSTOM_DATA)) { + crashReportData.put(CUSTOM_DATA, createCustomInfoString(customData)); + } + + if (crashReportFields.contains(BUILD_CONFIG)) { + try { + final Class buildConfigClass = getBuildConfigClass(); + crashReportData.put(BUILD_CONFIG, ReflectionCollector.collectConstants(buildConfigClass)); + } catch (ClassNotFoundException e) { + // We have already logged this when we had the name of the class that wasn't found. + } + } + + // Add user email address, if set in the app's preferences + if (crashReportFields.contains(USER_EMAIL)) { + crashReportData.put(USER_EMAIL, prefs.getString(ACRA.PREF_USER_EMAIL_ADDRESS, "N/A")); + } + + // Device features + if (crashReportFields.contains(DEVICE_FEATURES)) { + crashReportData.put(DEVICE_FEATURES, DeviceFeaturesCollector.getFeatures(context)); + } + + // Environment (External storage state) + if (crashReportFields.contains(ENVIRONMENT)) { + crashReportData.put(ENVIRONMENT, ReflectionCollector.collectStaticGettersResults(Environment.class)); + } + + // System settings + if (crashReportFields.contains(SETTINGS_SYSTEM)) { + crashReportData.put(SETTINGS_SYSTEM, SettingsCollector.collectSystemSettings(context)); + } + + // Secure settings + if (crashReportFields.contains(SETTINGS_SECURE)) { + crashReportData.put(SETTINGS_SECURE, SettingsCollector.collectSecureSettings(context)); + } + + // Global settings + if (crashReportFields.contains(SETTINGS_GLOBAL)) { + crashReportData.put(SETTINGS_GLOBAL, SettingsCollector.collectGlobalSettings(context)); + } + + // SharedPreferences + if (crashReportFields.contains(SHARED_PREFERENCES)) { + crashReportData.put(SHARED_PREFERENCES, SharedPreferencesCollector.collect(context)); + } + + // Now get all the crash data that relies on the PackageManager + // (which may or may not be here). + final PackageManagerWrapper pm = new PackageManagerWrapper(context); + + final PackageInfo pi = pm.getPackageInfo(); + if (pi != null) { + // Application Version + if (crashReportFields.contains(APP_VERSION_CODE)) { + crashReportData.put(APP_VERSION_CODE, Integer.toString(pi.versionCode)); + } + if (crashReportFields.contains(APP_VERSION_NAME)) { + crashReportData.put(APP_VERSION_NAME, pi.versionName != null ? pi.versionName : "not set"); + } + } else { + // Could not retrieve package info... + crashReportData.put(APP_VERSION_NAME, "Package info unavailable"); + } + + // Retrieve UDID(IMEI) if permission is available + if (crashReportFields.contains(DEVICE_ID) && prefs.getBoolean(ACRA.PREF_ENABLE_DEVICE_ID, true) + && pm.hasPermission(Manifest.permission.READ_PHONE_STATE)) { + final String deviceId = ReportUtils.getDeviceId(context); + if (deviceId != null) { + crashReportData.put(DEVICE_ID, deviceId); + } + } + + // Collect DropBox and logcat + // Before JellyBean, this required the READ_LOGS permission + // Since JellyBean, READ_LOGS is not granted to third-party apps anymore for security reasons. + // Though, we can call logcat without any permission and still get traces related to our app. + final boolean hasReadLogsPermission = pm.hasPermission(Manifest.permission.READ_LOGS) || (Compatibility.getAPILevel() >= 16); + if (prefs.getBoolean(ACRA.PREF_ENABLE_SYSTEM_LOGS, true) && hasReadLogsPermission) { + ACRA.log.i(LOG_TAG, "READ_LOGS granted! ACRA can include LogCat and DropBox data."); + if (crashReportFields.contains(LOGCAT)) { + crashReportData.put(LOGCAT, LogCatCollector.collectLogCat(null)); + } + if (crashReportFields.contains(EVENTSLOG)) { + crashReportData.put(EVENTSLOG, LogCatCollector.collectLogCat("events")); + } + if (crashReportFields.contains(RADIOLOG)) { + crashReportData.put(RADIOLOG, LogCatCollector.collectLogCat("radio")); + } + if (crashReportFields.contains(DROPBOX)) { + crashReportData.put(DROPBOX, + DropBoxCollector.read(context, ACRA.getConfig().additionalDropBoxTags())); + } + } else { + ACRA.log.i(LOG_TAG, "READ_LOGS not allowed. ACRA will not include LogCat and DropBox data."); + } + + // Application specific log file + if (crashReportFields.contains(APPLICATION_LOG)) { + try { + final String logFile = LogFileCollector.collectLogFile(context, + ACRA.getConfig().applicationLogFile(), + ACRA.getConfig().applicationLogFileLines()); + crashReportData.put(APPLICATION_LOG, logFile); + } catch (IOException e) { + ACRA.log.e(LOG_TAG, "Error while reading application log file " + ACRA.getConfig().applicationLogFile(), e); + } + } + + // Media Codecs list + if (crashReportFields.contains(MEDIA_CODEC_LIST)) { + crashReportData.put(MEDIA_CODEC_LIST, MediaCodecListCollector.collecMediaCodecList()); + } + + // Failing thread details + if (crashReportFields.contains(THREAD_DETAILS)) { + crashReportData.put(THREAD_DETAILS, ThreadCollector.collect(brokenThread)); + } + + // IP addresses + if (crashReportFields.contains(USER_IP)) { + crashReportData.put(USER_IP, ReportUtils.getLocalIpAddress()); + } + + } catch (RuntimeException e) { + ACRA.log.e(LOG_TAG, "Error while retrieving crash data", e); + } + + return crashReportData; + } + + /** + * Generates the string which is posted in the single custom data field in + * the GoogleDocs Form. + * + * @return A string with a 'key = value' pair on each line. + */ + private String createCustomInfoString(Map reportCustomData) { + Map params = customParameters; + + if (reportCustomData != null) { + params = new HashMap(params); + params.putAll(reportCustomData); + } + + final StringBuilder customInfo = new StringBuilder(); + for (final String currentKey : params.keySet()) { + String currentVal = params.get(currentKey); + customInfo.append(currentKey); + customInfo.append(" = "); + // We need to escape new lines in values or they are transformed into new + // custom fields. => let's replace all '\n' with "\\n" + if (currentVal != null) { + currentVal = currentVal.replaceAll("\n", "\\\\n"); + } + customInfo.append(currentVal); + customInfo.append("\n"); + } + return customInfo.toString(); + } + + private String getStackTrace(String msg, Throwable th) { + final Writer result = new StringWriter(); + final PrintWriter printWriter = new PrintWriter(result); + + if (msg != null && !msg.isEmpty()) + printWriter.println(msg); + + // If the exception was thrown in a background thread inside + // AsyncTask, then the actual exception can be found with getCause + Throwable cause = th; + while (cause != null) { + cause.printStackTrace(printWriter); + cause = cause.getCause(); + } + final String stacktraceAsString = result.toString(); + printWriter.close(); + + return stacktraceAsString; + } + + private String getStackTraceHash(Throwable th) { + final StringBuilder res = new StringBuilder(); + Throwable cause = th; + while (cause != null) { + final StackTraceElement[] stackTraceElements = cause.getStackTrace(); + for (final StackTraceElement e : stackTraceElements) { + res.append(e.getClassName()); + res.append(e.getMethodName()); + } + cause = cause.getCause(); + } + + return Integer.toHexString(res.toString().hashCode()); + } + + private Class getBuildConfigClass() throws ClassNotFoundException { + final Class configuredBuildConfig = ACRA.getConfig().buildConfigClass(); + if ((configuredBuildConfig != null) && !configuredBuildConfig.equals(Object.class)) { + // If set via annotations or programatically then it will have a real value, + // otherwise it will be Object.class (annotation default) or null (explicit programmatic). + return configuredBuildConfig; + } + + final String className = context.getClass().getPackage().getName() + ".BuildConfig"; + try { + return Class.forName(className); + } catch (ClassNotFoundException e) { + ACRA.log.e(LOG_TAG, "Not adding buildConfig to log. Class Not found : " + className + ". Please configure 'buildConfigClass' in your ACRA config"); + throw e; + } + } +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2913d54b8c6539ca3abccabcd6d9ace6a71e57da.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2913d54b8c6539ca3abccabcd6d9ace6a71e57da.svn-base new file mode 100644 index 0000000..99fc59f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/2913d54b8c6539ca3abccabcd6d9ace6a71e57da.svn-base @@ -0,0 +1,126 @@ +/* + * Copyright 2013, Edmodo, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with the License. + * You may obtain a copy of the License in the LICENSE file, or at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" + * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language + * governing permissions and limitations under the License. + */ + +package com.edmodo.cropper.util; + +import android.content.Context; +import android.graphics.Color; +import android.graphics.Paint; +import android.util.TypedValue; + +/** + * Utility class for handling all of the Paint used to draw the CropOverlayView. + */ +public class PaintUtil { + + // Private Constants /////////////////////////////////////////////////////// + + private static final int DEFAULT_CORNER_COLOR = Color.WHITE; + private static final String SEMI_TRANSPARENT = "#AAFFFFFF"; + private static final String DEFAULT_BACKGROUND_COLOR_ID = "#B0000000"; + private static final float DEFAULT_LINE_THICKNESS_DP = 3; + private static final float DEFAULT_CORNER_THICKNESS_DP = 5; + private static final float DEFAULT_GUIDELINE_THICKNESS_PX = 1; + + // Public Methods ////////////////////////////////////////////////////////// + + /** + * Creates the Paint object for drawing the crop window border. + * + * @param context the Context + * @return new Paint object + */ + public static Paint newBorderPaint(Context context) { + + // Set the line thickness for the crop window border. + final float lineThicknessPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, + DEFAULT_LINE_THICKNESS_DP, + context.getResources().getDisplayMetrics()); + + final Paint borderPaint = new Paint(); + borderPaint.setColor(Color.parseColor(SEMI_TRANSPARENT)); + borderPaint.setStrokeWidth(lineThicknessPx); + borderPaint.setStyle(Paint.Style.STROKE); + + return borderPaint; + } + + /** + * Creates the Paint object for drawing the crop window guidelines. + * + * @return the new Paint object + */ + public static Paint newGuidelinePaint() { + + final Paint paint = new Paint(); + paint.setColor(Color.parseColor(SEMI_TRANSPARENT)); + paint.setStrokeWidth(DEFAULT_GUIDELINE_THICKNESS_PX); + + return paint; + } + + /** + * Creates the Paint object for drawing the translucent overlay outside the + * crop window. + * + * @param context the Context + * @return the new Paint object + */ + public static Paint newBackgroundPaint(Context context) { + + final Paint paint = new Paint(); + paint.setColor(Color.parseColor(DEFAULT_BACKGROUND_COLOR_ID)); + + return paint; + } + + /** + * Creates the Paint object for drawing the corners of the border + * + * @param context the Context + * @return the new Paint object + */ + public static Paint newCornerPaint(Context context) { + + // Set the line thickness for the crop window border. + final float lineThicknessPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, + DEFAULT_CORNER_THICKNESS_DP, + context.getResources().getDisplayMetrics()); + + final Paint cornerPaint = new Paint(); + cornerPaint.setColor(DEFAULT_CORNER_COLOR); + cornerPaint.setStrokeWidth(lineThicknessPx); + cornerPaint.setStyle(Paint.Style.STROKE); + + return cornerPaint; + } + + /** + * Returns the value of the corner thickness + * + * @return Float equivalent to the corner thickness + */ + public static float getCornerThickness() { + return DEFAULT_CORNER_THICKNESS_DP; + } + + /** + * Returns the value of the line thickness of the border + * + * @return Float equivalent to the line thickness + */ + public static float getLineThickness() { + return DEFAULT_LINE_THICKNESS_DP; + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/292bdb341b59bc4aaa68c5e7cdda92a31ff87db7.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/292bdb341b59bc4aaa68c5e7cdda92a31ff87db7.svn-base new file mode 100644 index 0000000..da0e7d4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/29/292bdb341b59bc4aaa68c5e7cdda92a31ff87db7.svn-base @@ -0,0 +1,182 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31075b05e0e6c9b6ba00c357d31a18d03de8df13.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31075b05e0e6c9b6ba00c357d31a18d03de8df13.svn-base new file mode 100644 index 0000000..224f4be --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31075b05e0e6c9b6ba00c357d31a18d03de8df13.svn-base @@ -0,0 +1,61 @@ +package com.adins.mss.foundation.camerainapp; + +import android.content.Context; +import android.graphics.PixelFormat; +import android.util.AttributeSet; +import android.view.SurfaceHolder; +import android.view.SurfaceView; + +import com.adins.mss.foundation.camerainapp.helper.Logger; + +/** + * Created by angga.permadi on 7/26/2016. + */ +public class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback { + + private Context mContext; + private SurfaceHolder mSurfaceHolder; + private CameraPresenter presenter; + + public CameraSurfaceView(Context context, AttributeSet attrs) { + super(context, attrs); + // TODO Auto-generated constructor stub + mContext = context; + mSurfaceHolder = getHolder(); + mSurfaceHolder.setFormat(PixelFormat.TRANSPARENT); + mSurfaceHolder.addCallback(this); + } + + @Override + public void surfaceCreated(SurfaceHolder holder) { + // TODO Auto-generated method stub + Logger.i(this, "surfaceCreated..."); + } + + @Override + public void surfaceChanged(SurfaceHolder holder, int format, int width, + int height) { + // TODO Auto-generated method stub + Logger.i(this, "surfaceChanged..."); + } + + @Override + public void surfaceDestroyed(SurfaceHolder holder) { + // TODO Auto-generated method stub + Logger.i(this, "surfaceDestroyed..."); + //CameraInterface.getInstance().doStopCamera(); + + if (presenter != null) { + presenter.stopCamera(); + } + } + + public void setPresenter(CameraPresenter presenter) { + this.presenter = presenter; + } + + public SurfaceHolder getSurfaceHolder() { + return mSurfaceHolder; + } + +} \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/3129bdd74e339395bb0bb2fc87e808780b8acf72.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/3129bdd74e339395bb0bb2fc87e808780b8acf72.svn-base new file mode 100644 index 0000000..f4f178c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/3129bdd74e339395bb0bb2fc87e808780b8acf72.svn-base @@ -0,0 +1,1140 @@ +package com.adins.mss.base.todolist.form.todaysplan; + + +import android.content.Context; +import android.os.Bundle; +import android.os.Handler; +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.constraintlayout.widget.ConstraintLayout; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentTransaction; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import androidx.appcompat.widget.Toolbar; +import android.text.format.DateFormat; +import android.util.DisplayMetrics; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.NewMainActivity; +import com.adins.mss.base.R; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.dynamicform.CustomerFragment; +import com.adins.mss.base.dynamicform.SurveyHeaderBean; +import com.adins.mss.base.dynamicform.TaskManager; +import com.adins.mss.base.timeline.TimelineImpl; +import com.adins.mss.base.todolist.ToDoList; +import com.adins.mss.base.todolist.form.AllHeaderViewerFragment; +import com.adins.mss.base.todolist.form.MapsViewerFragment; +import com.adins.mss.base.todolist.form.OnTaskListClickListener; +import com.adins.mss.base.todolist.form.PriorityTabFragment; +import com.adins.mss.base.todolist.form.TaskListTabInteractor; +import com.adins.mss.base.todolist.form.TasklistImpl; +import com.adins.mss.base.todolist.form.TasklistInterface; +import com.adins.mss.base.todolist.form.TasklistListener; +import com.adins.mss.base.todolist.form.TasklistView; +import com.adins.mss.base.todolist.form.helper.TaskFilterParam; +import com.adins.mss.base.todolist.form.helper.TaskPlanFilterObservable; +import com.adins.mss.base.todolist.form.helper.TaskPlanFilterObserver; +import com.adins.mss.base.todolist.form.todaysplan.dummytaskplan.DummyPlan; +import com.adins.mss.base.todolist.todayplanrepository.IPlanTaskDataSource; +import com.adins.mss.base.todolist.todayplanrepository.ResponseStartVisit; +import com.adins.mss.base.todolist.todayplanrepository.TodayPlanRepository; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.PlanTask; +import com.adins.mss.dao.Scheme; +import com.adins.mss.dao.TaskD; +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.UserHelp.Bean.UserHelpView; +import com.adins.mss.foundation.UserHelp.UserHelp; +import com.adins.mss.foundation.db.dataaccess.PlanTaskDataAccess; +import com.adins.mss.foundation.db.dataaccess.SchemeDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskDDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.dialog.DialogManager; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder_PL; +import com.adins.mss.foundation.formatter.Tool; + +import org.acra.ACRA; + +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.List; + +import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; + +/** + * A simple {@link Fragment} subclass. + */ +public class TodayPlanFragment extends Fragment implements OnTaskListClickListener + ,TodayPlanHandler, View.OnClickListener, + TasklistListener, + TaskListTabInteractor.TabPage, + TodayPlanAdapter.OnPlanDeletedListener, TodayPlanRepository.PlanTaskRepoListener + , TaskPlanFilterObserver { + + //android view widget + private RecyclerView taskListRecycler; + private LinearLayout itemControlPanel; + private LinearLayout confirmPlanBtnCont; + private ConstraintLayout tasklistPlanContent; + private ConstraintLayout noContentInfo; + private TextView planSelectedInfo; + private LinearLayoutManager linearLayoutManager; + + private TodayPlanAdapter todayPlanAdapter; + private int selectedPlanIdx = -1; + private String selectedTaskH; + private boolean inControlMode = false; + private boolean planInfoHideScheduled = false; + private int totalTaskList; + private boolean filterActive; + + private TaskListTabInteractor tabInteractor; + private List plannedTasks = new ArrayList<>(); + + private Menu mainMenu; + private TasklistInterface iTasklist; + private NiftyDialogBuilder dialogBuilder; + private TimelineImpl iTimeline; + private TodayPlanRepository todayPlanRepo; + + private Handler handler; + private TaskPlanFilterObservable filterObservable; + private TaskFilterParam lastFilterParam; + + private static final String TASK_LIST_TAB_USERHELP = "PlanTaskList"; + + public TodayPlanFragment() { + // Required empty public constructor + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View todayPlanView = inflater.inflate(R.layout.fragment_today_plan, container, false); + noContentInfo = todayPlanView.findViewById(R.id.noPlanTaskContent); + Button goToTasklistBtn = todayPlanView.findViewById(R.id.goToTasklistBtn); + goToTasklistBtn.setOnClickListener(this); + confirmPlanBtnCont = todayPlanView.findViewById(R.id.confirmPlanBtnCont); + Button confirmButton = todayPlanView.findViewById(R.id.confirmPlanBtn); + confirmButton.setOnClickListener(this); + tasklistPlanContent = todayPlanView.findViewById(R.id.tasklistPlanContent); + taskListRecycler = todayPlanView.findViewById(R.id.planList); + linearLayoutManager = new LinearLayoutManager(getActivity()); + taskListRecycler.setLayoutManager(linearLayoutManager); + setScrollListener(); + planSelectedInfo = todayPlanView.findViewById(R.id.planSelectedInfo); + ImageView topBtn = todayPlanView.findViewById(R.id.toTopBtn); + topBtn.setOnClickListener(this); + + ImageView botBtn = todayPlanView.findViewById(R.id.toBottomBtn); + botBtn.setOnClickListener(this); + + ImageView downBtn = todayPlanView.findViewById(R.id.downBtn); + downBtn.setOnClickListener(this); + + ImageView upBtn = todayPlanView.findViewById(R.id.upBtn); + upBtn.setOnClickListener(this); + + ImageView doneMoveBtn = todayPlanView.findViewById(R.id.doneMoveBtn); + doneMoveBtn.setOnClickListener(this); + + itemControlPanel = todayPlanView.findViewById(R.id.itemControlPanel); + itemControlPanel.setVisibility(View.GONE); + + return todayPlanView; + } + + @Override + public void onAttach(Context context) { + super.onAttach(context); + + iTasklist = new TasklistImpl(this, this); + iTimeline = new TimelineImpl(getActivity()); + iTimeline.setCashOnHand(); + todayPlanRepo = GlobalData.getSharedGlobalData().getTodayPlanRepo(); + setHasOptionsMenu(true); + } + + @Override + public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + + filterObservable = tabInteractor.getFilterObservable(); + if(filterObservable != null) + filterObservable.subscribeEvent(this); + todayPlanRepo.addListener(this); + + if (Global.ENABLE_USER_HELP && needShowTabUserHelp()) { + showTaskPlanUserHelp(); + } + else { + loadPlanTasks(); + } + } + + @Override + public void onPrepareOptionsMenu(Menu menu) { + super.onPrepareOptionsMenu(menu); + mainMenu = menu; + menu.findItem(R.id.menuMore).setVisible(true); + if (checkUserHelpAvailability()) { + menu.findItem(com.adins.mss.base.R.id.mnGuide).setVisible(true); + } + setToolbar(); + } + + private void showPlanInfo(boolean autoHide){ + planSelectedInfo.setVisibility(View.VISIBLE); + if(!autoHide){ + planInfoHideScheduled = false; + return; + } + + if(planInfoHideScheduled) + return; + + if(handler == null){ + handler = new Handler(); + } + planInfoHideScheduled = true; + handler.postDelayed(new Runnable() { + @Override + public void run() { + //check if schedule hide is canceled + if(!planInfoHideScheduled) + return; + + planSelectedInfo.setVisibility(View.GONE); + planInfoHideScheduled = false; + } + },2000); + } + + private void setScrollListener(){ + taskListRecycler.addOnScrollListener(new RecyclerView.OnScrollListener() { + @Override + public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) { + switch (newState){ + case RecyclerView.SCROLL_STATE_IDLE: + break; + case RecyclerView.SCROLL_STATE_DRAGGING: + showPlanInfo(true); + break; + case RecyclerView.SCROLL_STATE_SETTLING: + break; + default: + break; + } + } + + @Override + public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) { + int firstVisPos = linearLayoutManager.findFirstCompletelyVisibleItemPosition(); + if(firstVisPos == 0){//got to top + //permanent visible plan info + showPlanInfo(false); + } + } + }); + } + + private void setToolbar() { + getActivity().findViewById(R.id.search).setVisibility(View.VISIBLE); + getActivity().findViewById(R.id.spinner).setVisibility(View.GONE); + + // olivia : set tampilan toolbar untuk masing" density + DisplayMetrics displayMetrics = new DisplayMetrics(); + getActivity().getWindowManager().getDefaultDisplay().getMetrics(displayMetrics); + switch (displayMetrics.densityDpi) { + case DisplayMetrics.DENSITY_MEDIUM: + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(200, WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_HIGH: + if(NewMainActivity.ismnGuideEnabled) + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(240, WRAP_CONTENT)); + else + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(300, WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XHIGH: + if(NewMainActivity.ismnGuideEnabled) + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(370, WRAP_CONTENT)); + else + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(470, WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XXHIGH: + if(NewMainActivity.ismnGuideEnabled) + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(560, WRAP_CONTENT)); + else + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(710, WRAP_CONTENT)); + break; + case DisplayMetrics.DENSITY_XXXHIGH: + if(NewMainActivity.ismnGuideEnabled) + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(750, WRAP_CONTENT)); + else + getActivity().findViewById(R.id.search).setLayoutParams(new Toolbar.LayoutParams(950, WRAP_CONTENT)); + break; + default: + break; + } + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + // Handle item selection + if (item.getItemId() == R.id.mnGuide && !Global.BACKPRESS_RESTRICTION) { + UserHelp.reloadUserHelp(getActivity(), TodayPlanFragment.class.getSimpleName()); + if (needShowTabUserHelp()) { + showTaskPlanUserHelp(); + } + } + if (!PriorityTabFragment.isIsMenuClicked()) { + int id = item.getItemId(); + if (id == R.id.menuMore) { + mainMenu.findItem(R.id.mnViewMap).setVisible(true); + PriorityTabFragment.setIsMenuClicked(false); + } + + if (id == R.id.mnViewMap) { + MapsViewerFragment fragment = new MapsViewerFragment(); + fragment.setTodayPlanHandler(this); + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + PriorityTabFragment.setIsMenuClicked(true); + } + // olivia : menu View All Header sdh tidak digunakan karena hampir sama dgn Task List + else if (id == R.id.mnViewAllHeader) { + AllHeaderViewerFragment viewerFragment = AllHeaderViewerFragment.newInstance(AllHeaderViewerFragment.REQ_PRIORITY_LIST); + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, viewerFragment); + transaction.addToBackStack(null); + transaction.commit(); + PriorityTabFragment.setIsMenuClicked(true); + } + + } + return super.onOptionsItemSelected(item); + } + + public void setTabInteractor(TaskListTabInteractor tabInteractor) { + this.tabInteractor = tabInteractor; + } + + private void processItemClicked(TaskH item){ + try { + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (Global.APPLICATION_COLLECTION.equalsIgnoreCase(application) && iTimeline.isCOHAktif() && iTimeline.getLimit() > 0 && iTimeline.getCashOnHand() >= iTimeline.getLimit()) { + DialogManager.showAlertNotif(getActivity(), getActivity().getString(R.string.limit_coh), "Cash On Hand"); + return; + } + + Scheme scheme = null; + scheme = item.getScheme(); + if (scheme == null) { + Toast.makeText(getActivity(), getActivity().getString(R.string.task_cant_seen), + Toast.LENGTH_SHORT).show(); + return; + } + + if (item.getUuid_scheme() == null){ + return; + } + + scheme = SchemeDataAccess.getOne(getActivity(), item.getUuid_scheme()); + if (scheme == null) + return; + + item.setScheme(scheme); + if (Boolean.FALSE.equals(GlobalData.getSharedGlobalData().getDoingTask())) { + SurveyHeaderBean header = new SurveyHeaderBean(item); + CustomerFragment fragment = CustomerFragment.create(header); + if(scheme.getForm_type().equals("KTP")) { + CustomerFragment.setHeader(header); + fragment.gotoNextDynamicForm(this.getActivity()); + } else{ + FragmentTransaction transaction = NewMainActivity.fragmentManager.beginTransaction(); + transaction.setCustomAnimations(R.anim.activity_open_translate, R.anim.activity_close_scale, R.anim.activity_open_scale, R.anim.activity_close_translate); + transaction.replace(R.id.content_frame, fragment); + transaction.addToBackStack(null); + transaction.commit(); + } + } + + } catch (Exception e) { + FireCrash.log(e); + ACRA.getErrorReporter().putCustomData("errorClickListener", e.getMessage()); + ACRA.getErrorReporter().putCustomData("errorClickListener", DateFormat.format("yyyy.MM.dd G \'at\' HH:mm:ss z", Calendar.getInstance().getTime()).toString()); + ACRA.getErrorReporter().handleSilentException(new Exception("Exception saat click item")); + String message = e.getMessage(); + Toast.makeText(getActivity(), message, Toast.LENGTH_SHORT).show(); + } + } + + @Override + public void onItemClickListener(TaskH item, int position) { + if(!Global.isPlanStarted()){ + if(inControlMode){ + return; + } + Toast.makeText(getActivity(), getString(R.string.pls_start_visit), Toast.LENGTH_SHORT).show(); + return; + } + + if (Global.isLockTask() || Global.BACKPRESS_RESTRICTION) return; + processItemClicked(item); + } + + @Override + public void onItemLongClickListener(TaskH item, int position) { + if(Global.isPlanStarted()){ + onItemLongClickAfterStart(item,position); + return; + } + + if(inControlMode)//cannot select another or same item while control mode active + return; + + //hide confirm button + confirmPlanBtnCont.setVisibility(View.GONE); + //show move tools + itemControlPanel.setVisibility(View.VISIBLE); + selectedPlanIdx = position; + selectedTaskH = item.getUuid_task_h(); + inControlMode = true; + } + + private void handleLongClickUploading(final TaskH item){ + try { + dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.info_capital)) + .withMessage(getActivity().getString(R.string.confirm_upload) + " " + item.getCustomer_name() + " ?") + .withButton1Text(getActivity().getString(R.string.btnYes)) + .withButton2Text(getActivity().getString(R.string.btnCancel)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + if (!Tool.isInternetconnected(getActivity())){ + Toast.makeText(getActivity(), getActivity().getString(R.string.no_internet_connection), Toast.LENGTH_SHORT).show(); + return; + } + + if (Global.isIsUploading() || Global.isIsManualUploading()) { + Toast.makeText(getActivity(), getActivity().getString(R.string.upload_on_queue), Toast.LENGTH_SHORT).show(); + return; + } + + try { + List taskd = TaskDDataAccess.getUnsentImageByTaskH(getActivity(), item.getUuid_user(), item.getUuid_task_h()); + TaskManager.ManualUploadImage(getActivity(), taskd); + for (int i = 1; i < getActivity().getSupportFragmentManager().getBackStackEntryCount(); i++) + getActivity().getSupportFragmentManager().popBackStack(); + } catch (Exception e) { + FireCrash.log(e); + Toast.makeText(getActivity(), getActivity().getString(R.string.request_error), Toast.LENGTH_SHORT).show(); + } + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + private void forceSendVerifTask(TaskH item){ + if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK)) + new TaskManager.ApproveTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK, false, item.getVerification_notes()).execute(); + else if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY)) + new TaskManager.RejectWithReSurveyTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY, Global.VERIFICATION_FLAG).execute(); + else + new TaskManager.ForceSendTaskOnBackground(getActivity(), item.getTask_id()).execute(); + } + + private void forceSendApprovalTask(TaskH item) { + if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK)) + new TaskManager.ApproveTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK, true, item.getVerification_notes()).execute(); + else if (item.getFlag_survey() != null && item.getFlag_survey().equals(Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY)) + new TaskManager.RejectWithReSurveyTaskOnBackground(getActivity(), item, Global.FLAG_FOR_REJECTEDTASK_WITHRESURVEY, Global.APPROVAL_FLAG).execute(); + else + new TaskManager.ApproveTaskOnBackground(getActivity(), item, Global.FLAG_FOR_APPROVALTASK, true, item.getVerification_notes()).execute(); + } + + private void handleLongClickPending(final TaskH item, final int position){ + String btnText1 = null; + if (item.getIs_prepocessed() == null){ + btnText1 = getActivity().getString(R.string.btnSend); + } + else if (item.getIs_prepocessed().equals(Global.FORM_TYPE_VERIFICATION)) + btnText1 = getActivity().getString(R.string.verifyBtn); + else if (item.getIs_prepocessed().equals(Global.FORM_TYPE_APPROVAL)) + btnText1 = getActivity().getString(R.string.approveBtn); + + final NiftyDialogBuilder_PL dialogBuilderNoTitle = NiftyDialogBuilder_PL.getInstance(getActivity()); + dialogBuilderNoTitle.withNoTitle() + .withNoMessage() + .withButton1Text(btnText1) + .withButton2Text(getActivity().getString(R.string.btnDelete)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilderNoTitle.dismiss(); + if (!Tool.isInternetconnected(getActivity())){ + Toast.makeText(getActivity(), getActivity().getString(R.string.no_internet_connection), Toast.LENGTH_SHORT).show(); + return; + } + + if (item.getTask_id() == null) { + return; + } + + if (item.getIs_prepocessed() == null){ + new TaskManager.ForceSendTaskOnBackground(getActivity(), item.getUuid_task_h()).execute(); + } + else if (item.getIs_prepocessed().equals(Global.FORM_TYPE_VERIFICATION)) { + forceSendVerifTask(item); + } else if (item.getIs_prepocessed().equals(Global.FORM_TYPE_APPROVAL)) { + forceSendApprovalTask(item); + } + + for (int i = 1; i < getActivity().getSupportFragmentManager().getBackStackEntryCount(); i++) + getActivity().getSupportFragmentManager().popBackStack(); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + todayPlanAdapter.delete(position); + TaskHDataAccess.deleteWithRelation(getActivity(), item); + if (item.getTask_id() != null) + ToDoList.removeSurveyFromList(item.getTask_id()); + dialogBuilderNoTitle.dismiss(); + } + }).show(); + } + + private void handleLongClickDraft(final TaskH item, final int position){ + dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.info_capital)) + .withMessage(getActivity().getString(R.string.confirm_delete) + " " + item.getCustomer_name() + " ?") + .withButton1Text(getActivity().getString(R.string.btnYes)) + .withButton2Text(getActivity().getString(R.string.btnCancel)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + todayPlanAdapter.delete(position); + TaskHDataAccess.deleteWithRelation(getActivity(), item); + ToDoList.removeSurveyFromList(item.getTask_id()); + if(Global.PLAN_TASK_ENABLED){ + plannedTasks.remove(position); + planSelectedInfo.setText(getString(R.string.planned_info,todayPlanAdapter.getListTaskh().size(),totalTaskList)); + todayPlanRepo.setHasDeletedPlanTask(true); + } + dialogBuilder.dismiss(); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } + + private void processItemLongClicked(final TaskH item, final int position){ + if (item.getStatus().equals(TaskHDataAccess.STATUS_SEND_UPLOADING)) { + handleLongClickUploading(item); + } else if (item.getStatus().equals(TaskHDataAccess.STATUS_SEND_PENDING)) { + handleLongClickPending(item,position); + } else if (item.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT)) { + handleLongClickDraft(item,position); + } + } + + private void onItemLongClickAfterStart(TaskH item,int position){ + try { + processItemLongClicked(item,position); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + @Override + public void addToPlan(List planTasks) { + noContentInfo.setVisibility(View.GONE); + tasklistPlanContent.setVisibility(View.VISIBLE); + + String uuidUser = GlobalData.getSharedGlobalData().getUser().getUuid_user(); + for(int i=0; i getCurrentPlans() { + return plannedTasks; + } + + @Override + public int getAllPlansCount() { + int planCount = 0; + if(Global.isPlanStarted()){ + planCount = todayPlanRepo.getLastPlanSequenceNo(); + } + else { + planCount = todayPlanRepo.getLastPlansCount(); + } + return planCount; + } + + //task item move navigation + private void moveTop(){ + if(selectedPlanIdx == -1) + return; + selectedPlanIdx = todayPlanAdapter.moveItemToTop(selectedPlanIdx); + linearLayoutManager.scrollToPositionWithOffset(selectedPlanIdx,1); + } + + private void moveBottom(){ + if(selectedPlanIdx == -1) + return; + selectedPlanIdx = todayPlanAdapter.moveItemToBottom(selectedPlanIdx); + linearLayoutManager.scrollToPositionWithOffset(selectedPlanIdx,1); + } + + private void moveUp(){ + if(selectedPlanIdx == -1) + return; + int topIdx = selectedPlanIdx - 1; + selectedPlanIdx = todayPlanAdapter.moveItemFromTo(selectedPlanIdx,topIdx); + linearLayoutManager.scrollToPositionWithOffset(selectedPlanIdx,1); + } + + private void moveDown(){ + if(selectedPlanIdx == -1) + return; + int downIdx = selectedPlanIdx + 1; + selectedPlanIdx = todayPlanAdapter.moveItemFromTo(selectedPlanIdx,downIdx); + linearLayoutManager.scrollToPositionWithOffset(selectedPlanIdx,1); + } + + private void doneMoveControl(){ + inControlMode = false; + todayPlanAdapter.deselectItem(selectedTaskH,selectedPlanIdx); + + //save new sequence state + for(int i=0; i() { + @Override + public void onResult(ResponseStartVisit result) { + onStartVisitSuccess(result); + } + + @Override + public void onError(String error) { + onStartVisitError(error); + } + }); + } + + private void onStartVisitSuccess(ResponseStartVisit result){ + if(result != null){//sukses + todayPlanRepo.setStartVisit(true);//has started visit online + todayPlanRepo.setNeedSync(false);//no need to sync + confirmPlanBtnCont.setVisibility(View.GONE); + //show dialog + if (!Global.isPlanStarted()) { + if (dialogBuilder == null) { + dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + } + dialogBuilder.withTitle(getString(R.string.success)).withMessage(getString(R.string.plan_started)).show(); + } + + //reset filter + if(filterActive && filterObservable != null){ + filterActive = false; + filterObservable.setSearchFilterText(0,0); + } + //update plan on local db + todayPlanRepo.updatePlan(plannedTasks); + Global.setPlanStarted(true); + } + } + + private void onStartVisitError(String error){ + if(GlobalData.isRequireRelogin()){ + DialogManager.showForceExitAlert(getActivity(),getString(R.string.msgLogout)); + return; + } + if(error.equals("Offline")){//offline mode + confirmPlanBtnCont.setVisibility(View.GONE); + + if(!todayPlanRepo.isStartVisit())//if has not been start visit online before, set to false + todayPlanRepo.setStartVisit(false); + + todayPlanRepo.setNeedSync(true);//need sync when online + + //show dialog + if (!Global.isPlanStarted()) { + if (dialogBuilder == null) { + dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + } + dialogBuilder.withTitle(getString(R.string.success)).withMessage(getString(R.string.plan_started)).show(); + } + + //update plan on local db + todayPlanRepo.updatePlan(plannedTasks); + Global.setPlanStarted(true); + return; + } + //error + Toast.makeText(getActivity(), error, Toast.LENGTH_SHORT).show(); + } + + @Override + public void onRefreshBackgroundCancelled(boolean value) { + throw new UnsupportedOperationException(); + } + + @Override + public void onRefreshBackgroundComplete(List result) { + throw new UnsupportedOperationException(); + } + + + @Override + public String getTabPageName() { + return TasklistView.TODAYSPLAN_TAB_PAGE_TAG; + } + + @Override + public void onEnterPage() { + if(Global.PLAN_TASK_ENABLED){ + if(plannedTasks.isEmpty()) { + confirmPlanBtnCont.setVisibility(View.GONE); + tasklistPlanContent.setVisibility(View.GONE); + noContentInfo.setVisibility(View.VISIBLE); + } + if(Global.ENABLE_USER_HELP && needShowTabUserHelp()) { + showTaskPlanUserHelp(); + } + } + } + + @Override + public void onLeavePage() { + if(selectedTaskH == null || selectedTaskH.equals("")) + return; + if(selectedPlanIdx == -1) + return; + //remove control before leave today plan page + doneMoveControl(); + } + + @Override + public void onDestroyView() { + onLeavePage(); + //unsubscribe filter event when view destroyed + if(filterObservable != null){ + if(filterActive){ + filterActive = false; + filterObservable.setSearchFilterText(0,0); + } + //unsubscribe observer + filterObservable.unsubscribeEvent(this); + } + + todayPlanRepo.removeListener(this); + super.onDestroyView(); + } + + @Override + public void onPlanDeleted(final TaskH taskH, final int position) { + dialogBuilder = NiftyDialogBuilder.getInstance(getActivity()); + dialogBuilder.withTitle(getActivity().getString(R.string.info_capital)) + .withMessage(getActivity().getString(R.string.confirm_delete) + " " + taskH.getCustomer_name() + " " + getString(R.string.from_todays_plan)) + .withButton1Text(getActivity().getString(R.string.btnYes)) + .withButton2Text(getActivity().getString(R.string.btnCancel)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + PlanTask removedPlan = plannedTasks.remove(position); + if(removedPlan == null) + return; + + PlanTaskDataAccess.removePlan(getActivity(),removedPlan); + handler = new Handler(); + handler.postDelayed(new Runnable() { + @Override + public void run() { + todayPlanRepo.updateLastPlansCount();//update only last count of plans because delete only happen before start visit + } + },300); + + todayPlanAdapter.delete(position); + if(plannedTasks.isEmpty()){ + confirmPlanBtnCont.setVisibility(View.GONE); + tasklistPlanContent.setVisibility(View.GONE); + noContentInfo.setVisibility(View.VISIBLE); + } + planSelectedInfo.setText(getString(R.string.planned_info,plannedTasks.size(),totalTaskList)); + Toast.makeText(getActivity(), getActivity().getString(R.string.successfully_removed_task, taskH.getCustomer_name()), Toast.LENGTH_SHORT).show(); + dialogBuilder.dismiss(); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } + + @Override + public void onRepoChange(List plans) { + if(UserHelp.isActive || inControlMode) + return; + + List taskhDataset = new ArrayList<>(); + plannedTasks = plans;//update plan dataset from repo + + for(PlanTask planTask : plannedTasks){ + if(planTask != null){ + TaskH taskH = TaskHDataAccess.getOneUnsentTaskHeader(getActivity(),planTask.getUuid_task_h()); + if(taskH == null) + continue; + taskhDataset.add(taskH); + } + } + + if(filterActive){ + filterPlan(lastFilterParam); + } + else if(todayPlanAdapter == null) { + todayPlanAdapter = new TodayPlanAdapter(getActivity() + ,taskhDataset + ,this,this,""); + } + else{ + todayPlanAdapter.changeDataset(taskhDataset); + } + linearLayoutManager = new LinearLayoutManager(getActivity()); + taskListRecycler.setLayoutManager(linearLayoutManager); + taskListRecycler.setAdapter(todayPlanAdapter); + + planSelectedInfo.setText(getString(R.string.planned_info,plannedTasks.size(),totalTaskList)); + showPlanInfo(false); + if(Global.isPlanStarted()){ + confirmPlanBtnCont.setVisibility(View.GONE); + } + else { + confirmPlanBtnCont.setVisibility(View.VISIBLE); + } + + if(taskhDataset.isEmpty()){ + tasklistPlanContent.setVisibility(View.GONE); + noContentInfo.setVisibility(View.VISIBLE); + confirmPlanBtnCont.setVisibility(View.GONE); + todayPlanRepo.setStartVisit(false); + } + } + + @Override + public void onError(String errMsg) { + throw new UnsupportedOperationException(); + } + + private boolean userHelpMode = false; + public static boolean needShowTabUserHelp() { + List userHelpViews = Global.userHelpGuide.get(TodayPlanFragment.class.getSimpleName()); + return Global.ENABLE_USER_HELP && userHelpViews != null && !userHelpViews.isEmpty(); + } + + private UserHelp.OnSequenceShowed userHelpShowCallback = new UserHelp.OnSequenceShowed() { + @Override + public void onSequenceShowed(String prevUserHelp, String currentShowUserHelp, int index) { + if(currentShowUserHelp.equals("slidingTabLayout")){ + tasklistPlanContent.setVisibility(View.GONE); + confirmPlanBtnCont.setVisibility(View.GONE); + } + else if(currentShowUserHelp.equals("goToTasklistBtn")){ + tasklistPlanContent.setVisibility(View.VISIBLE); + confirmPlanBtnCont.setVisibility(View.VISIBLE); + noContentInfo.setVisibility(View.VISIBLE); + List dummyPlans = TodayPlanDummyAdapter.createDefaultDummyDataset(1,true); + planDummyAdapter.setDummyDataset(dummyPlans); + } + else if(currentShowUserHelp.equals("dummyDeletePlanBtn")){ + noContentInfo.setVisibility(View.GONE); + } + else if(currentShowUserHelp.equals("confirmPlanBtn")){ + //hide delete button on dummy plan item + List dummyPlans = TodayPlanDummyAdapter.createDefaultDummyDataset(2,false); + planDummyAdapter.setDummyDataset(dummyPlans); + planSelectedInfo.setVisibility(View.GONE); + } + } + }; + + private UserHelp.OnShowSequenceFinish userHelpFinishCallback = new UserHelp.OnShowSequenceFinish() { + @Override + public void onSequenceFinish() { + userHelpMode = false; + tasklistPlanContent.setVisibility(View.VISIBLE); + noContentInfo.setVisibility(View.GONE); + confirmPlanBtnCont.setVisibility(View.GONE); + loadPlanTasks();//load plan tasks + } + }; + + TodayPlanDummyAdapter planDummyAdapter; + public void showTaskPlanUserHelp(){ + userHelpMode = true; + //create dummy adapter + List dummyPlans = TodayPlanDummyAdapter.createDefaultDummyDataset(2,false); + planDummyAdapter = new TodayPlanDummyAdapter(getActivity(),dummyPlans); + taskListRecycler.setAdapter(planDummyAdapter); + tasklistPlanContent.setVisibility(View.VISIBLE); + confirmPlanBtnCont.setVisibility(View.VISIBLE); + noContentInfo.setVisibility(View.VISIBLE); + planSelectedInfo.setVisibility(View.GONE); + + handler = new Handler(); + handler.postDelayed(new Runnable() { + @Override + public void run() { + //start user help sequences + UserHelp.showAllUserHelp(getActivity(), TodayPlanFragment.class.getSimpleName(),taskListRecycler,userHelpShowCallback,userHelpFinishCallback); + } + },200); + } + + @Override + public void onFilterApplied(TaskFilterParam filterData) { + if(filterData == null) + return; + + filterActive = true; + //hide selected plan info + planSelectedInfo.setVisibility(View.GONE); + lastFilterParam = filterData; + iTasklist.setSelectedScheme(filterData.getScheme()); + iTasklist.setSelectedTask(filterData.getSearchType()); + filterPlan(filterData); + } + + private void filterPlan(TaskFilterParam filterParam){ + //check if filter is reset + if(filterParam.getScheme().getUuid_scheme().equals(PriorityTabFragment.uuidSchemeDummy) + && filterParam.getSearchType() <= 0 && filterParam.getCustomerName().isEmpty() + && filterParam.getPtp() <= 0 && filterParam.getOsFrom().isEmpty() + && filterParam.getTenorFrom().isEmpty()){//if reset, load plan as default + filterActive = false; + planSelectedInfo.setVisibility(View.VISIBLE); + todayPlanRepo.loadPlans(); + return; + } + + List filteredPlan; + filteredPlan = TaskHDataAccess.getTaskhPlanFilter( + getActivity().getApplicationContext() + ,filterParam.getScheme().getUuid_scheme() + ,filterParam.getSearchType(), filterParam.getPtp() + , filterParam.getTenorFrom(), filterParam.getTenorTo() + , filterParam.getOsFrom(), filterParam.getOsTo() + , filterParam.getCustomerName()); + + List todayPlan = PlanTaskDataAccess.getAllPlan(getActivity().getApplicationContext(), GlobalData.getSharedGlobalData().getUser().getUuid_user()); + for (PlanTask planTask : todayPlan){ + String planTaskH = planTask.getUuid_task_h(); + } + + if(todayPlanAdapter != null){//update adapter + todayPlanAdapter.changeDataset(filteredPlan); + linearLayoutManager = new LinearLayoutManager(getActivity()); + taskListRecycler.setLayoutManager(linearLayoutManager); + taskListRecycler.setAdapter(todayPlanAdapter); + } + } + + private boolean checkUserHelpAvailability() { + List userHelpViews = Global.userHelpGuide.get(TodayPlanFragment.class.getSimpleName()); + return Global.ENABLE_USER_HELP && userHelpViews != null; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/313236cff3c240b9c4c53e75c64513469bb33f23.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/313236cff3c240b9c4c53e75c64513469bb33f23.svn-base new file mode 100644 index 0000000..e4ee8e2 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/313236cff3c240b9c4c53e75c64513469bb33f23.svn-base @@ -0,0 +1,40 @@ +package com.adins.mss.base.dynamicform.form.models; + +import com.google.gson.annotations.SerializedName; + +/** + * Created by gigin.ginanjar on 11/10/2016. + */ + +public class Parameter { + @SerializedName("refId") + private String refId; + @SerializedName("flag") + private String flag; + @SerializedName("answer") + private String answer; + + public String getRefId() { + return refId; + } + + public void setRefId(String refId) { + this.refId = refId; + } + + public String getFlag() { + return flag; + } + + public void setFlag(String flag) { + this.flag = flag; + } + + public String getAnswer() { + return answer; + } + + public void setAnswer(String answer) { + this.answer = answer; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31771b6cc3f33727c916031533e10504100b3f43.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31771b6cc3f33727c916031533e10504100b3f43.svn-base new file mode 100644 index 0000000..7b1dae4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31771b6cc3f33727c916031533e10504100b3f43.svn-base @@ -0,0 +1,19 @@ +package com.adins.mss.base.todolist; + +import com.adins.mss.foundation.http.MssRequestType; +import com.google.gson.annotations.SerializedName; + +public class RequestQuestionSetBean extends MssRequestType { + @SerializedName("formId") + String formId; + + public String getFormId() { + return formId; + } + + public void setFormId(String formId) { + this.formId = formId; + } + + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31b29defa48adb2a3f3c2cb80384de78e8e8bd9d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31b29defa48adb2a3f3c2cb80384de78e8e8bd9d.svn-base new file mode 100644 index 0000000..60a3fc4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31b29defa48adb2a3f3c2cb80384de78e8e8bd9d.svn-base @@ -0,0 +1,14 @@ + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31c8f3acf7f213782fc03ff467fd07124c5fc733.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31c8f3acf7f213782fc03ff467fd07124c5fc733.svn-base new file mode 100644 index 0000000..8bd1f7c --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31c8f3acf7f213782fc03ff467fd07124c5fc733.svn-base @@ -0,0 +1,91 @@ +package com.adins.mss.base.loyalti.barchart; + +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; + +import com.adins.mss.base.loyalti.model.RankDetail; + +import com.github.mikephil.charting.buffer.BarBuffer; +import com.github.mikephil.charting.charts.BarChart; +import com.github.mikephil.charting.data.BarEntry; +import com.github.mikephil.charting.interfaces.datasets.IBarDataSet; +import com.github.mikephil.charting.renderer.BarChartRenderer; + +public class LoyaltyBarChartRenderer extends BarChartRenderer { + + private RankDetail[][] rankDataSet; + private Paint textPaint; + private float textSizeMultiplier; + private float textOffset; + + public LoyaltyBarChartRenderer(BarChart chart, RankDetail[][] rankDataSet, float textSizeMultiplier, float textOffset) { + super(chart, chart.getAnimator(), chart.getViewPortHandler()); + this.rankDataSet = rankDataSet; + this.textPaint = new Paint(); + this.textSizeMultiplier = textSizeMultiplier; + this.textOffset = textOffset; + textPaint.setColor(Color.BLACK); + } + + @Override + protected void drawDataSet(Canvas c, IBarDataSet dataSet, int index) { + super.drawDataSet(c, dataSet, index);//draw default bar dimulai dari index x = 0 + drawRanksText(c,dataSet,index);//tambah draw rank disini + } + + private void drawRanksText(Canvas canvas,IBarDataSet dataSet,int index){ + BarBuffer buffer = mBarBuffers[index]; + + float left;//simpan pos kiri bar + float right;//simpan pos kanan bar + float bottom;//simpan pos bawah bar + float offsetLeft; + float marginPerRank; + int stackLength; + + for (int j = 0; j < buffer.buffer.length * mAnimator.getPhaseX(); j += (4*stackLength)) { + if(rankDataSet == null || index >= rankDataSet.length) + break; + + stackLength = getStackLength(dataSet,index);//dapatkan length stack bar di xAxis=index untuk menentukan nilai buffer j selanjutnya. + if(stackLength == 0) + break; + + left = buffer.buffer[j]; + right = buffer.buffer[j + 2]; + bottom = buffer.buffer[j + 3]; + + float x = (left + right) / 2f; + float barWidth = right-left; + if (!mViewPortHandler.isInBoundsRight(x) || !mViewPortHandler.isInBoundsLeft(x)){//render rank dimulai dari nilai coordinate(pixel) x bar yang terlihat di viewport + index += 1; + continue; + } + + textPaint.setTextSize(barWidth * textSizeMultiplier); + marginPerRank = textPaint.getTextSize(); + offsetLeft = barWidth + textOffset; + + //draw ranks text from bottom to top of bar + for (int r=0; r dataSet.getXMax()){ + return 0; + } + BarEntry entry = dataSet.getEntryForIndex(xIndex); + return entry.getYVals().length;//dapatkan length stack untuk index bar berikutnya + } + + private void drawText(RankDetail rankData,Canvas c,float x, float y){ + textPaint.setColor(rankData.colorValue); + c.drawText(String.valueOf(rankData.rank),x,y,textPaint); + } +} + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d04528ea2991378b475b7f7bdde250a7c52738.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d04528ea2991378b475b7f7bdde250a7c52738.svn-base new file mode 100644 index 0000000..6e37543 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d04528ea2991378b475b7f7bdde250a7c52738.svn-base @@ -0,0 +1,114 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d7210e97914ec7b16f7b7e35bdb53b71376004.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d7210e97914ec7b16f7b7e35bdb53b71376004.svn-base new file mode 100644 index 0000000..36b56cd --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31d7210e97914ec7b16f7b7e35bdb53b71376004.svn-base @@ -0,0 +1,18 @@ +package com.adins.mss.base.todolist; + +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.http.MssResponseType; +import com.google.gson.annotations.SerializedName; + +public class JsonOneTask extends MssResponseType { + @SerializedName("taskH") + private TaskH taskH; + + public TaskH getOneTaskH() { + return taskH; + } + + public void setOneTaskH(TaskH OneTaskH) { + this.taskH = OneTaskH; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31e4cb99c277bbda9b362d368709bfdb79e5b337.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31e4cb99c277bbda9b362d368709bfdb79e5b337.svn-base new file mode 100644 index 0000000..cae7a77 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31e4cb99c277bbda9b362d368709bfdb79e5b337.svn-base @@ -0,0 +1,52 @@ +package com.adins.mss.foundation.sync.api.model; + +/** + * Created by gigin.ginanjar on 23/03/2016. + */ +public class SynchronizeRequestModelWithConstraint extends SynchronizeRequestModel { + public String constraint1; + public String constraint2; + public String constraint3; + public String constraint4; + public String constraint5; + + public String getConstraint1() { + return constraint1; + } + + public void setConstraint1(String constraint1) { + this.constraint1 = constraint1; + } + + public String getConstraint2() { + return constraint2; + } + + public void setConstraint2(String constraint2) { + this.constraint2 = constraint2; + } + + public String getConstraint3() { + return constraint3; + } + + public void setConstraint3(String constraint3) { + this.constraint3 = constraint3; + } + + public String getConstraint4() { + return constraint4; + } + + public void setConstraint4(String constraint4) { + this.constraint4 = constraint4; + } + + public String getConstraint5() { + return constraint5; + } + + public void setConstraint5(String constraint5) { + this.constraint5 = constraint5; + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31f2e638298b2c77c2e1d8fe990a567d6806df4d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31f2e638298b2c77c2e1d8fe990a567d6806df4d.svn-base new file mode 100644 index 0000000..12f9e76 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/31/31f2e638298b2c77c2e1d8fe990a567d6806df4d.svn-base @@ -0,0 +1,33 @@ +package com.adins.mss.odr; + +import com.adins.mss.dao.MobileContentH; +import com.adins.mss.foundation.http.MssRequestType; +import com.google.gson.annotations.SerializedName; + +import java.util.List; + +public class JsonRequestNews extends MssRequestType{ + + @SerializedName("uuid_mobile_content_h") + String uuid_mobile_content_h; + @SerializedName("listContentHeader") + List listContentHeader; + + public List getListContentHeader() { + return listContentHeader; + } + public void setListContentHeader(List listContentHeader) { + this.listContentHeader = listContentHeader; + } + public String getuuid_mobile_content_h(){ + return uuid_mobile_content_h; + } + public void setuuid_mobile_content_h(String uuid_mobile_content_h){ + this.uuid_mobile_content_h = uuid_mobile_content_h; + } +// public class ContentHeader extends ContentHeaderBean{ +// public ContentHeader(MobileContentH contentH){ +// super(contentH); +// } +// } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/3207507df925f2c88e65b513346d70a7f4b3762d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/3207507df925f2c88e65b513346d70a7f4b3762d.svn-base new file mode 100644 index 0000000..6ff7bd4 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/3207507df925f2c88e65b513346d70a7f4b3762d.svn-base @@ -0,0 +1,704 @@ +package com.adins.mss.base.todolist.todayplanrepository; + +import android.content.Context; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.R; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.PlanTask; +import com.adins.mss.dao.TaskH; +import com.adins.mss.dao.Timeline; +import com.adins.mss.dao.TimelineType; +import com.adins.mss.foundation.db.dataaccess.PlanTaskDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskDDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.db.dataaccess.TimelineTypeDataAccess; +import com.adins.mss.foundation.dialog.DialogManager; +import com.adins.mss.foundation.formatter.Tool; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.Date; +import java.util.List; + +public class TodayPlanRepository implements Comparator { + + private List currentPlans; + private IPlanTaskDataSource dataSource; + private List listeners; + private Context context; + private int lastPlanSequenceNo; + private boolean isStartVisit; + private boolean needSync;//used for check if current plans has changed from last start visit + private String[] lastOffChangePlanInfo; + private boolean hasDeletedPlanTask; + + @Override + public int compare(PlanTask o1, PlanTask o2) { + return o1.getSequence() - o2.getSequence(); + } + + public interface PlanTaskRepoListener{ + void onRepoChange(List plans); + void onError(String errMsg); + } + + public TodayPlanRepository(Context context) { + this.context = context; + this.dataSource = new PlanTaskDataSource(context); + isStartVisit = dataSource.getStartVisitOnlineStatus(); + needSync = dataSource.getNeedSyncStatus(); + lastOffChangePlanInfo = dataSource.getLastOfflineChangePlan(); + } + + public void addListener(PlanTaskRepoListener listener){ + if(listeners == null){ + listeners = new ArrayList<>(); + } + if(listeners.contains(listener)){ + return;//has added to list of listeners + } + listeners.add(listener); + } + + public void removeListener(PlanTaskRepoListener listener){ + if(listeners == null){ + return; + } + listeners.remove(listener); + } + + public int getLastPlanSequenceNo() { + return lastPlanSequenceNo; + } + + public void updateLastPlanSequenceNo(){ + lastPlanSequenceNo = dataSource.getLastSequenceNo(); + } + + public int getLastPlansCount() { + return currentPlans.size(); + } + + public void updateLastPlansCount(){ + lastPlanSequenceNo = dataSource.getTotalPlanFromStart(); + } + + public boolean isStartVisit() { + return isStartVisit; + } + + public boolean isHasDeletedPlanTask() { + return hasDeletedPlanTask; + } + + public void setHasDeletedPlanTask(boolean hasDeletedPlanTask) { + this.hasDeletedPlanTask = hasDeletedPlanTask; + } + + public void setStartVisit(boolean startVisit) { + isStartVisit = startVisit; + dataSource.saveStartVisitOnlineStatus(isStartVisit); + } + + public boolean isNeedSync() { + return needSync; + } + + public void setNeedSync(boolean needSync) { + this.needSync = needSync; + dataSource.saveNeedSyncStatus(needSync); + } + + public String[] getLastOffChangePlanInfo() { + return lastOffChangePlanInfo; + } + + public void setLastOffChangePlanInfo(String[] lastOffChangePlanInfo) { + this.lastOffChangePlanInfo = lastOffChangePlanInfo; + if(lastOffChangePlanInfo == null) + dataSource.saveLastChangePlanOffline(null,null); + else{ + dataSource.saveLastChangePlanOffline(lastOffChangePlanInfo[0],lastOffChangePlanInfo[1]); + } + } + + private void applyChange(List planTasks){ + if(listeners != null && !listeners.isEmpty()){ + for (PlanTaskRepoListener listener:listeners){ + if(listener == null) + continue; + listener.onRepoChange(planTasks); + } + } + } + + private void applyChange(String message){ + if(listeners != null && !listeners.isEmpty()){ + for (PlanTaskRepoListener listener:listeners){ + if(listener == null) + continue; + listener.onError(message); + } + } + } + + private void decideStartedPlan(){ + for (PlanTask planTask:currentPlans) { + if(planTask.getPlan_status().equals(PlanTaskDataAccess.STATUS_STARTED)){ + Global.setPlanStarted(true); + Global.setCurrentPlanTask(planTask.getUuid_task_h()); + break; + } + } + } + + public void loadPlans(){ + dataSource.loadPlans(new IPlanTaskDataSource.Result>() { + @Override + public void onResult(List result) { + if(result == null) + return; + + lastPlanSequenceNo = dataSource.getLastSequenceNo(); + currentPlans = result; + decideStartedPlan(); + applyChange(result); + } + + @Override + public void onError(String error) { + applyChange(error); + } + }); + } + + public void updatePlan(final List planTasks){ + dataSource.updatePlanStatus(planTasks, new IPlanTaskDataSource.Result>() { + @Override + public void onResult(List result) { + //if plan status is finish -> decide next plan + if(result != null){ + currentPlans = result;//update cached result + for (PlanTask planTask:currentPlans) { + if(planTask.getPlan_status().equals(PlanTaskDataAccess.STATUS_STARTED)){ + Global.setPlanStarted(true); + Global.setCurrentPlanTask(planTask.getUuid_task_h()); + break; + } + } + applyChange(result); + } + } + + @Override + public void onError(String error) { + applyChange(error); + } + }); + } + + public void updatePlanByTaskH(TaskH taskH,String planStatus){ + if(taskH == null){ + return; + } + + if(planStatus.equals(PlanTaskDataAccess.STATUS_FINISH)){ + List updatedPlans = new ArrayList<>(); + + //update previous finish plan status to finish + PlanTask updatedPlan = getPlanTaskByTaskH(taskH.getTask_id()); + updatedPlan.setPlan_status(PlanTaskDataAccess.STATUS_FINISH); + updatedPlans.add(updatedPlan); + dataSource.updatePlanStatus(updatedPlans);//update plan + + if(!Global.getCurrentPlanTask().equals(updatedPlan.getUuid_task_h())){//jika plan aktif bukan plan yang berubah. + //no need decide next plan, remove plan from view + currentPlans.remove(updatedPlan); + updatePlanViewSequence(); + return; + } + + //if updated plan is active plan, decide next plan and remove current plan from view + PlanTask nextPlan = decideNextPlan(updatedPlan); + if(nextPlan != null){ + nextPlan.setPlan_status(PlanTaskDataAccess.STATUS_STARTED); + Global.setCurrentPlanTask(nextPlan.getUuid_task_h()); + updatedPlans.add(nextPlan); + }else { + Global.setCurrentPlanTask(null); + } + + //update plan view sequence + updatePlanViewSequence(); + } + else { + PlanTask updatedPlan = getPlanTaskByTaskH(taskH.getTask_id()); + updatedPlan.setPlan_status(planStatus); + List updatedPlans = new ArrayList<>(); + updatedPlans.add(updatedPlan); + updatePlan(updatedPlans); + } + } + + public void changeTaskhFromPlan(String oldUuidTaskH,String newUuidTaskH){ + PlanTask oldCurrentPlan = getPlanTaskByTaskH(oldUuidTaskH); + //create new copied plan for new task id + PlanTask newChangedIdPlan = new PlanTask(Tool.getUUID()); + newChangedIdPlan.setPlan_crt_date(oldCurrentPlan.getPlan_crt_date()); + newChangedIdPlan.setPlan_start_date(oldCurrentPlan.getPlan_start_date()); + newChangedIdPlan.setUuid_task_h(newUuidTaskH); + newChangedIdPlan.setPlan_status(oldCurrentPlan.getPlan_status()); + newChangedIdPlan.setSequence(oldCurrentPlan.getSequence()); + newChangedIdPlan.setUuid_user(oldCurrentPlan.getUuid_user()); + newChangedIdPlan.setView_sequence(oldCurrentPlan.getView_sequence()); + + //remove old plan and add new plan + int planIdx = currentPlans.indexOf(oldCurrentPlan); + currentPlans.remove(oldCurrentPlan); + oldCurrentPlan.setPlan_status(PlanTaskDataAccess.STATUS_FINISH);//change old plan status to finish + currentPlans.add(planIdx,newChangedIdPlan); + + if(Global.getCurrentPlanTask().equals(oldUuidTaskH)){ + Global.setCurrentPlanTask(newUuidTaskH); + } + + //update plan data + List changedPlans = new ArrayList<>(); + changedPlans.add(newChangedIdPlan); + changedPlans.add(oldCurrentPlan); + PlanTaskDataAccess.addUpdatePlans(context,changedPlans); + + loadPlans();//refresh today plan view + } + + public PlanTask decideNextPlan(PlanTask currentPlan){ + PlanTask nextPlan = null; + + currentPlans.remove(currentPlan); + if(currentPlans.isEmpty()) + return null; + List sortedPlanTaskAcend = new ArrayList<>(currentPlans); + //sort by lowest sequence + Collections.sort(sortedPlanTaskAcend,this); + nextPlan = sortedPlanTaskAcend.get(0); + int nextPlanIdx = currentPlans.indexOf(nextPlan); + currentPlans.remove(nextPlanIdx); + currentPlans.add(0,nextPlan); + + return nextPlan; + } + + public String nextPlanBeforeSubmit(String uuidCurrentPlan){ + if(uuidCurrentPlan == null || uuidCurrentPlan.equals("")) + return null; + + if (null != Global.getCurrentPlanTask() && !Global.getCurrentPlanTask().equals(uuidCurrentPlan)) { + return Global.getCurrentPlanTask(); + } + + PlanTask currentPlan = getPlanTaskByTaskH(uuidCurrentPlan); + if(currentPlan == null) + return null; + + if(currentPlans.isEmpty()) + return null; + + List sortedPlanTaskAcend = new ArrayList<>(currentPlans); + //exclude current plan + sortedPlanTaskAcend.remove(currentPlan); + if(sortedPlanTaskAcend.isEmpty()){ + return null; + } + + //sort by lowest sequence + Collections.sort(sortedPlanTaskAcend,this); + PlanTask nextPlan = sortedPlanTaskAcend.get(0); + + return nextPlan.getUuid_task_h(); + } + + public PlanTask getPlanTaskByTaskH(String uuidTaskh){ + PlanTask result = null; + if(currentPlans != null && !currentPlans.isEmpty()){ + for(PlanTask planTask:currentPlans){ + if(planTask.getUuid_task_h().equals(uuidTaskh)){ + result = planTask; + break; + } + } + } + return result; + } + + public void startVisit(List planTasks, IPlanTaskDataSource.Result callback){ + RequestStartVisit requestStartVisit = new RequestStartVisit(); + requestStartVisit.setIsStartVisit(this.isStartVisit); + List activityList = new ArrayList<>(); + for(PlanTask planTask:planTasks){ + if(planTask == null) + continue; + PlanTaskSequence activity = new PlanTaskSequence(planTask.getUuid_task_h() + ,String.valueOf(planTask.getSequence())); + activityList.add(activity); + } + requestStartVisit.setActivityList(activityList); + requestStartVisit.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + dataSource.startVisit(requestStartVisit,callback); + } + + public boolean isAllowChangePlan(){ + List result = PlanTaskDataAccess.findPlanByTaskH(context,Global.getCurrentPlanTask()); + if(result.isEmpty()){ + return false; + } + + PlanTask currentPlan = result.get(0); + if(currentPlan == null) + return false; + + TaskH currentPlantaskH = TaskHDataAccess.getOneHeader(context,currentPlan.getUuid_task_h()); + if(currentPlantaskH == null && !hasDeletedPlanTask){//task is manualy deleted but plan still exist + return false; + } + else if(currentPlantaskH == null){ + return true; + } + + //only allow if current plan taskh status is not failed draft task + //check if current plan is failed draft task + if(currentPlantaskH.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT)){ + List timelines = currentPlantaskH.getTimelineList(); + if(!timelines.isEmpty()){ + TimelineType timelineType = timelines.get(timelines.size() - 1).getTimelineType(); + if(timelineType != null){ + TimelineType typeFailedDraft = TimelineTypeDataAccess.getTimelineTypebyType(context, Global.TIMELINE_TYPE_FAILEDDRAFT); + if(typeFailedDraft.getTimeline_type().equals(timelineType.getTimeline_type())){ + return false; + } + } + } + } + + //check for pending submit + if(currentPlantaskH.getStatus().equals(TaskHDataAccess.STATUS_SEND_FAILED)){ + //check if task coll result is paid/collected + String uuidUser = GlobalData.getSharedGlobalData().getUser().getUuid_user(); + boolean isTaskPaid = TaskDDataAccess.isTaskPaid(context,uuidUser,currentPlantaskH.getUuid_task_h()); + if(isTaskPaid){ + return false; + } + } + + return true; + } + + public void changePlan(final String oldPlanUuidTaskh, final String newPlanUuidTaskh, final IPlanTaskDataSource.Result callback){ + if(callback == null) + return; + + RequestChangePlan requestChangePlan = new RequestChangePlan(newPlanUuidTaskh,oldPlanUuidTaskh); + requestChangePlan.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + + dataSource.changePlan(requestChangePlan, new IPlanTaskDataSource.Result() { + @Override + public void onResult(ResponseChangePlan result) { + if(result != null){ + //reset last changeplan offline info + lastOffChangePlanInfo = null; + dataSource.saveLastChangePlanOffline(null,null); + + List oldPlanResult = PlanTaskDataAccess.findPlanByTaskH(context,oldPlanUuidTaskh); + PlanTask oldPlan = oldPlanResult.isEmpty()?null:oldPlanResult.get(0); + PlanTask newPlan = getPlanTaskByTaskH(newPlanUuidTaskh); + if(newPlan == null){//if null, then it is change plan from revisit + List searchedPlans = PlanTaskDataAccess.findPlanByTaskH(context,newPlanUuidTaskh); + if(searchedPlans.isEmpty()){ + return; + } + newPlan = searchedPlans.get(0); + newPlan.setPlan_status(PlanTaskDataAccess.STATUS_STARTED); + currentPlans.add(0,newPlan);//just add to top + } + else { + //move new plan to top + newPlan.setPlan_status(PlanTaskDataAccess.STATUS_STARTED); + currentPlans.remove(newPlan); + currentPlans.add(0,newPlan); + } + + if(oldPlan!=null){ + oldPlan.setPlan_status(PlanTaskDataAccess.STATUS_PLANNED); + PlanTaskDataAccess.updatePlan(context,oldPlan); + TaskH oldTaskh = TaskHDataAccess.getOneUnsentTaskHeader(context,oldPlan.getUuid_task_h()); + if(hasDeletedPlanTask || (oldTaskh != null && oldTaskh.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT))){//move old plan to bottom if draft task + currentPlans.remove(oldPlan); + currentPlans.add(oldPlan); + } + } + + updatePlanViewSequence(); + Global.setCurrentPlanTask(newPlan.getUuid_task_h()); + callback.onResult(true); + } + } + + @Override + public void onError(String error) { + if(GlobalData.isRequireRelogin() || "Plan Not Approved Yet.".equals(error)) { + callback.onError(error); + return; + } + if(error.equals("Offline")){ + //save offline changeplan info + lastOffChangePlanInfo = new String[]{oldPlanUuidTaskh,newPlanUuidTaskh}; + dataSource.saveLastChangePlanOffline(oldPlanUuidTaskh,newPlanUuidTaskh); + + PlanTask oldPlan = getPlanTaskByTaskH(Global.getCurrentPlanTask()); + PlanTask newPlan = getPlanTaskByTaskH(newPlanUuidTaskh); + if(newPlan == null){//if null, then it is change plan from revisit + List searchedPlans = PlanTaskDataAccess.findPlanByTaskH(context,newPlanUuidTaskh); + if(searchedPlans.isEmpty()){ + return; + } + newPlan = searchedPlans.get(0); + currentPlans.add(0,newPlan);//just add to top + } + else { + //move new plan to top + currentPlans.remove(newPlan); + currentPlans.add(0,newPlan); + } + + if(oldPlan != null) + oldPlan.setPlan_status(PlanTaskDataAccess.STATUS_PLANNED); + + if(newPlan != null) + newPlan.setPlan_status(PlanTaskDataAccess.STATUS_STARTED); + + //move old plan to bottom if draft task + if(oldPlan!=null){ + TaskH oldTaskh = TaskHDataAccess.getOneUnsentTaskHeader(context,oldPlan.getUuid_task_h()); + if(oldTaskh.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT)){ + currentPlans.remove(oldPlan); + currentPlans.add(oldPlan); + } + } + + updatePlanViewSequence(); + + if(newPlan != null){ + Global.setCurrentPlanTask(newPlan.getUuid_task_h()); + } + callback.onResult(true); + return; + } + + callback.onResult(false); + } + }); + } + + private void updatePlanViewSequence(){ + if(currentPlans == null || currentPlans.isEmpty()){ + return; + } + + for(int i=0; i getCachedPlans(){ + return currentPlans; + } + + public void generatePlansFromTaskList(final List taskList){ + if(taskList == null || taskList.isEmpty()) + return; + + //check if has plan before + dataSource.loadPlans(new IPlanTaskDataSource.Result>() { + @Override + public void onResult(List result) { + //check each sequence of taskh + List generatedPlans = new ArrayList<>(); + for(TaskH taskH: taskList){ + Integer seqNo = taskH.getSeq_no(); + //if 0 then dont generate plan + if(seqNo == null || seqNo == 0){ + continue; + } + + //if not 0 then generate plan and set status as planned + String uuidUser = GlobalData.getSharedGlobalData().getUser().getUuid_user(); + PlanTask planTask = new PlanTask(); + planTask.setUuid_plan_task(Tool.getUUID()); + planTask.setUuid_user(uuidUser); + planTask.setUuid_task_h(taskH.getUuid_task_h()); + planTask.setPlan_crt_date(new Date()); + planTask.setPlan_start_date(new Date()); + planTask.setPlan_status(PlanTaskDataAccess.STATUS_PLANNED); + planTask.setSequence(seqNo); + + //add to plan list + generatedPlans.add(planTask); + } + + if (generatedPlans.isEmpty()) { + return; + } + + //if has, return + if (result != null && !result.isEmpty()) { + PlanTaskDataAccess.removeAllPlans(context, GlobalData.getSharedGlobalData().getUser().getUuid_user()); + } + + //sort plan list ascending by seqNo + Collections.sort(generatedPlans,TodayPlanRepository.this); + + for(int i=0; i searchedPlans = PlanTaskDataAccess.findPlanByTaskH(context,revisitUuidTaskh); + if(searchedPlans.isEmpty()){ + return; + } + newPlan = searchedPlans.get(0); + currentPlans.add(0,newPlan);//just add to top + } + else { + //move new plan to top + currentPlans.remove(newPlan); + currentPlans.add(0,newPlan); + } + + if(oldPlan != null) + oldPlan.setPlan_status(PlanTaskDataAccess.STATUS_PLANNED); + + if(newPlan != null) + newPlan.setPlan_status(PlanTaskDataAccess.STATUS_STARTED); + + //move old plan to bottom if draft task + if(oldPlan!=null){ + TaskH oldTaskh = TaskHDataAccess.getOneUnsentTaskHeader(context,oldPlan.getUuid_task_h()); + if(oldTaskh.getStatus().equals(TaskHDataAccess.STATUS_SEND_SAVEDRAFT)){ + currentPlans.remove(oldPlan); + currentPlans.add(oldPlan); + } + } + + updatePlanViewSequence(); + + if(newPlan != null){ + Global.setCurrentPlanTask(newPlan.getUuid_task_h()); + } + } + + private PlanTask getPlanWithUnsentTaskh(){ + PlanTask result = null; + TaskH taskH; + for(PlanTask plan:currentPlans){ + if(plan == null){ + continue; + } + taskH = TaskHDataAccess.getOneUnsentTaskHeader(context,plan.getUuid_task_h()); + if(taskH != null){ + return plan; + } + } + return result; + } + + public void checkPlanAfterSync(){ + //getCurrent plans + dataSource.loadPlans(new IPlanTaskDataSource.Result>() { + @Override + public void onResult(List result) { + currentPlans = result; + if(result.isEmpty()){ + Global.setCurrentPlanTask(null); + return; + } + PlanTask startedPlan = null; + for (PlanTask plan:currentPlans) { + if(plan != null && PlanTaskDataAccess.STATUS_STARTED.equals(plan.getPlan_status())){ + startedPlan = plan; + break; + } + } + if(startedPlan == null){ + Global.setCurrentPlanTask(null); + return; + } + + TaskH planTaskh = TaskHDataAccess.getOneUnsentTaskHeader(context,startedPlan.getUuid_task_h()); + if(planTaskh != null){ + Global.setPlanStarted(true); + Global.setCurrentPlanTask(startedPlan.getUuid_task_h()); + return; + } + + final PlanTask newPlan = getPlanWithUnsentTaskh(); + if(newPlan == null){ + Global.setCurrentPlanTask(null); + return; + } + + changePlan(startedPlan.getUuid_task_h(), newPlan.getUuid_task_h(), new IPlanTaskDataSource.Result() { + @Override + public void onResult(Boolean result) { + Global.setPlanStarted(true); + Global.setCurrentPlanTask(newPlan.getUuid_task_h()); + } + + @Override + public void onError(String error) { + if(GlobalData.isRequireRelogin()){ + DialogManager.showForceExitAlert(context,context.getString(R.string.msgLogout)); + return; + } + Toast.makeText(context, context.getString(R.string.error_change_plan), Toast.LENGTH_SHORT).show(); + } + }); + } + + @Override + public void onError(String error) { + Toast.makeText(context, "Error", Toast.LENGTH_SHORT).show(); + } + }); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32197007075694b4df2a35be1b6015c20b464cb0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32197007075694b4df2a35be1b6015c20b464cb0.svn-base new file mode 100644 index 0000000..b82cf0a --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32197007075694b4df2a35be1b6015c20b464cb0.svn-base @@ -0,0 +1,26 @@ + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/322c4694aea47ba7690589d26e803eaf6e6095ee.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/322c4694aea47ba7690589d26e803eaf6e6095ee.svn-base new file mode 100644 index 0000000..b744b50 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/322c4694aea47ba7690589d26e803eaf6e6095ee.svn-base @@ -0,0 +1,891 @@ +package com.adins.mss.foundation.dialog; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.graphics.Bitmap; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.provider.Settings; +import androidx.fragment.app.FragmentActivity; +import androidx.localbroadcastmanager.content.LocalBroadcastManager; + +import android.util.Log; +import android.view.Gravity; +import android.view.View; +import android.view.ViewGroup; +import android.view.Window; +import android.view.WindowManager; +import android.widget.Button; +import android.widget.ImageButton; +import android.widget.ImageView; +import android.widget.TextView; +import android.widget.Toast; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.NewMainActivity; +import com.adins.mss.base.R; +import com.adins.mss.base.authentication.Authentication; +import com.adins.mss.base.commons.CommonImpl; +import com.adins.mss.base.commons.SecondHelper; +import com.adins.mss.base.commons.SubmitResult; +import com.adins.mss.base.crashlytics.FireCrash; +import com.adins.mss.base.dynamicform.DynamicFormActivity; +import com.adins.mss.base.util.ByteFormatter; +import com.adins.mss.base.util.SecondFormatter; +import com.adins.mss.base.util.UserSession; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.Contact; +import com.adins.mss.dao.Scheme; +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.db.dataaccess.GeneralParameterDataAccess; +import com.adins.mss.foundation.db.dataaccess.SchemeDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskDDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.formatter.Formatter; +import com.adins.mss.foundation.location.LocationTrackingManager; +import com.adins.mss.foundation.security.storepreferences.ObscuredSharedPreferences; +import com.github.jjobes.slidedatetimepicker.SlideDateTimeListener; +import com.github.jjobes.slidedatetimepicker.SlideDateTimePicker; +import com.google.android.gms.common.ConnectionResult; +import com.google.android.gms.common.GoogleApiAvailability; + +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.Date; + + +public class DialogManager { + public static final int TYPE_ERROR = 0; + public static final int TYPE_INFO = 1; + public static final int TYPE_WARNING = 2; + public static final int TYPE_SUCCESS = 3; + static final int REQUEST_CODE_RECOVER_PLAY_SERVICES = 1001; + private static final String OK_LABEL = "OK"; + private static boolean isForceLogoutDialogShowing; + /** + * To check gps enabled and create an alert to force user to enable gps + * + * @param activity + * @author bong.rk + */ + public static NiftyDialogBuilder ndb; + public static NiftyDialogBuilder ndb2; + private static String TAG = "DIALOG_MANAGER"; + private static SlideDateTimeListener dtmListener = new SlideDateTimeListener() { + + @Override + public void onDateTimeSet(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTimeInMillis(date.getTime()); + cal.set(cal.SECOND, 0); + SimpleDateFormat mFormatter = new SimpleDateFormat(Global.DATE_TIME_STR_FORMAT); + String result = mFormatter.format(cal); + DynamicFormActivity.setTxtInFocusText(result); + } + + // Optional cancel listener + @Override + public void onDateTimeCancel() { + //EMPTY + } + }; + + /** + * @param context + * @param dialogType TYPE_ERROR, TYPE_INFO, TYPE_WARNING + * @param message + * @param title, you can set empty string + */ + + public static void showAlert(Context context, int dialogType, String message, String title) { + final AlertDialog alertDialog = new AlertDialog.Builder(context).create(); + + String frontText = null; + + switch (dialogType) { + case TYPE_ERROR: + frontText = "ERROR"; + break; + case TYPE_INFO: + frontText = "INFO"; + break; + case TYPE_WARNING: + frontText = "WARNING"; + break; + case TYPE_SUCCESS: + frontText = "SUCCESS"; + break; + default: + break; + } + + alertDialog.setTitle(title); + alertDialog.setMessage(frontText + ": " + message); + alertDialog.setButton(DialogInterface.BUTTON_POSITIVE, OK_LABEL, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + dialog.cancel(); + } + }); + + // ** dikasih try, soalnya kadang saat lg mau nampilin, + // orang yang megang hp nya pencet back or home, + // so kalo dialog nya tampil dy bakal eror karena layar nya berganti. + // 17 feb 2012 + try { + alertDialog.show(); + } catch (Exception e) { + FireCrash.log(e); + if (Global.IS_DEV) + Log.i(TAG, "Show Dialog " + e); + } + + } + + public static void showAlertNotif(Context context, String message, String title) { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(context); + dialogBuilder.withTitle(title) + .withMessage(message) + .withButton1Text(OK_LABEL) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + } + }) + .isCancelable(true) + .isCancelableOnTouchOutside(true) + .show(); + } + + public static void showAlert(Context context, int type, String message, + DialogInterface.OnClickListener listener, String title) { + final AlertDialog alertDialog = new AlertDialog.Builder(context).create(); + + String frontText = null; + + switch (type) { + case TYPE_ERROR: + frontText = "ERROR"; + break; + case TYPE_INFO: + frontText = "INFO"; + break; + case TYPE_WARNING: + frontText = "WARNING"; + break; + case TYPE_SUCCESS: + frontText = "SUCCESS"; + break; + default: + break; + } + alertDialog.setTitle(title); + alertDialog.setMessage(frontText + ": " + message); + alertDialog.setButton(DialogInterface.BUTTON_POSITIVE, OK_LABEL, listener); + alertDialog.show(); + } + + public static void showOptimizeDialog(final Context activity) { + try { + ndb = NiftyDialogBuilder.getInstance(activity); + ndb.withTitle(activity.getString(R.string.optimize_battery)) + .withMessage(activity.getString(R.string.optimize_battery_alert)) + + .withButton1Text(activity.getString(R.string.btnYes)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent settingsIntent = new Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS); + activity.startActivity(settingsIntent); + } + }); + ndb.isCancelable(true); + ndb.show(); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + public static void showImageDialog(Context context, Bitmap image) { + NiftyDialogBuilder_PL pl = NiftyDialogBuilder_PL.getInstance(context); + pl.withNoTitle().withNoMessage().withTransparentBackground().withImageView(image).show(); + } + + public static void showExitAlertQuestion(final Activity activity, String message) { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.btnExit)) + .withMessage(message) + .withButton1Text(activity.getString(R.string.btnYes)) + .withButton2Text(activity.getString(R.string.btnNo)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + activity.finish(); + GlobalData.getSharedGlobalData().setDoingTask(false); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(true) + .show(); + } + + public static void showExitAlert(final Activity activity, String message) { + if (Global.isIsUploading()) { + //param, jika masih uoloading gak boleh exit + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.btnExit)) + .withMessage(activity.getString(R.string.msgStillUploading)) + .withButton1Text(OK_LABEL) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(true) + .show(); + } else { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.btnExit)) + .withMessage(message) + .withButton1Text(activity.getString(R.string.btnYes)) + .withButton2Text(activity.getString(R.string.btnNo)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + if (NewMainActivity.AutoSendLocationHistoryService != null) { + activity.stopService(NewMainActivity.AutoSendLocationHistoryService); + } + if (NewMainActivity.RunNotificationService != null) + activity.stopService(NewMainActivity.RunNotificationService); + try { + Formatter.clearFormatter(); + CommonImpl.clearFormatter(); + UserSession.clear(); + + ObscuredSharedPreferences sharedPref = ObscuredSharedPreferences.getPrefs(activity, + "GlobalData", Context.MODE_PRIVATE); + + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + sharedPrefEditor.remove("HAS_LOGGED"); + sharedPrefEditor.commit(); + Authentication.setAsNonFreshInstall(LocationTrackingManager.getContextLocation()); + activity.sendBroadcast(new Intent(activity.getString(R.string.action_user_logout))); + } catch (Exception e) { + FireCrash.log(e); + } + activity.finish(); + + new Handler().postDelayed(new Runnable() { + @Override + public void run() { + System.exit(0); + } + }, 1000); + } + }) + .setButton2Click(new View.OnClickListener() { + + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(true) + .show(); + } + } + + public static void showForceExitAlert(final Context context, String message) { + if(!(context instanceof Activity)){ + //cannot show dialog if context is not activity. + return; + } + + Activity activity = (Activity)context; + if(activity.isFinishing() || activity.isDestroyed()) + return; + + if(isForceLogoutDialogShowing){ + return; + } + + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(context); + dialogBuilder.withTitle(context.getString(R.string.btnExit)) + .withMessage(message) + .withButton1Text(context.getString(R.string.btnYes)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + isForceLogoutDialogShowing = false; + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (!Global.APPLICATION_ORDER.equals(application) && NewMainActivity.AutoSendLocationHistoryService != null) { + context.stopService(NewMainActivity.AutoSendLocationHistoryService); + } + if (NewMainActivity.RunNotificationService != null) + context.stopService(NewMainActivity.RunNotificationService); + try { + UserSession.clear(); + + ObscuredSharedPreferences sharedPref = ObscuredSharedPreferences.getPrefs(context, + "GlobalData", Context.MODE_PRIVATE); + + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + sharedPrefEditor.remove("HAS_LOGGED"); + sharedPrefEditor.commit(); + Authentication.setAsNonFreshInstall(context); + + ((Activity)context).finishAffinity(); + dialogBuilder.dismiss(); + } catch (Exception e) { + FireCrash.log(e); + } + + new Handler().postDelayed(new Runnable() { + @Override + public void run() { + System.exit(0); + } + }, 1000); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(false) + .show(); + isForceLogoutDialogShowing = true; + } + + public static void showForceExitAlert(final Activity activity, String message) { + if(activity.isFinishing() || activity.isDestroyed()) + return; + + if(isForceLogoutDialogShowing){ + return; + } + + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.btnExit)) + .withMessage(message) + .withButton1Text(activity.getString(R.string.btnYes)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + isForceLogoutDialogShowing = false; + String application = GlobalData.getSharedGlobalData().getAuditData().getApplication(); + if (!Global.APPLICATION_ORDER.equals(application) && NewMainActivity.AutoSendLocationHistoryService != null) { + activity.stopService(NewMainActivity.AutoSendLocationHistoryService); + } + if (NewMainActivity.RunNotificationService != null) + activity.stopService(NewMainActivity.RunNotificationService); + try { + UserSession.clear(); + + ObscuredSharedPreferences sharedPref = ObscuredSharedPreferences.getPrefs(activity, + "GlobalData", Context.MODE_PRIVATE); + + ObscuredSharedPreferences.Editor sharedPrefEditor = sharedPref.edit(); + sharedPrefEditor.remove("HAS_LOGGED"); + sharedPrefEditor.commit(); + Authentication.setAsNonFreshInstall(LocationTrackingManager.getContextLocation()); + + activity.sendBroadcast(new Intent(activity.getString(R.string.action_user_logout))); + } catch (Exception e) { + FireCrash.log(e); + } + + activity.finishAffinity(); + new Handler().postDelayed(new Runnable() { + @Override + public void run() { + System.exit(0); + } + }, 1000); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(false) + .show(); + isForceLogoutDialogShowing = true; + } + + public static void showForceSyncronize(final NewMainActivity activity) { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.sync_dialog)) + .withMessage(R.string.sync_dialog_message) + .withButton1Text(activity.getString(R.string.btnYes)) + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + activity.gotoSynchronize(); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(false) + .show(); + } + + public static void showDateTimePicker(FragmentActivity activity) { + new SlideDateTimePicker.Builder(activity.getSupportFragmentManager()) + .setListener(dtmListener) + .setInitialDate(new Date()) + .setIs24HourTime(true) + .build() + .show(); + } + + public static void showGPSAlert(final Context activity) { + LocationManager lm = (LocationManager) activity.getSystemService(Context.LOCATION_SERVICE); + try { + if (lm.getProvider(LocationManager.GPS_PROVIDER) != null) { + final boolean gpsEnabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER); + if (!gpsEnabled) { + closeGPSAlert(); + ndb = NiftyDialogBuilder.getInstance(activity); + ndb.withTitle(activity.getString(R.string.gps_unable)) + .withMessage(activity.getString(R.string.gps_warning)) + .withButton1Text(activity.getString(R.string.gps_button)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent settingsIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS); + activity.startActivity(settingsIntent); + + } + }); + ndb.isCancelable(false); + ndb.show(); + } + } + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + try { + if (lm.getProvider(LocationManager.GPS_PROVIDER) != null) { + final boolean gpsEnabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER); + + new LocationListener() { + @Override + public void onLocationChanged(Location location) { + boolean isMock; + if (android.os.Build.VERSION.SDK_INT >= 18) { + isMock = location.isFromMockProvider(); + } else { + isMock = Settings.Secure.getString(LocationTrackingManager.getContextLocation().getContentResolver(), Settings.Secure.ALLOW_MOCK_LOCATION).equals("0"); + } + showMockDialog(gpsEnabled, isMock, activity); + } + + @Override + public void onStatusChanged(String provider, int status, Bundle extras) { + //EMPTY + } + + @Override + public void onProviderEnabled(String provider) { + //EMPTY + } + + @Override + public void onProviderDisabled(String provider) { + //EMPTY + } + }; + } + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + private static void showMockDialog(Boolean gpsEnabled, Boolean isMock, final Context activity) { + if (gpsEnabled && isMock) { + closeGPSAlert(); + ndb = NiftyDialogBuilder.getInstance(activity); + ndb.withTitle(activity.getString(R.string.mock_location)) + .withMessage(activity.getString(R.string.mock_location_alert)) + + .withButton1Text(activity.getString(R.string.dev_option)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent settingsIntent = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); + activity.startActivity(settingsIntent); + + } + }); + ndb.isCancelable(false); + ndb.show(); + } + } + + public static void showMockDialog(final Context activity) { + try { + closeGPSAlert(); + ndb = NiftyDialogBuilder.getInstance(activity); + ndb.withTitle(activity.getString(R.string.mock_location)) + .withMessage(activity.getString(R.string.mock_location_alert)) + + .withButton1Text(activity.getString(R.string.dev_option)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent settingsIntent = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); + activity.startActivity(settingsIntent); + + } + }); + ndb.isCancelable(false); + ndb.show(); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + public static void closeGPSAlert() { + if (ndb != null) + ndb.dismiss(); + } + + public static boolean checkPlayServices(Activity activity) { + int status = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(activity); + if (status != ConnectionResult.SUCCESS) { + if (GoogleApiAvailability.getInstance().isUserResolvableError(status)) { + Dialog dialog = GoogleApiAvailability.getInstance().getErrorDialog(activity, status, + REQUEST_CODE_RECOVER_PLAY_SERVICES); + dialog.setCancelable(false); + dialog.show(); + } else { + Toast.makeText(activity, activity.getString(R.string.device_not_supported), + Toast.LENGTH_LONG).show(); + activity.finish(); + } + return false; + } + return true; + } + + public static void uninstallAPK(Context context) { + String packageName = context.getPackageName(); + Uri packageURI = Uri.parse("package:" + packageName); + Intent uninstallIntent = new Intent(Intent.ACTION_DELETE, packageURI); + uninstallIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + context.startActivity(uninstallIntent); + } + + public static void UninstallerHandler(final FragmentActivity activity) { + String message = activity.getString(R.string.inactive_user, GlobalData.getSharedGlobalData().getUser().getFullname()); + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.warning_capital)) + .withMessage(message) + .withButton1Text("Uninstall") + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + String packageName = activity.getPackageName(); + Intent intent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE); + intent.setData(Uri.parse("package:" + packageName)); + intent.putExtra(Intent.EXTRA_RETURN_RESULT, true); + activity.startActivityForResult(intent, 1); + activity.sendBroadcast(new Intent(activity.getString(R.string.action_user_logout))); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(false) + .show(); + } + + public static void UninstallerHandler(final Activity activity) { + String message = activity.getString(R.string.inactive_user, GlobalData.getSharedGlobalData().getUser().getFullname()); + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(activity); + dialogBuilder.withTitle(activity.getString(R.string.warning_capital)) + .withMessage(message) + .withButton1Text("Uninstall") + .setButton1Click(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + dialogBuilder.dismiss(); + String packageName = activity.getPackageName(); + Intent intent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE); + intent.setData(Uri.parse("package:" + packageName)); + intent.putExtra(Intent.EXTRA_RETURN_RESULT, true); + activity.startActivityForResult(intent, 1); + activity.sendBroadcast(new Intent(activity.getString(R.string.action_user_logout))); + } + }) + .isCancelable(false) + .isCancelableOnTouchOutside(false) + .show(); + } + + public static void showRootAlert(final Activity activity, final Context context) { + try { + ndb2 = NiftyDialogBuilder.getInstance(activity); + ndb2.withTitle(activity.getResources().getString(R.string.device_rooted)) + .withMessage(activity.getResources().getString(R.string.device_rooted_uninstall)) + .withButton1Text(activity.getResources().getString(R.string.uninstall_apk)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb2.dismiss(); + uninstallAPK(context); + } + }); + ndb2.isCancelable(false); + ndb2.show(); + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + public static boolean isTimeAutomatic(Context context) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { + return Settings.Global.getInt(context.getContentResolver(), Settings.Global.AUTO_TIME, 0) == 1; + } else { + return android.provider.Settings.System.getInt(context.getContentResolver(), android.provider.Settings.System.AUTO_TIME, 0) == 1; + } + } + + public static void showTimeProviderAlert(final Activity activity) { + try { + if (!isTimeAutomatic(activity)) { + closeGPSAlert(); + ndb = NiftyDialogBuilder.getInstance(activity); + ndb.withTitle(activity.getString(R.string.time_unable)) + .withMessage(activity.getString(R.string.time_warning)) + .withButton1Text(activity.getString(R.string.time_button)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent settingsIntent = new Intent(Settings.ACTION_DATE_SETTINGS); + activity.startActivity(settingsIntent); + + } + }); + ndb.isCancelable(false); + ndb.show(); + } + } catch (Exception e) { + FireCrash.log(e); + e.printStackTrace(); + } + } + + public static void showTurnOffDevMode(final Context context) { + try { + ndb = NiftyDialogBuilder.getInstance(context); + ndb.withTitle(context.getString(R.string.title_developer_mode)) + .withMessage(context.getString(R.string.text_turn_off_dev_mode)) + .withButton1Text(context.getString(R.string.btnSetting)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + ndb.dismiss(); + Intent setting = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); + context.startActivity(setting); + } + }); + ndb.isCancelable(false); + ndb.isCancelableOnTouchOutside(false); + ndb.show(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void showAskForDownloadDialog(final Activity activity) { + final NiftyDialogBuilder builder = NiftyDialogBuilder.getInstance(activity); + builder.withTitle(activity.getString(R.string.get_services)) + .withMessage(activity.getString(R.string.get_services_message)) + .withButton1Text(activity.getString(R.string.get_services)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + builder.dismiss(); + Intent download = new Intent(Intent.ACTION_VIEW, Uri.parse(activity.getString(R.string.download_services))); + activity.startActivity(download); + } + + }).show(); + } + + public static void submitResult(final Activity activity, final SubmitResult submitResult) { + String msgResult = submitResult.getResult(); + + final androidx.appcompat.app.AlertDialog dialog = new androidx.appcompat.app.AlertDialog.Builder(activity) + .setView(R.layout.new_dialog_send_result) + .create(); + WindowManager.LayoutParams wmlp = dialog.getWindow().getAttributes(); + wmlp.windowAnimations = R.style.DialogAnimation2; + dialog.show(); + + ImageView icon = (ImageView) dialog.findViewById(R.id.imgHeader); + Button btnOK = (Button) dialog.findViewById(R.id.btnOK); + Button btnPrint = (Button) dialog.findViewById(R.id.btnPrintPage); + TextView txtResult = (TextView) dialog.findViewById(R.id.txtResult); + TextView txtTime = (TextView) dialog.findViewById(R.id.txtTimeSent); + TextView txtSize = (TextView) dialog.findViewById(R.id.txtDataSize); + + Scheme scheme = SchemeDataAccess.getOne(activity, submitResult.getTaskH().getUuid_scheme()); + if (scheme != null) { + String uuidUser = GlobalData.getSharedGlobalData().getUser().getUuid_user(); + boolean isTaskPaid = TaskDDataAccess.isTaskPaid(activity, uuidUser, submitResult.getTaskH().getUuid_task_h()); + boolean isRVinFront = GeneralParameterDataAccess.isRvInFrontEnable(activity, uuidUser); + if (isRVinFront) { + btnPrint.setVisibility(View.GONE); + } else if (!scheme.getIs_printable().equals("1") || !isTaskPaid) { + btnPrint.setVisibility(View.GONE); + } else { + btnPrint.setVisibility(View.VISIBLE); + } + } + + if (msgResult != null) { + if (msgResult.equalsIgnoreCase("Success")) { + String time = submitResult.getTaskH().getSubmit_duration(); + String size = submitResult.getTaskH().getSubmit_size(); + + String seconds = SecondFormatter.secondsToString(Long.parseLong(time)); + String mTime = activity.getString(com.adins.mss.base.R.string.time) + seconds; + + String bytes = ByteFormatter.formatByteSize(Long.parseLong(size)); + String mSize = activity.getString(com.adins.mss.base.R.string.size) + bytes; + + txtTime.setText(mTime); + txtSize.setText(mSize); + } else { + icon.setImageDrawable(activity.getResources().getDrawable(R.drawable.ic_failed)); + txtResult.setText(submitResult.getTaskH().getMessage()); + txtTime.setVisibility(View.GONE); + txtSize.setVisibility(View.GONE); + btnPrint.setVisibility(View.GONE); + } + } else { + icon.setImageDrawable(activity.getResources().getDrawable(R.drawable.ic_failed)); + txtResult.setText(activity.getString(R.string.message_sending_failed)); + txtTime.setVisibility(View.GONE); + txtSize.setVisibility(View.GONE); + btnPrint.setVisibility(View.GONE); + } + + btnOK.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + dialog.dismiss(); + + Message msg = new Message(); + Bundle bundle = new Bundle(); + bundle.putInt(NewMainActivity.KEY_ACTION, NewMainActivity.ACTION_TIMELINE); + msg.setData(bundle); + + NewMainActivity.submitHandler.sendMessage(msg); + } + }); + + btnPrint.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + final TaskH taskH = TaskHDataAccess.getOneTaskHeader(activity, submitResult.getTaskId()); + if (taskH.getRv_number() != null && !taskH.getRv_number().isEmpty()) { + Toast.makeText(activity, R.string.cantPrint, Toast.LENGTH_SHORT).show(); + } else { + SecondHelper.Companion.doPrint(activity, submitResult.getTaskId(), "log"); + } + } + }); + } + + public static void showDetailContact(final Activity activity, final Contact contact) { + final androidx.appcompat.app.AlertDialog dialog = new androidx.appcompat.app.AlertDialog.Builder(activity, R.style.Dialog_NoTitle) + .setView(R.layout.dialog_contact_detail) + .create(); + dialog.setCancelable(true); + dialog.requestWindowFeature(Window.FEATURE_NO_TITLE); + WindowManager.LayoutParams wmlp = dialog.getWindow().getAttributes(); + wmlp.gravity = Gravity.BOTTOM; + wmlp.windowAnimations = R.style.DialogAnimation; + dialog.show(); + dialog.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT); + + TextView contactName = (TextView) dialog.findViewById(R.id.txtName); + TextView contactDept = (TextView) dialog.findViewById(R.id.txtDepartment); + TextView contactPhone = (TextView) dialog.findViewById(R.id.txtPhone); + TextView contactEmail = (TextView) dialog.findViewById(R.id.txtEmail); + ImageButton btnCall = (ImageButton) dialog.findViewById(R.id.btnCall); + + contactName.setText(contact.getContact_name()); + contactDept.setText(contact.getContact_dept()); + contactPhone.setText(contact.getContact_phone()); + contactEmail.setText(contact.getContact_email()); + + btnCall.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + Intent intent = new Intent(Intent.ACTION_CALL); + intent.setData(Uri.parse("tel:" + contact.getContact_phone())); + activity.startActivity(intent); + } + }); + } + public static void showTaskRejected(Activity activity, String result){ + final androidx.appcompat.app.AlertDialog dialog = new androidx.appcompat.app.AlertDialog.Builder(activity) + .setView(R.layout.dialog_reject_success) + .create(); + WindowManager.LayoutParams wmlp = dialog.getWindow().getAttributes(); + wmlp.windowAnimations = R.style.DialogAnimation2; + dialog.show(); + + TextView textMessage = dialog.findViewById(R.id.txtResult); + Button btnOK = (Button) dialog.findViewById(R.id.btnOK); + + textMessage.setText(result); + + btnOK.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + dialog.dismiss(); + } + }); + } +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/329a2abdfeb0bbd80aa233f8eb8feca028f086e0.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/329a2abdfeb0bbd80aa233f8eb8feca028f086e0.svn-base new file mode 100644 index 0000000..0ddc488 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/329a2abdfeb0bbd80aa233f8eb8feca028f086e0.svn-base @@ -0,0 +1,7 @@ + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bd3ee1206aa0ebd4b73cba41e9bf70407fe346.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bd3ee1206aa0ebd4b73cba41e9bf70407fe346.svn-base new file mode 100644 index 0000000..361b31b --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bd3ee1206aa0ebd4b73cba41e9bf70407fe346.svn-base @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bf1401a9352097ea169e4620e1c4f83c1c9d8d.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bf1401a9352097ea169e4620e1c4f83c1c9d8d.svn-base new file mode 100644 index 0000000..6ed03af --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32bf1401a9352097ea169e4620e1c4f83c1c9d8d.svn-base @@ -0,0 +1,26 @@ +package com.adins.mss.base.receipt; + +import android.graphics.Canvas; + +/** + * Created by Loise on 12/04/2018. + */ + +/** + * interface untuk menggambar pada canvas + */ +public interface IDrawItem { + /** + * Menggambar pada canvas + * @param canvas objek canvas yang akan digambar + * @param x lokasi menggambar pada sumbu x + * @param y lokasi menggambar pada sumbu y + */ + void drawOnCanvas(Canvas canvas, float x, float y); + + /** + * mengembalikan tinggi objek + * @return + */ + int getHeight(); +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32c814faf8b30f886cae43230213497c9179159b.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32c814faf8b30f886cae43230213497c9179159b.svn-base new file mode 100644 index 0000000..9f0e632 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32c814faf8b30f886cae43230213497c9179159b.svn-base @@ -0,0 +1,418 @@ +package com.adins.mss.coll.fragments; + +import android.annotation.SuppressLint; +import android.app.ProgressDialog; +import android.content.Context; +import android.content.Intent; +import android.graphics.Color; +import android.os.AsyncTask; +import android.os.Bundle; +import android.os.Environment; +import android.text.SpannableString; +import android.text.Spanned; +import android.text.TextUtils; +import android.text.method.LinkMovementMethod; +import android.text.style.ClickableSpan; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.TableLayout; +import android.widget.TextView; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.fragment.app.FragmentActivity; + +import com.adins.mss.base.GlobalData; +import com.adins.mss.base.dynamicform.JsonRequestPdfReceiptHistory; +import com.adins.mss.base.dynamicform.JsonResponsePdfReceiptHistory; +import com.adins.mss.base.pdfrenderer.ViewPdfRendererFragment; +import com.adins.mss.base.util.GsonHelper; +import com.adins.mss.base.util.Utility; +import com.adins.mss.coll.R; +import com.adins.mss.coll.api.ReceiptHistoryApi; +import com.adins.mss.coll.models.ReceiptHistoryResponse; +import com.adins.mss.constant.Global; +import com.adins.mss.dao.ReceiptHistory; +import com.adins.mss.dao.TaskH; +import com.adins.mss.foundation.db.dataaccess.ReceiptHistoryDataAccess; +import com.adins.mss.foundation.db.dataaccess.TaskHDataAccess; +import com.adins.mss.foundation.dialog.NiftyDialogBuilder; +import com.adins.mss.foundation.formatter.Tool; +import com.adins.mss.foundation.http.HttpConnectionResult; +import com.adins.mss.foundation.http.HttpCryptedConnection; +import com.adins.mss.foundation.image.Base64; +import com.google.firebase.perf.FirebasePerformance; +import com.google.firebase.perf.metrics.HttpMetric; + +import org.acra.ACRA; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.List; + +public class ReceiptHistoryFragment extends FragmentActivity { + + public ReceiptHistoryResponse rHistoryResponse; + private String taskId; + private String agreementNo; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.fragment_receipt_history); + + ACRA.getErrorReporter().putCustomData("LAST_CLASS_ACCESSED", getClass().getSimpleName()); + Bundle bundle = getIntent().getExtras(); + taskId = bundle.getString(Global.BUND_KEY_TASK_ID); + agreementNo = bundle.getString(Global.BUND_KEY_AGREEMENT_NO); + + loadData(); + } + + public void saveData(Context context, ReceiptHistoryResponse receiptHistoryResponse) { + List receiptHistoryList = receiptHistoryResponse.getReceiptHistoryList(); + if (receiptHistoryList != null && receiptHistoryList.size() > 0) { + TaskH taskH = TaskHDataAccess.getOneTaskHeader(context, taskId); + ReceiptHistoryDataAccess.delete(context, taskH.getTask_id()); + for (ReceiptHistory receiptHistory : receiptHistoryList) { + receiptHistory.setUuid_task_h(taskH.getTask_id()); + receiptHistory.setUuid_receipt_history(Tool.getUUID()); + receiptHistory.setAgreement_no(agreementNo); + } + ReceiptHistoryDataAccess.add(getApplicationContext(), receiptHistoryList); + } + } + + public void loadData() { + new AsyncTask() { + private ProgressDialog progressDialog; + + @Override + protected void onPreExecute() { + progressDialog = ProgressDialog.show(ReceiptHistoryFragment.this, + "", getString(R.string.progressWait), true); + + } + + @Override + protected ReceiptHistoryResponse doInBackground(Void... params) { + ReceiptHistoryApi api = new ReceiptHistoryApi(ReceiptHistoryFragment.this); + try { + + //bong 21 mei 15 - check internet connection + if (Tool.isInternetconnected(getApplicationContext())) { + return api.request(agreementNo, taskId); + } + return null; + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } + + protected void onPostExecute(ReceiptHistoryResponse receiptHistoryResponse) { + super.onPostExecute(receiptHistoryResponse); + if (progressDialog != null && progressDialog.isShowing()) { + try { + progressDialog.dismiss(); + } catch (Exception e) { + } + } + + if (receiptHistoryResponse == null) { + TaskH taskH = TaskHDataAccess.getOneTaskHeader(getApplicationContext(), taskId); + if (taskH != null) { + List receiptHistoryList = ReceiptHistoryDataAccess.getAllByTask(getApplicationContext(), taskH.getUuid_task_h()); + if (receiptHistoryList != null) { + TableLayout table = (TableLayout) findViewById(R.id.tableHeaders); + int index = 1; + + for (final ReceiptHistory item : receiptHistoryList) { + View row = LayoutInflater.from(ReceiptHistoryFragment.this).inflate(R.layout.view_row_receipt_history, table, false); + TextView contractNumber = (TextView) row.findViewById(R.id.contractNumber); + TextView receiptNumber = (TextView) row.findViewById(R.id.receiptNumber); + TextView paymentDate = (TextView) row.findViewById(R.id.paymentDate); + TextView file = (TextView) row.findViewById(R.id.file); + row.setTag(item); + + contractNumber.setText(item.getAgreement_no()); + receiptNumber.setText(item.getReceipt_no()); + paymentDate.setText(item.getPayment_date() + ""); + file.setText("(download)"); + SpannableString spannableString = new SpannableString(file.getText()); + ClickableSpan clickableSpan = new ClickableSpan() { + @Override + public void onClick(@NonNull View widget) { + String receiptNo = item.getReceipt_no(); + if (receiptNo.contains("/")) { + receiptNo = receiptNo.replace("/", ""); + } + getDocumentPDF(getApplicationContext(), item.getAgreement_no(), receiptNo); + } + }; + spannableString.setSpan(clickableSpan, 0, spannableString.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); + file.setText(spannableString); + file.setMovementMethod(LinkMovementMethod.getInstance()); + file.setHighlightColor(Color.TRANSPARENT); + if (index % 2 == 1) { + row.setBackgroundResource(R.color.tv_gray_light); + } else if (index % 2 == 0) { + row.setBackgroundResource(R.color.tv_gray); + } + table.addView(row); + } + } else { + NiftyDialogBuilder.getInstance(ReceiptHistoryFragment.this) + .withMessage(getString(R.string.no_data_found_offline)) + .withTitle(getString(R.string.no_data_found_offline)) + .withIcon(android.R.drawable.ic_dialog_alert) + .withButton1Text(getString(R.string.btnClose)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + //finish(); + NiftyDialogBuilder.getInstance(ReceiptHistoryFragment.this).dismiss(); + } + }) + .show(); + } + } + } else if (receiptHistoryResponse.getStatus().getCode() != 0) { + NiftyDialogBuilder.getInstance(ReceiptHistoryFragment.this) + .withMessage(receiptHistoryResponse.getStatus().getMessage()) + .withTitle(getString(R.string.server_error)) + .withButton1Text(getString(R.string.btnClose)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }) + .show(); + return; + } else if (!receiptHistoryResponse.getStatusCode().equalsIgnoreCase("00")) { + NiftyDialogBuilder.getInstance(ReceiptHistoryFragment.this) + .withMessage(receiptHistoryResponse.getMessage()) + .withTitle(getString(R.string.message)) + .withButton1Text(getString(R.string.btnClose)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }) + .show(); + return; + } else { + rHistoryResponse = receiptHistoryResponse; + saveData(getApplicationContext(), rHistoryResponse); + + TableLayout table = (TableLayout) findViewById(R.id.tableHeaders); + int index = 1; + + for (final ReceiptHistory item : receiptHistoryResponse.getReceiptHistoryList()) { + View row = LayoutInflater.from(ReceiptHistoryFragment.this).inflate(R.layout.view_row_receipt_history, table, false); + TextView contractNumber = (TextView) row.findViewById(R.id.contractNumber); + TextView receiptNumber = (TextView) row.findViewById(R.id.receiptNumber); + TextView paymentDate = (TextView) row.findViewById(R.id.paymentDate); + TextView file = (TextView) row.findViewById(R.id.file); + row.setTag(item); + + contractNumber.setText(rHistoryResponse.getAgreementNo()); + receiptNumber.setText(item.getReceipt_no()); + paymentDate.setText(item.getPayment_date() + ""); + file.setText("(download)"); + SpannableString spannableString = new SpannableString(file.getText()); + ClickableSpan clickableSpan = new ClickableSpan() { + @Override + public void onClick(@NonNull View widget) { + String receiptNo = item.getReceipt_no(); + if (receiptNo.contains("/")) { + receiptNo = receiptNo.replace("/", ""); + } + getDocumentPDF(getApplicationContext(), item.getAgreement_no(), receiptNo); + } + }; + spannableString.setSpan(clickableSpan, 0, spannableString.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); + file.setText(spannableString); + file.setMovementMethod(LinkMovementMethod.getInstance()); + file.setHighlightColor(Color.TRANSPARENT); + if (index % 2 == 1) { + row.setBackgroundResource(R.color.tv_gray_light); + } else if (index % 2 == 0) { + row.setBackgroundResource(R.color.tv_gray); + } + table.addView(row); + } + if (receiptHistoryResponse.getReceiptHistoryList().size() == 0) { + NiftyDialogBuilder.getInstance(ReceiptHistoryFragment.this) + .withMessage(R.string.no_data_from_server) + .withTitle(getString(R.string.info_capital)) + .withButton1Text(getString(R.string.btnClose)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }) + .show(); + } + } + + } + }.execute(); + } + + @SuppressLint("StaticFieldLeak") + private void getDocumentPDF(final Context context, final String agreementNo, final String receiptNo) { + new AsyncTask() { + private ProgressDialog progressDialog; + private String fileLocation; + private String message; + + @Override + protected void onPreExecute() { + progressDialog = ProgressDialog.show(ReceiptHistoryFragment.this, + "", getString(R.string.progressWait), true); + } + + @Override + protected JsonResponsePdfReceiptHistory doInBackground(Void... arg0) { + String fileName = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS).getAbsolutePath() + "/bafmcspdf" + "/" + agreementNo + "_" + receiptNo + ".pdf"; + File fileOpen = new File(fileName); + if (fileOpen.exists()) { + fileLocation = fileName; + JsonResponsePdfReceiptHistory responsePdfReceiptHistory = new JsonResponsePdfReceiptHistory(); + JsonResponsePdfReceiptHistory.Status status = new JsonResponsePdfReceiptHistory.Status(); + status.setCode(0); + responsePdfReceiptHistory.setStatusCode("00"); + responsePdfReceiptHistory.setStatus(status); + return responsePdfReceiptHistory; + } else { + try { + if (Tool.isInternetconnected(context)) { + JsonRequestPdfReceiptHistory requestPdfDocument = new JsonRequestPdfReceiptHistory(); + requestPdfDocument.setAudit(GlobalData.getSharedGlobalData().getAuditData()); + requestPdfDocument.addImeiAndroidIdToUnstructured(); + requestPdfDocument.setAgreementNo(agreementNo); + requestPdfDocument.setInvoiceNo(receiptNo); + + String json = GsonHelper.toJson(requestPdfDocument); + String url = GlobalData.getSharedGlobalData().getURL_GET_RECEIPT_HISTORY_PDF(); + boolean encrypt = GlobalData.getSharedGlobalData().isEncrypt(); + boolean decrypt = GlobalData.getSharedGlobalData().isDecrypt(); + + HttpCryptedConnection httpConn = new HttpCryptedConnection(context, encrypt, decrypt); + HttpConnectionResult serverResult = null; + // Firebase Performance Trace Network Request + HttpMetric networkMetric = FirebasePerformance.getInstance().newHttpMetric( + url, FirebasePerformance.HttpMethod.POST); + Utility.metricStart(networkMetric, json); + + try { + serverResult = httpConn.requestToServer(url, json, Global.DEFAULTCONNECTIONTIMEOUT); + Utility.metricStop(networkMetric, serverResult); + } catch (Exception e) { + e.printStackTrace(); + } + if (null != serverResult) { + if (serverResult.isOK()) { + JsonResponsePdfReceiptHistory responsePdfReceiptHistory = GsonHelper.fromJson(serverResult.getResult(), JsonResponsePdfReceiptHistory.class); + if (responsePdfReceiptHistory.getStatus().getCode() == 0) { + if (responsePdfReceiptHistory.getStatusCode().equals("200") || responsePdfReceiptHistory.getStatusCode().equals("00")) { + String pathFolder = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS).getAbsolutePath() + "/bafmcspdf"; + File filePath = new File(pathFolder); + if (!filePath.exists()) { + filePath.mkdirs(); + } + + String uriString = filePath.getAbsolutePath() + "/" + agreementNo + "_" + receiptNo + ".pdf"; + fileLocation = uriString; + + try { + File file = new File(uriString); + byte[] pdfBytes = Base64.decode(responsePdfReceiptHistory.getPdf()); + FileOutputStream os = new FileOutputStream(file); + os.write(pdfBytes); + os.flush(); + os.close(); + } catch (IOException e) { + e.printStackTrace(); + message = "Error decoding pdf file!"; + } + return responsePdfReceiptHistory; + } else { + message = responsePdfReceiptHistory.getMessage(); + } + return responsePdfReceiptHistory; + } else { + message = responsePdfReceiptHistory.getStatus().getMessage(); + } + } else { + message = serverResult.getResult(); + } + } else { + message = "Failed to get result from Server"; + } + } else { + message = context.getString(com.adins.mss.base.R.string.no_internet_connection); + } + return null; + } catch (Exception e) { + if (Global.IS_DEV) { + e.printStackTrace(); + } + Log.e("Info", e.getMessage()); + return null; + } + } + } + + @Override + protected void onPostExecute(JsonResponsePdfReceiptHistory result) { + super.onPostExecute(result); + if (progressDialog != null && progressDialog.isShowing()) { + try { + progressDialog.dismiss(); + } catch (Exception e) { + e.printStackTrace(); + } + } + if (result != null && (result.getStatusCode().equals("200") || result.getStatusCode().equals("00"))) { + try { + Intent intent = new Intent(context, ViewPdfRendererFragment.class); + Bundle extras = new Bundle(); + extras.putString("FILE_LOC", fileLocation); + intent.putExtras(extras); + + startActivity(intent); + } catch (Exception ex) { + if (Global.IS_DEV) { + ex.printStackTrace(); + } + } + } else if (result != null && !(result.getStatusCode().equals("200") || result.getStatusCode().equals("00"))) { + final NiftyDialogBuilder dialogBuilder = NiftyDialogBuilder.getInstance(context); + dialogBuilder.withTitle(context.getString(com.adins.mss.base.R.string.info_capital)) + .isCancelableOnTouchOutside(false) + .withMessage(result.getMessage()) + .withButton1Text(context.getString(com.adins.mss.base.R.string.btnOk)) + .setButton1Click(new View.OnClickListener() { + @Override + public void onClick(View v) { + dialogBuilder.dismiss(); + } + }) + .show(); + } else if (!TextUtils.isEmpty(message)) { + Toast.makeText(context, message, Toast.LENGTH_SHORT).show(); + } else { + Toast.makeText(context, context.getString(com.adins.mss.base.R.string.msgErrorParsingJson), Toast.LENGTH_SHORT).show(); + } + } + }.execute(); + } + +} diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32e1057241088468d314c3a20e60d6dfb9d8ea88.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32e1057241088468d314c3a20e60d6dfb9d8ea88.svn-base new file mode 100644 index 0000000..69a9caa --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32e1057241088468d314c3a20e60d6dfb9d8ea88.svn-base @@ -0,0 +1,8 @@ + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32fb157bc71d9c6c2f9c36c7a3b1e0d9d5647d48.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32fb157bc71d9c6c2f9c36c7a3b1e0d9d5647d48.svn-base new file mode 100644 index 0000000..55e7d97 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/32/32fb157bc71d9c6c2f9c36c7a3b1e0d9d5647d48.svn-base @@ -0,0 +1,140 @@ + + + + + + + + + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/3679293352772c908c590879479b3169a2670797.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/3679293352772c908c590879479b3169a2670797.svn-base new file mode 100644 index 0000000..9043e03 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/3679293352772c908c590879479b3169a2670797.svn-base @@ -0,0 +1,11 @@ + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36843c29d3ba070d5d14565c7b11c3ae486394db.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36843c29d3ba070d5d14565c7b11c3ae486394db.svn-base new file mode 100644 index 0000000..ead22b3 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36843c29d3ba070d5d14565c7b11c3ae486394db.svn-base @@ -0,0 +1,9 @@ + + + diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36864176a69383d9ac5e579d2aee2c190a2eb827.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36864176a69383d9ac5e579d2aee2c190a2eb827.svn-base new file mode 100644 index 0000000..5b0719f --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36864176a69383d9ac5e579d2aee2c190a2eb827.svn-base @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36891b46239bc16d2d246d57774b5f9c0c29b4c4.svn-base b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36891b46239bc16d2d246d57774b5f9c0c29b4c4.svn-base new file mode 100644 index 0000000..d675cf7 --- /dev/null +++ b/MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/36/36891b46239bc16d2d246d57774b5f9c0c29b4c4.svn-base @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + +