#173

pending completion

Build # #173

Build Type

Pull #919

github-actions

Committed by

web-flow

Commit Message

Merge a10bd445f into 5668d546b

Pull Request Pull Request #919: v5 - Set Locales When Formatting Dates

Run Details

18784 of 26961 relevant lines covered (69.67%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.19

opensrp-core/src/main/java/org/smartregister/multitenant/ResetAppHelper.java

package org.smartregister.multitenant;

import android.content.SharedPreferences;
import androidx.annotation.AnyThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import android.widget.Toast;

import com.evernote.android.job.JobManager;

import org.smartregister.CoreLibrary;
import org.smartregister.P2POptions;
import org.smartregister.R;
import org.smartregister.exception.AppResetException;
import org.smartregister.exception.PreResetAppOperationException;
import org.smartregister.listener.OnCompleteClearDataCallback;
import org.smartregister.multitenant.check.EventClientSyncedCheck;
import org.smartregister.multitenant.check.PreResetAppCheck;
import org.smartregister.multitenant.check.SettingsSyncedCheck;
import org.smartregister.multitenant.check.StructureSyncedCheck;
import org.smartregister.multitenant.check.TaskSyncedCheck;
import org.smartregister.p2p.P2PLibrary;
import org.smartregister.p2p.model.AppDatabase;
import org.smartregister.util.AppExecutors;
import org.smartregister.util.NetworkUtils;
import org.smartregister.util.Utils;
import org.smartregister.view.activity.DrishtiApplication;
import org.smartregister.view.dialog.ResetAppDialog;

import java.security.KeyStore;
import java.security.KeyStoreException;
import java.util.ArrayList;
import java.util.Enumeration;

import timber.log.Timber;

/**
 * Created by Ephraim Kigamba - nek.eam@gmail.com on 09-04-2020.
 */
public class ResetAppHelper {

    private DrishtiApplication application;
    private AppExecutors appExecutors;
    private ArrayList<PreResetAppCheck> preResetAppChecks = new ArrayList<>();
    private ResetAppDialog resetAppDialog;
    private boolean resetCancelled = false;

    public ResetAppHelper(@NonNull DrishtiApplication drishtiApplication) {
        this.application = drishtiApplication;
        appExecutors = new AppExecutors();
        preResetAppChecks.add(new EventClientSyncedCheck());
        preResetAppChecks.add(new SettingsSyncedCheck());
        preResetAppChecks.add(new StructureSyncedCheck());
        preResetAppChecks.add(new TaskSyncedCheck());
    }

    public void startResetProcess(@Nullable AppCompatActivity activity, @Nullable OnCompleteClearDataCallback onCompleteClearDataCallback) {

        resetCancelled = false;
        // Show some UI here to display the reset progress

        if (activity != null) {
            resetAppDialog = ResetAppDialog.newInstance();
            resetAppDialog.show(activity.getSupportFragmentManager(), "rest-app-dialog");
            resetAppDialog.setOnCancelListener((dialogInterface) -> {
                showProgressText(activity.getString(R.string.cancelling));
                resetCancelled = true;
            });

            resetAppDialog.showText(activity.getString(R.string.stopping_services));
        }

        JobManager.create(application).cancelAll();

        if (resetAppDialog != null) {
            resetAppDialog.showText(activity.getString(R.string.performing_data_checks));
        }

        if (!resetCancelled) {
            performPreResetChecksAndResetProcess(onCompleteClearDataCallback);
        }
    }

    public void performPreResetChecksAndResetProcess(@Nullable OnCompleteClearDataCallback onCompleteClearDataCallback) {
        // Should be handled in the background
        appExecutors.diskIO()
                .execute(() -> {
                    try {
                        for (PreResetAppCheck preResetAppCheck : preResetAppChecks) {
                            if (!preResetAppCheck.isCheckOk(application)) {
                                if (resetCancelled) {
                                    dismissDialog();
                                    return;
                                }

                                if (!NetworkUtils.isNetworkAvailable()) {
                                    dismissDialog();
                                    appExecutors.mainThread().execute(new Runnable() {
                                        @Override
                                        public void run() {
                                            Toast.makeText(application, "No Internet Connection Available", Toast.LENGTH_LONG)
                                                    .show();
                                        }
                                    });

                                    resetCancelled = true;
                                    return;
                                }

                                performPreResetOperations(preResetAppCheck);
                            }
                        }

                        if (resetCancelled) {
                            dismissDialog();
                            return;
                        }

                        showProgressText(application.getString(R.string.clearing_application_data));

                        if (resetCancelled) {
                            dismissDialog();
                            return;
                        }

                        Timber.w("User %s has completely reset the app", application.getUsername());
                        performResetOperations();
                        appExecutors.mainThread()
                                .execute(() -> {
                                    dismissDialog();

                                    if (onCompleteClearDataCallback != null) {
                                        onCompleteClearDataCallback.onComplete();
                                    }
                                });

                    } catch (PreResetAppOperationException | AppResetException e) {
                        Timber.e(e);
                    }
                });
    }

    public void performResetOperations() throws AppResetException {
        clearSqCipherDb();
        clearP2PDb();
        clearAllPrivateKeyEntries();
        clearSharedPreferences();
    }

    protected void clearP2PDb() {
        P2POptions p2POptions = CoreLibrary.getInstance().getP2POptions();
        if (p2POptions != null && p2POptions.isEnableP2PLibrary()) {
            p2POptions.setAuthorizationService(null);
            AppDatabase roomP2PDb = P2PLibrary.getInstance().getDb();
            roomP2PDb.clearAllTables();
            Utils.deleteRoomDb(application.getApplicationContext(), roomP2PDb.getOpenHelper().getDatabaseName());
        }
    }

    public void performPreResetOperations(@NonNull PreResetAppCheck preResetAppCheck) throws PreResetAppOperationException {
        preResetAppCheck.performPreResetAppOperations(application);
    }

    protected boolean clearSharedPreferences() {
        SharedPreferences sharedPreferences = application.getContext().allSharedPreferences().getPreferences();
        if (sharedPreferences != null) {
            return sharedPreferences.edit().clear().commit();
        }

        return false;
    }

    protected boolean clearSqCipherDb() {
        return application.getRepository().deleteRepository();
    }

    protected void clearAllPrivateKeyEntries() throws AppResetException {
        KeyStore keyStore = application.getContext().userService().getKeyStore();
        if (keyStore != null) {
            try {
                Enumeration<String> keystoreEnumeration = keyStore.aliases();
                while (keystoreEnumeration.hasMoreElements()) {
                    String keyStoreAlias = keystoreEnumeration.nextElement();
                    keyStore.deleteEntry(keyStoreAlias);
                }
            } catch (KeyStoreException ex) {
                Timber.e(ex);
                throw new AppResetException(ex.getMessage(), ex);
            }
        }
    }

    public boolean addPreResetAppCheck(@NonNull PreResetAppCheck preResetAppCheck) {
        if (!preResetAppChecks.contains(preResetAppCheck)) {
            return preResetAppChecks.add(preResetAppCheck);
        }

        return false;
    }

    public boolean removePreResetAppCheck(@NonNull PreResetAppCheck preResetAppCheck) {
        return preResetAppChecks.remove(preResetAppCheck);
    }

    @Nullable
    public PreResetAppCheck removePreResetAppCheck(@NonNull String checkName) {
        for (PreResetAppCheck preResetAppCheck : preResetAppChecks) {
            if (checkName.equals(preResetAppCheck.getUniqueName())) {
                if (removePreResetAppCheck(preResetAppCheck)) {
                    return preResetAppCheck;
                }

                break;
            }
        }

        return null;
    }

    protected void dismissDialog() {
        if (resetAppDialog != null) {
            resetAppDialog.dismiss();
        }
    }


    @AnyThread
    public void showProgressText(@NonNull String progressText) {
        if (resetCancelled) {
            return;
        }

        appExecutors.mainThread()
                .execute(() -> {
                    if (resetAppDialog != null) {
                        resetAppDialog.showText(progressText);
                    }
                });

    }

}

1	package org.smartregister.multitenant;
2
3	import android.content.SharedPreferences;
4	import androidx.annotation.AnyThread;
5	import androidx.annotation.NonNull;
6	import androidx.annotation.Nullable;
7	import androidx.appcompat.app.AppCompatActivity;
8	import android.widget.Toast;
9
10	import com.evernote.android.job.JobManager;
11
12	import org.smartregister.CoreLibrary;
13	import org.smartregister.P2POptions;
14	import org.smartregister.R;
15	import org.smartregister.exception.AppResetException;
16	import org.smartregister.exception.PreResetAppOperationException;
17	import org.smartregister.listener.OnCompleteClearDataCallback;
18	import org.smartregister.multitenant.check.EventClientSyncedCheck;
19	import org.smartregister.multitenant.check.PreResetAppCheck;
20	import org.smartregister.multitenant.check.SettingsSyncedCheck;
21	import org.smartregister.multitenant.check.StructureSyncedCheck;
22	import org.smartregister.multitenant.check.TaskSyncedCheck;
23	import org.smartregister.p2p.P2PLibrary;
24	import org.smartregister.p2p.model.AppDatabase;
25	import org.smartregister.util.AppExecutors;
26	import org.smartregister.util.NetworkUtils;
27	import org.smartregister.util.Utils;
28	import org.smartregister.view.activity.DrishtiApplication;
29	import org.smartregister.view.dialog.ResetAppDialog;
30
31	import java.security.KeyStore;
32	import java.security.KeyStoreException;
33	import java.util.ArrayList;
34	import java.util.Enumeration;
35
36	import timber.log.Timber;
37
38	/**
39	* Created by Ephraim Kigamba - nek.eam@gmail.com on 09-04-2020.
40	*/
41	public class ResetAppHelper {
42
43	private DrishtiApplication application;
44	private AppExecutors appExecutors;
45	private ArrayList<PreResetAppCheck> preResetAppChecks = new ArrayList<>();	1✔
46	private ResetAppDialog resetAppDialog;
47	private boolean resetCancelled = false;	1✔
48
49	public ResetAppHelper(@NonNull DrishtiApplication drishtiApplication) {	1✔
50	this.application = drishtiApplication;	1✔
51	appExecutors = new AppExecutors();	1✔
52	preResetAppChecks.add(new EventClientSyncedCheck());	1✔
53	preResetAppChecks.add(new SettingsSyncedCheck());	1✔
54	preResetAppChecks.add(new StructureSyncedCheck());	1✔
55	preResetAppChecks.add(new TaskSyncedCheck());	1✔
56	}	1✔
57
58	public void startResetProcess(@Nullable AppCompatActivity activity, @Nullable OnCompleteClearDataCallback onCompleteClearDataCallback) {
59
60	resetCancelled = false;	1✔
61	// Show some UI here to display the reset progress
62
63	if (activity != null) {	1✔
64	resetAppDialog = ResetAppDialog.newInstance();	1✔
65	resetAppDialog.show(activity.getSupportFragmentManager(), "rest-app-dialog");	1✔
66	resetAppDialog.setOnCancelListener((dialogInterface) -> {	1✔
67	showProgressText(activity.getString(R.string.cancelling));	×
68	resetCancelled = true;	×
69	});	×
70
71	resetAppDialog.showText(activity.getString(R.string.stopping_services));	1✔
72	}
73
74	JobManager.create(application).cancelAll();	1✔
75
76	if (resetAppDialog != null) {	1✔
77	resetAppDialog.showText(activity.getString(R.string.performing_data_checks));	1✔
78	}
79
80	if (!resetCancelled) {	1✔
81	performPreResetChecksAndResetProcess(onCompleteClearDataCallback);	1✔
82	}
83	}	1✔
84
85	public void performPreResetChecksAndResetProcess(@Nullable OnCompleteClearDataCallback onCompleteClearDataCallback) {
86	// Should be handled in the background
87	appExecutors.diskIO()	1✔
88	.execute(() -> {	1✔
89	try {
90	for (PreResetAppCheck preResetAppCheck : preResetAppChecks) {	1✔
91	if (!preResetAppCheck.isCheckOk(application)) {	1✔
92	if (resetCancelled) {	1✔
93	dismissDialog();	×
94	return;	×
95	}
96
97	if (!NetworkUtils.isNetworkAvailable()) {	1✔
98	dismissDialog();	×
99	appExecutors.mainThread().execute(new Runnable() {	×
100	@Override
101	public void run() {
102	Toast.makeText(application, "No Internet Connection Available", Toast.LENGTH_LONG)	×
103	.show();	×
104	}	×
105	});
106
107	resetCancelled = true;	×
108	return;	×
109	}
110
111	performPreResetOperations(preResetAppCheck);	1✔
112	}
113	}	1✔
114
115	if (resetCancelled) {	1✔
116	dismissDialog();	×
117	return;	×
118	}
119
120	showProgressText(application.getString(R.string.clearing_application_data));	1✔
121
122	if (resetCancelled) {	1✔
123	dismissDialog();	×
124	return;	×
125	}
126
127	Timber.w("User %s has completely reset the app", application.getUsername());	1✔
128	performResetOperations();	1✔
129	appExecutors.mainThread()	1✔
130	.execute(() -> {	1✔
131	dismissDialog();	1✔
132
133	if (onCompleteClearDataCallback != null) {	1✔
134	onCompleteClearDataCallback.onComplete();	×
135	}
136	});	1✔
137
138	} catch (PreResetAppOperationException \| AppResetException e) {	×
139	Timber.e(e);	×
140	}	1✔
141	});	1✔
142	}	1✔
143
144	public void performResetOperations() throws AppResetException {
145	clearSqCipherDb();	1✔
146	clearP2PDb();	1✔
147	clearAllPrivateKeyEntries();	1✔
148	clearSharedPreferences();	1✔
149	}	1✔
150
151	protected void clearP2PDb() {
152	P2POptions p2POptions = CoreLibrary.getInstance().getP2POptions();	1✔
153	if (p2POptions != null && p2POptions.isEnableP2PLibrary()) {	1✔
154	p2POptions.setAuthorizationService(null);	1✔
155	AppDatabase roomP2PDb = P2PLibrary.getInstance().getDb();	1✔
156	roomP2PDb.clearAllTables();	1✔
157	Utils.deleteRoomDb(application.getApplicationContext(), roomP2PDb.getOpenHelper().getDatabaseName());	1✔
158	}
159	}	1✔
160
161	public void performPreResetOperations(@NonNull PreResetAppCheck preResetAppCheck) throws PreResetAppOperationException {
162	preResetAppCheck.performPreResetAppOperations(application);	1✔
163	}	1✔
164
165	protected boolean clearSharedPreferences() {
166	SharedPreferences sharedPreferences = application.getContext().allSharedPreferences().getPreferences();	1✔
167	if (sharedPreferences != null) {	1✔
168	return sharedPreferences.edit().clear().commit();	1✔
169	}
170
171	return false;	×
172	}
173
174	protected boolean clearSqCipherDb() {
175	return application.getRepository().deleteRepository();	1✔
176	}
177
178	protected void clearAllPrivateKeyEntries() throws AppResetException {
179	KeyStore keyStore = application.getContext().userService().getKeyStore();	1✔
180	if (keyStore != null) {	1✔
181	try {
182	Enumeration<String> keystoreEnumeration = keyStore.aliases();	1✔
183	while (keystoreEnumeration.hasMoreElements()) {	1✔
184	String keyStoreAlias = keystoreEnumeration.nextElement();	1✔
185	keyStore.deleteEntry(keyStoreAlias);	1✔
186	}	1✔
187	} catch (KeyStoreException ex) {	×
188	Timber.e(ex);	×
189	throw new AppResetException(ex.getMessage(), ex);	×
190	}	1✔
191	}
192	}	1✔
193
194	public boolean addPreResetAppCheck(@NonNull PreResetAppCheck preResetAppCheck) {
195	if (!preResetAppChecks.contains(preResetAppCheck)) {	1✔
196	return preResetAppChecks.add(preResetAppCheck);	1✔
197	}
198
199	return false;	×
200	}
201
202	public boolean removePreResetAppCheck(@NonNull PreResetAppCheck preResetAppCheck) {
203	return preResetAppChecks.remove(preResetAppCheck);	1✔
204	}
205
206	@Nullable
207	public PreResetAppCheck removePreResetAppCheck(@NonNull String checkName) {
208	for (PreResetAppCheck preResetAppCheck : preResetAppChecks) {	1✔
209	if (checkName.equals(preResetAppCheck.getUniqueName())) {	1✔
210	if (removePreResetAppCheck(preResetAppCheck)) {	1✔
211	return preResetAppCheck;	1✔
212	}
213
214	break;
215	}
216	}	1✔
217
218	return null;	1✔
219	}
220
221	protected void dismissDialog() {
222	if (resetAppDialog != null) {	1✔
223	resetAppDialog.dismiss();	×
224	}
225	}	1✔
226
227
228	@AnyThread
229	public void showProgressText(@NonNull String progressText) {
230	if (resetCancelled) {	1✔
231	return;	×
232	}
233
234	appExecutors.mainThread()	1✔
235	.execute(() -> {	1✔
236	if (resetAppDialog != null) {	1✔
237	resetAppDialog.showText(progressText);	1✔
238	}
239	});	1✔
240
241	}	1✔
242
243	}

opensrp / opensrp-client-core / #173

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous