#182

Committed 08 Aug 2024 12:55PM UTC coverage: 68.316% (-0.08%) from 68.395%

Build # #182

Build Type

Pull #925

github

Committed by

web-flow

Commit Message

Merge 0883be0a0 into 4fcf06cf5

Pull Request Pull Request #925: migrate SyncserviceJob to work manager

Run Details

18308 of 26799 relevant lines covered (68.32%)

0.68 hits per line

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

85.14

opensrp-core/src/main/java/org/smartregister/repository/AllSharedPreferences.java

package org.smartregister.repository;

import android.content.SharedPreferences;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import org.apache.commons.lang3.StringUtils;
import org.smartregister.AllConstants;
import org.smartregister.CoreLibrary;
import org.smartregister.util.Log;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;

public class AllSharedPreferences {
    public static final String ANM_IDENTIFIER_PREFERENCE_KEY = "anmIdentifier";
    public static final String ANM_IDENTIFIER_SET_PREFERENCE_KEY = "anmIdentifierSet";
    private static final String HOST = "HOST";
    private static final String PORT = "PORT";
    private static final String LAST_SYNC_DATE = "LAST_SYNC_DATE";
    private static final String LAST_UPDATED_AT_DATE = "LAST_UPDATED_AT_DATE";
    private static final String LAST_CHECK_TIMESTAMP = "LAST_SYNC_CHECK_TIMESTAMP";
    public final static String LAST_SETTINGS_SYNC_TIMESTAMP = "LAST_SETTINGS_SYNC_TIMESTAMP";
    private static final String LAST_CLIENT_PROCESSED_TIMESTAMP = "LAST_CLIENT_PROCESSED_TIMESTAMP";
    private static final String TRANSACTIONS_KILLED_FLAG = "TRANSACTIONS_KILLED_FLAG";
    private static final String MIGRATED_TO_SQLITE_4 = "MIGRATED_TO_SQLITE_4";
    private static final String PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD = "PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD";
    private static final String PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD = "PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD";
    public static final String MANIFEST_VERSION = "MANIFEST_VERSION";
    public static final String FORMS_VERSION = "FORMS_VERSION";
    private static final String ENCRYPTED_PASSPHRASE_KEY = "ENCRYPTED_PASSPHRASE_KEY";
    private static final String DB_ENCRYPTION_VERSION = "DB_ENCRYPTION_VERSION";
    private SharedPreferences preferences;
    private String LAST_AUTHENTICATION_HTTP_STATUS = "LAST_AUTHENTICATION_HTTP_STATUS";

    public AllSharedPreferences(SharedPreferences preferences) {
        this.preferences = preferences;
    }


    public void updateANMUserName(String userName) {
        preferences.edit().putString(ANM_IDENTIFIER_PREFERENCE_KEY, userName).commit();

        Set<String> anmIdentifiers = new HashSet<>(preferences.getStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, new HashSet<>()));
        anmIdentifiers.add(userName);
        preferences.edit().putStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, anmIdentifiers).commit();
    }

    public String fetchRegisteredANM() {
        return preferences.getString(ANM_IDENTIFIER_PREFERENCE_KEY, "").trim();
    }

    public boolean isRegisteredANM(String userName) {
        return preferences.getStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, new HashSet<>()).contains(userName);
    }

    public boolean fetchForceRemoteLogin(String username) {
        return preferences.getBoolean(new StringBuffer(AllConstants.FORCE_REMOTE_LOGIN).append('_').append(username).toString(), true);
    }

    public void saveForceRemoteLogin(boolean forceRemoteLogin, String username) {
        preferences.edit().putBoolean(new StringBuffer(AllConstants.FORCE_REMOTE_LOGIN).append('_').append(username).toString(), forceRemoteLogin).commit();
    }

    public String fetchServerTimeZone() {
        return preferences.getString(AllConstants.SERVER_TIMEZONE, null);
    }

    public void saveServerTimeZone(String serverTimeZone) {
        preferences.edit().putString(AllConstants.SERVER_TIMEZONE, serverTimeZone).commit();
    }

    public String fetchEncryptedGroupId(String username) {
        if (username != null) {
            return preferences.getString(AllConstants.ENCRYPTED_GROUP_ID_PREFIX + username, null);
        }
        return null;
    }

    public String fetchPioneerUser() {
        return preferences.getString(AllConstants.PIONEER_USER, null);
    }

    public void savePioneerUser(String username) {
        preferences.edit().putString(AllConstants.PIONEER_USER, username).commit();
    }

    public void saveDefaultLocalityId(String username, String localityId) {
        if (username != null) {
            preferences.edit().putString(AllConstants.DEFAULT_LOCALITY_ID_PREFIX + username, localityId)
                    .commit();
        }
    }

    public String fetchDefaultLocalityId(String username) {
        if (username != null) {
            return preferences.getString(AllConstants.DEFAULT_LOCALITY_ID_PREFIX + username, null);
        }
        return null;
    }

    public void saveUserLocalityId(String username, String localityId) {
        if (username != null) {
            preferences.edit().putString(AllConstants.USER_LOCALITY_ID_PREFIX + username, localityId)
                    .commit();
        }
    }

    public String fetchUserLocalityId(String username) {
        if (username != null) {
            return preferences.getString(AllConstants.USER_LOCALITY_ID_PREFIX + username, null);
        }
        return null;
    }

    public void saveDefaultTeam(String username, String team) {
        if (username != null) {
            preferences.edit().putString(AllConstants.DEFAULT_TEAM_PREFIX + username, team)
                    .commit();
        }
    }

    public String fetchDefaultTeam(String username) {
        if (username != null) {
            return preferences.getString(AllConstants.DEFAULT_TEAM_PREFIX + username, null);
        }
        return null;
    }

    public void saveDefaultTeamId(String username, String teamId) {
        if (username != null) {
            preferences.edit().putString(AllConstants.DEFAULT_TEAM_ID_PREFIX + username, teamId)
                    .commit();
        }
    }

    public String fetchDefaultTeamId(String username) {
        if (username != null) {
            return preferences.getString(AllConstants.DEFAULT_TEAM_ID_PREFIX + username, null);
        }
        return null;
    }

    public String fetchCurrentLocality() {
        return preferences.getString(AllConstants.CURRENT_LOCALITY, null);
    }

    public void saveCurrentLocality(String currentLocality) {
        preferences.edit().putString(AllConstants.CURRENT_LOCALITY, currentLocality).commit();
    }

    public String fetchCurrentDataStrategy() {
        return preferences.getString(AllConstants.DATA_STRATEGY, AllConstants.DATA_CAPTURE_STRATEGY.NORMAL);
    }

    public void saveCurrentDataStrategy(String currentDataStrategy) {
        preferences.edit().putString(AllConstants.DATA_STRATEGY, currentDataStrategy).commit();
    }

    public String fetchLanguagePreference() {
        return preferences.getString(AllConstants.LANGUAGE_PREFERENCE_KEY, AllConstants.DEFAULT_LOCALE).trim();
    }

    public void saveLanguagePreference(String languagePreference) {
        preferences.edit().putString(AllConstants.LANGUAGE_PREFERENCE_KEY, languagePreference).commit();
    }

    public Boolean fetchIsSyncInProgress() {
        return preferences.getBoolean(AllConstants.IS_SYNC_IN_PROGRESS_PREFERENCE_KEY, false);
    }

    public void saveIsSyncInProgress(Boolean isSyncInProgress) {
        preferences.edit().putBoolean(AllConstants.IS_SYNC_IN_PROGRESS_PREFERENCE_KEY, isSyncInProgress).commit();
    }

    public String fetchBaseURL(String baseurl) {

        String url = preferences.getString(AllConstants.DRISHTI_BASE_URL, baseurl);
        return StringUtils.isNotBlank(url) && url.endsWith("/") ? url.substring(0, url.length() - 1) : url;

    }

    public String fetchHost(String host) {
        if ((host == null || host.isEmpty()) && preferences.getString(HOST, host).equals(host)) {
            updateUrl(fetchBaseURL(""));
        }
        return preferences.getString(HOST, host);
    }

    public void saveHost(String host) {
        preferences.edit().putString(HOST, host).commit();
    }

    public Integer fetchPort(Integer port) {

        return Integer.parseInt(preferences.getString(PORT, "" + port));
    }

    public Long fetchLastSyncDate(long lastSyncDate) {

        return preferences.getLong(LAST_SYNC_DATE, lastSyncDate);
    }

    public void saveLastSyncDate(long lastSyncDate) {
        preferences.edit().putLong(LAST_SYNC_DATE, lastSyncDate).commit();
    }

    public Long fetchLastUpdatedAtDate(long lastSyncDate) {

        return preferences.getLong(LAST_UPDATED_AT_DATE, lastSyncDate);
    }

    public void saveLastUpdatedAtDate(long lastSyncDate) {
        preferences.edit().putLong(LAST_UPDATED_AT_DATE, lastSyncDate).commit();
    }

    public void savePort(Integer port) {
        preferences.edit().putString(PORT, String.valueOf(port)).commit();
    }

    public void savePreference(String key, String value) {
        preferences.edit().putString(key, value).commit();
    }

    public String getPreference(String key) {
        return preferences.getString(key, "");
    }

    public boolean getBooleanPreference(String key) {
        return preferences.getBoolean(key, false);
    }

    public void updateUrl(String baseUrl) {
        try {

            URL url = new URL(baseUrl);

            String base = url.getProtocol() + "://" + url.getHost();
            int port = url.getPort();

            Log.logInfo("Base URL: " + base);
            Log.logInfo("Port: " + port);

            saveHost(base);
            savePort(port);

        } catch (MalformedURLException e) {
            Log.logError("Malformed Url: " + baseUrl);
        }
    }

    public void updateANMPreferredName(String userName, String preferredName) {
        preferences.edit().putString(userName, preferredName).commit();
    }

    public String getANMPreferredName(String userName) {
        return preferences.getString(userName, "");
    }

    public void saveIsSyncInitial(boolean initialSynStatus) {
        preferences.edit().putBoolean(AllConstants.IS_SYNC_INITIAL_KEY, initialSynStatus).commit();
    }

    public Boolean fetchIsSyncInitial() {
        return preferences.getBoolean(AllConstants.IS_SYNC_INITIAL_KEY, false);
    }

    public long fetchLastCheckTimeStamp() {
        return preferences.getLong(LAST_CHECK_TIMESTAMP, 0);
    }

    public void updateLastCheckTimeStamp(long lastSyncTimeStamp) {
        preferences.edit().putLong(LAST_CHECK_TIMESTAMP, lastSyncTimeStamp).commit();
    }

    public void updateLastSettingsSyncTimeStamp(long lastSettingsSync) {
        preferences.edit().putLong(LAST_SETTINGS_SYNC_TIMESTAMP, lastSettingsSync).commit();
    }

    public long fetchLastSettingsSyncTimeStamp() {
        return preferences.getLong(LAST_SETTINGS_SYNC_TIMESTAMP, 0);
    }

    public boolean isMigratedToSqlite4() {
        return preferences.getBoolean(MIGRATED_TO_SQLITE_4, false);
    }

    public void setMigratedToSqlite4() {
        preferences.edit().putBoolean(MIGRATED_TO_SQLITE_4, true).commit();
    }

    public int getLastPeerToPeerSyncProcessedEvent() {
        return preferences.getInt(PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD, -1);
    }

    public void setLastPeerToPeerSyncProcessedEvent(int lastEventRowId) {
        preferences.edit().putInt(PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD, lastEventRowId).commit();
    }

    public int getLastPeerToPeerSyncForeignProcessedEvent() {
        return preferences.getInt(PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD, -1);
    }

    public void setLastPeerToPeerSyncForeignProcessedEvent(int lastEventRowId) {
        preferences.edit().putInt(PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD, lastEventRowId).commit();
    }

    public boolean isPeerToPeerUnprocessedEvents() {
        return getLastPeerToPeerSyncProcessedEvent() != -1;
    }

    public void resetLastPeerToPeerSyncProcessedEvent() {
        setLastPeerToPeerSyncProcessedEvent(-1);
    }


    public void updateLastClientProcessedTimeStamp(long lastProcessed) {
        preferences.edit().putLong(LAST_CLIENT_PROCESSED_TIMESTAMP, lastProcessed).commit();
    }

    public long fetchLastClientProcessedTimeStamp() {
        return preferences.getLong(LAST_CLIENT_PROCESSED_TIMESTAMP, 0);
    }


    public void updateTransactionsKilledFlag(boolean transactionsKilled) {
        preferences.edit().putBoolean(TRANSACTIONS_KILLED_FLAG, transactionsKilled).commit();
    }

    public boolean fetchTransactionsKilledFlag() {
        return preferences.getBoolean(TRANSACTIONS_KILLED_FLAG, false);
    }

    public boolean saveManifestVersion(@NonNull String manifestVersion) {
        return preferences.edit().putString(MANIFEST_VERSION, manifestVersion).commit();
    }

    @Nullable
    public String fetchManifestVersion() {
        return preferences.getString(MANIFEST_VERSION, null);
    }

    public boolean saveFormsVersion(@NonNull String formsVersion) {
        return preferences.edit().putString(FORMS_VERSION, formsVersion).commit();
    }

    @Nullable
    public String fetchFormsVersion() {
        return preferences.getString(FORMS_VERSION, null);
    }

    @Nullable
    public SharedPreferences getPreferences() {
        return preferences;
    }

    public String getPassphrase(String encryptionParam, String username) {
        return preferences.getString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).append('_').append(username).toString(), null);
    }

    public void savePassphrase(String passphrase, String encryptionParam, String username) {
        preferences.edit().putString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).append('_').append(username).toString(), passphrase).commit();
    }

    /**
     * Allows migration of older passphrase so that is linked to pioneer user
     **/
    public void migratePassphrase() {
        if (CoreLibrary.getInstance().getSyncConfiguration() == null) {
            return;
        }
        String encryptionParam = CoreLibrary.getInstance().getSyncConfiguration().getEncryptionParam().name();
        String passphrase = preferences.getString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).toString(), null);
        if (passphrase != null) {
            savePassphrase(passphrase, encryptionParam, fetchPioneerUser());
        }
    }

    public int getDBEncryptionVersion() {
        return preferences.getInt(DB_ENCRYPTION_VERSION, 0);
    }

    public void setDBEncryptionVersion(int encryptionVersion) {
        preferences.edit().putInt(DB_ENCRYPTION_VERSION, encryptionVersion).commit();
    }

    /**
     * Used for logic with allowOfflineLoginWithInvalidToken
     * @param httpStatus
     */
    public void updateLastAuthenticationHttpStatus(int httpStatus) {
        preferences.edit().putInt(LAST_AUTHENTICATION_HTTP_STATUS, httpStatus).apply();
    }

    public int getLastAuthenticationHttpStatus() {
        return preferences.getInt(LAST_AUTHENTICATION_HTTP_STATUS, 0);
    }

    public void saveUserId(String username, String userId) {
        preferences.edit().putString(AllConstants.USER_ID_PREFIX + username, userId).apply();
    }

    public String getUserId(String userName) {
        return StringUtils.isNotBlank(userName) ? preferences.getString(AllConstants.USER_ID_PREFIX + userName, null) : "";
    }
}


1	package org.smartregister.repository;
2
3	import android.content.SharedPreferences;
4
5	import androidx.annotation.NonNull;
6	import androidx.annotation.Nullable;
7
8	import org.apache.commons.lang3.StringUtils;
9	import org.smartregister.AllConstants;
10	import org.smartregister.CoreLibrary;
11	import org.smartregister.util.Log;
12
13	import java.net.MalformedURLException;
14	import java.net.URL;
15	import java.util.HashSet;
16	import java.util.Set;
17
18	public class AllSharedPreferences {
19	public static final String ANM_IDENTIFIER_PREFERENCE_KEY = "anmIdentifier";
20	public static final String ANM_IDENTIFIER_SET_PREFERENCE_KEY = "anmIdentifierSet";
21	private static final String HOST = "HOST";
22	private static final String PORT = "PORT";
23	private static final String LAST_SYNC_DATE = "LAST_SYNC_DATE";
24	private static final String LAST_UPDATED_AT_DATE = "LAST_UPDATED_AT_DATE";
25	private static final String LAST_CHECK_TIMESTAMP = "LAST_SYNC_CHECK_TIMESTAMP";
26	public final static String LAST_SETTINGS_SYNC_TIMESTAMP = "LAST_SETTINGS_SYNC_TIMESTAMP";
27	private static final String LAST_CLIENT_PROCESSED_TIMESTAMP = "LAST_CLIENT_PROCESSED_TIMESTAMP";
28	private static final String TRANSACTIONS_KILLED_FLAG = "TRANSACTIONS_KILLED_FLAG";
29	private static final String MIGRATED_TO_SQLITE_4 = "MIGRATED_TO_SQLITE_4";
30	private static final String PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD = "PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD";
31	private static final String PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD = "PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD";
32	public static final String MANIFEST_VERSION = "MANIFEST_VERSION";
33	public static final String FORMS_VERSION = "FORMS_VERSION";
34	private static final String ENCRYPTED_PASSPHRASE_KEY = "ENCRYPTED_PASSPHRASE_KEY";
35	private static final String DB_ENCRYPTION_VERSION = "DB_ENCRYPTION_VERSION";
36	private SharedPreferences preferences;
37	private String LAST_AUTHENTICATION_HTTP_STATUS = "LAST_AUTHENTICATION_HTTP_STATUS";	1✔
38
39	public AllSharedPreferences(SharedPreferences preferences) {	1✔
40	this.preferences = preferences;	1✔
41	}	1✔
42
43
44	public void updateANMUserName(String userName) {
45	preferences.edit().putString(ANM_IDENTIFIER_PREFERENCE_KEY, userName).commit();	1✔
46
47	Set<String> anmIdentifiers = new HashSet<>(preferences.getStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, new HashSet<>()));	1✔
48	anmIdentifiers.add(userName);	1✔
49	preferences.edit().putStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, anmIdentifiers).commit();	1✔
50	}	1✔
51
52	public String fetchRegisteredANM() {
53	return preferences.getString(ANM_IDENTIFIER_PREFERENCE_KEY, "").trim();	1✔
54	}
55
56	public boolean isRegisteredANM(String userName) {
57	return preferences.getStringSet(ANM_IDENTIFIER_SET_PREFERENCE_KEY, new HashSet<>()).contains(userName);	×
58	}
59
60	public boolean fetchForceRemoteLogin(String username) {
61	return preferences.getBoolean(new StringBuffer(AllConstants.FORCE_REMOTE_LOGIN).append('_').append(username).toString(), true);	1✔
62	}
63
64	public void saveForceRemoteLogin(boolean forceRemoteLogin, String username) {
65	preferences.edit().putBoolean(new StringBuffer(AllConstants.FORCE_REMOTE_LOGIN).append('_').append(username).toString(), forceRemoteLogin).commit();	1✔
66	}	1✔
67
68	public String fetchServerTimeZone() {
69	return preferences.getString(AllConstants.SERVER_TIMEZONE, null);	1✔
70	}
71
72	public void saveServerTimeZone(String serverTimeZone) {
73	preferences.edit().putString(AllConstants.SERVER_TIMEZONE, serverTimeZone).commit();	1✔
74	}	1✔
75
76	public String fetchEncryptedGroupId(String username) {
77	if (username != null) {	×
78	return preferences.getString(AllConstants.ENCRYPTED_GROUP_ID_PREFIX + username, null);	×
79	}
80	return null;	×
81	}
82
83	public String fetchPioneerUser() {
84	return preferences.getString(AllConstants.PIONEER_USER, null);	1✔
85	}
86
87	public void savePioneerUser(String username) {
88	preferences.edit().putString(AllConstants.PIONEER_USER, username).commit();	1✔
89	}	1✔
90
91	public void saveDefaultLocalityId(String username, String localityId) {
92	if (username != null) {	1✔
93	preferences.edit().putString(AllConstants.DEFAULT_LOCALITY_ID_PREFIX + username, localityId)	1✔
94	.commit();	1✔
95	}
96	}	1✔
97
98	public String fetchDefaultLocalityId(String username) {
99	if (username != null) {	1✔
100	return preferences.getString(AllConstants.DEFAULT_LOCALITY_ID_PREFIX + username, null);	1✔
101	}
102	return null;	1✔
103	}
104
105	public void saveUserLocalityId(String username, String localityId) {
106	if (username != null) {	1✔
107	preferences.edit().putString(AllConstants.USER_LOCALITY_ID_PREFIX + username, localityId)	1✔
108	.commit();	1✔
109	}
110	}	1✔
111
112	public String fetchUserLocalityId(String username) {
113	if (username != null) {	1✔
114	return preferences.getString(AllConstants.USER_LOCALITY_ID_PREFIX + username, null);	1✔
115	}
116	return null;	1✔
117	}
118
119	public void saveDefaultTeam(String username, String team) {
120	if (username != null) {	1✔
121	preferences.edit().putString(AllConstants.DEFAULT_TEAM_PREFIX + username, team)	1✔
122	.commit();	1✔
123	}
124	}	1✔
125
126	public String fetchDefaultTeam(String username) {
127	if (username != null) {	1✔
128	return preferences.getString(AllConstants.DEFAULT_TEAM_PREFIX + username, null);	1✔
129	}
130	return null;	1✔
131	}
132
133	public void saveDefaultTeamId(String username, String teamId) {
134	if (username != null) {	1✔
135	preferences.edit().putString(AllConstants.DEFAULT_TEAM_ID_PREFIX + username, teamId)	1✔
136	.commit();	1✔
137	}
138	}	1✔
139
140	public String fetchDefaultTeamId(String username) {
141	if (username != null) {	1✔
142	return preferences.getString(AllConstants.DEFAULT_TEAM_ID_PREFIX + username, null);	1✔
143	}
144	return null;	1✔
145	}
146
147	public String fetchCurrentLocality() {
148	return preferences.getString(AllConstants.CURRENT_LOCALITY, null);	1✔
149	}
150
151	public void saveCurrentLocality(String currentLocality) {
152	preferences.edit().putString(AllConstants.CURRENT_LOCALITY, currentLocality).commit();	1✔
153	}	1✔
154
155	public String fetchCurrentDataStrategy() {
156	return preferences.getString(AllConstants.DATA_STRATEGY, AllConstants.DATA_CAPTURE_STRATEGY.NORMAL);	1✔
157	}
158
159	public void saveCurrentDataStrategy(String currentDataStrategy) {
160	preferences.edit().putString(AllConstants.DATA_STRATEGY, currentDataStrategy).commit();	1✔
161	}	1✔
162
163	public String fetchLanguagePreference() {
164	return preferences.getString(AllConstants.LANGUAGE_PREFERENCE_KEY, AllConstants.DEFAULT_LOCALE).trim();	1✔
165	}
166
167	public void saveLanguagePreference(String languagePreference) {
168	preferences.edit().putString(AllConstants.LANGUAGE_PREFERENCE_KEY, languagePreference).commit();	1✔
169	}	1✔
170
171	public Boolean fetchIsSyncInProgress() {
172	return preferences.getBoolean(AllConstants.IS_SYNC_IN_PROGRESS_PREFERENCE_KEY, false);	1✔
173	}
174
175	public void saveIsSyncInProgress(Boolean isSyncInProgress) {
176	preferences.edit().putBoolean(AllConstants.IS_SYNC_IN_PROGRESS_PREFERENCE_KEY, isSyncInProgress).commit();	1✔
177	}	1✔
178
179	public String fetchBaseURL(String baseurl) {
180
181	String url = preferences.getString(AllConstants.DRISHTI_BASE_URL, baseurl);	1✔
182	return StringUtils.isNotBlank(url) && url.endsWith("/") ? url.substring(0, url.length() - 1) : url;	1✔
183
184	}
185
186	public String fetchHost(String host) {
187	if ((host == null \|\| host.isEmpty()) && preferences.getString(HOST, host).equals(host)) {	1✔
188	updateUrl(fetchBaseURL(""));	1✔
189	}
190	return preferences.getString(HOST, host);	1✔
191	}
192
193	public void saveHost(String host) {
194	preferences.edit().putString(HOST, host).commit();	1✔
195	}	1✔
196
197	public Integer fetchPort(Integer port) {
198
199	return Integer.parseInt(preferences.getString(PORT, "" + port));	1✔
200	}
201
202	public Long fetchLastSyncDate(long lastSyncDate) {
203
204	return preferences.getLong(LAST_SYNC_DATE, lastSyncDate);	1✔
205	}
206
207	public void saveLastSyncDate(long lastSyncDate) {
208	preferences.edit().putLong(LAST_SYNC_DATE, lastSyncDate).commit();	1✔
209	}	1✔
210
211	public Long fetchLastUpdatedAtDate(long lastSyncDate) {
212
213	return preferences.getLong(LAST_UPDATED_AT_DATE, lastSyncDate);	1✔
214	}
215
216	public void saveLastUpdatedAtDate(long lastSyncDate) {
217	preferences.edit().putLong(LAST_UPDATED_AT_DATE, lastSyncDate).commit();	1✔
218	}	1✔
219
220	public void savePort(Integer port) {
221	preferences.edit().putString(PORT, String.valueOf(port)).commit();	1✔
222	}	1✔
223
224	public void savePreference(String key, String value) {
225	preferences.edit().putString(key, value).commit();	1✔
226	}	1✔
227
228	public String getPreference(String key) {
229	return preferences.getString(key, "");	1✔
230	}
231
232	public boolean getBooleanPreference(String key) {
233	return preferences.getBoolean(key, false);	×
234	}
235
236	public void updateUrl(String baseUrl) {
237	try {
238
239	URL url = new URL(baseUrl);	1✔
240
241	String base = url.getProtocol() + "://" + url.getHost();	1✔
242	int port = url.getPort();	1✔
243
244	Log.logInfo("Base URL: " + base);	1✔
245	Log.logInfo("Port: " + port);	1✔
246
247	saveHost(base);	1✔
248	savePort(port);	1✔
249
250	} catch (MalformedURLException e) {	1✔
251	Log.logError("Malformed Url: " + baseUrl);	1✔
252	}	1✔
253	}	1✔
254
255	public void updateANMPreferredName(String userName, String preferredName) {
256	preferences.edit().putString(userName, preferredName).commit();	1✔
257	}	1✔
258
259	public String getANMPreferredName(String userName) {
260	return preferences.getString(userName, "");	1✔
261	}
262
263	public void saveIsSyncInitial(boolean initialSynStatus) {
264	preferences.edit().putBoolean(AllConstants.IS_SYNC_INITIAL_KEY, initialSynStatus).commit();	1✔
265	}	1✔
266
267	public Boolean fetchIsSyncInitial() {
268	return preferences.getBoolean(AllConstants.IS_SYNC_INITIAL_KEY, false);	1✔
269	}
270
271	public long fetchLastCheckTimeStamp() {
272	return preferences.getLong(LAST_CHECK_TIMESTAMP, 0);	1✔
273	}
274
275	public void updateLastCheckTimeStamp(long lastSyncTimeStamp) {
276	preferences.edit().putLong(LAST_CHECK_TIMESTAMP, lastSyncTimeStamp).commit();	1✔
277	}	1✔
278
279	public void updateLastSettingsSyncTimeStamp(long lastSettingsSync) {
280	preferences.edit().putLong(LAST_SETTINGS_SYNC_TIMESTAMP, lastSettingsSync).commit();	1✔
281	}	1✔
282
283	public long fetchLastSettingsSyncTimeStamp() {
284	return preferences.getLong(LAST_SETTINGS_SYNC_TIMESTAMP, 0);	1✔
285	}
286
287	public boolean isMigratedToSqlite4() {
288	return preferences.getBoolean(MIGRATED_TO_SQLITE_4, false);	1✔
289	}
290
291	public void setMigratedToSqlite4() {
292	preferences.edit().putBoolean(MIGRATED_TO_SQLITE_4, true).commit();	1✔
293	}	1✔
294
295	public int getLastPeerToPeerSyncProcessedEvent() {
296	return preferences.getInt(PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD, -1);	1✔
297	}
298
299	public void setLastPeerToPeerSyncProcessedEvent(int lastEventRowId) {
300	preferences.edit().putInt(PEER_TO_PEER_SYNC_LAST_PROCESSED_RECORD, lastEventRowId).commit();	1✔
301	}	1✔
302
303	public int getLastPeerToPeerSyncForeignProcessedEvent() {
304	return preferences.getInt(PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD, -1);	×
305	}
306
307	public void setLastPeerToPeerSyncForeignProcessedEvent(int lastEventRowId) {
308	preferences.edit().putInt(PEER_TO_PEER_SYNC_LAST_FOREIGN_PROCESSED_RECORD, lastEventRowId).commit();	×
309	}	×
310
311	public boolean isPeerToPeerUnprocessedEvents() {
312	return getLastPeerToPeerSyncProcessedEvent() != -1;	1✔
313	}
314
315	public void resetLastPeerToPeerSyncProcessedEvent() {
316	setLastPeerToPeerSyncProcessedEvent(-1);	1✔
317	}	1✔
318
319
320	public void updateLastClientProcessedTimeStamp(long lastProcessed) {
321	preferences.edit().putLong(LAST_CLIENT_PROCESSED_TIMESTAMP, lastProcessed).commit();	1✔
322	}	1✔
323
324	public long fetchLastClientProcessedTimeStamp() {
325	return preferences.getLong(LAST_CLIENT_PROCESSED_TIMESTAMP, 0);	1✔
326	}
327
328
329	public void updateTransactionsKilledFlag(boolean transactionsKilled) {
330	preferences.edit().putBoolean(TRANSACTIONS_KILLED_FLAG, transactionsKilled).commit();	1✔
331	}	1✔
332
333	public boolean fetchTransactionsKilledFlag() {
334	return preferences.getBoolean(TRANSACTIONS_KILLED_FLAG, false);	1✔
335	}
336
337	public boolean saveManifestVersion(@NonNull String manifestVersion) {
338	return preferences.edit().putString(MANIFEST_VERSION, manifestVersion).commit();	1✔
339	}
340
341	@Nullable
342	public String fetchManifestVersion() {
343	return preferences.getString(MANIFEST_VERSION, null);	1✔
344	}
345
346	public boolean saveFormsVersion(@NonNull String formsVersion) {
347	return preferences.edit().putString(FORMS_VERSION, formsVersion).commit();	1✔
348	}
349
350	@Nullable
351	public String fetchFormsVersion() {
352	return preferences.getString(FORMS_VERSION, null);	×
353	}
354
355	@Nullable
356	public SharedPreferences getPreferences() {
357	return preferences;	1✔
358	}
359
360	public String getPassphrase(String encryptionParam, String username) {
361	return preferences.getString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).append('_').append(username).toString(), null);	×
362	}
363
364	public void savePassphrase(String passphrase, String encryptionParam, String username) {
365	preferences.edit().putString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).append('_').append(username).toString(), passphrase).commit();	×
366	}	×
367
368	/**
369	* Allows migration of older passphrase so that is linked to pioneer user
370	**/
371	public void migratePassphrase() {
372	if (CoreLibrary.getInstance().getSyncConfiguration() == null) {	1✔
373	return;	×
374	}
375	String encryptionParam = CoreLibrary.getInstance().getSyncConfiguration().getEncryptionParam().name();	1✔
376	String passphrase = preferences.getString(new StringBuffer(ENCRYPTED_PASSPHRASE_KEY).append('_').append(encryptionParam).toString(), null);	1✔
377	if (passphrase != null) {	1✔
378	savePassphrase(passphrase, encryptionParam, fetchPioneerUser());	×
379	}
380	}	1✔
381
382	public int getDBEncryptionVersion() {
383	return preferences.getInt(DB_ENCRYPTION_VERSION, 0);	1✔
384	}
385
386	public void setDBEncryptionVersion(int encryptionVersion) {
387	preferences.edit().putInt(DB_ENCRYPTION_VERSION, encryptionVersion).commit();	×
388	}	×
389
390	/**
391	* Used for logic with allowOfflineLoginWithInvalidToken
392	* @param httpStatus
393	*/
394	public void updateLastAuthenticationHttpStatus(int httpStatus) {
395	preferences.edit().putInt(LAST_AUTHENTICATION_HTTP_STATUS, httpStatus).apply();	×
396	}	×
397
398	public int getLastAuthenticationHttpStatus() {
399	return preferences.getInt(LAST_AUTHENTICATION_HTTP_STATUS, 0);	×
400	}
401
402	public void saveUserId(String username, String userId) {
403	preferences.edit().putString(AllConstants.USER_ID_PREFIX + username, userId).apply();	×
404	}	×
405
406	public String getUserId(String userName) {
407	return StringUtils.isNotBlank(userName) ? preferences.getString(AllConstants.USER_ID_PREFIX + userName, null) : "";	×
408	}
409	}
410

opensrp / opensrp-client-core / #182

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