#901

pending completion

Build # #901

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Merge pull request #191 from opensrp/issue189-2

Migrate core dependencies

Run Details

5141 of 6670 relevant lines covered (77.08%)

0.77 hits per line

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

86.81

opensrp-immunization/src/main/java/org/smartregister/immunization/ImmunizationLibrary.java

package org.smartregister.immunization;

import androidx.annotation.NonNull;

import org.smartregister.Context;
import org.smartregister.commonregistry.CommonFtsObject;
import org.smartregister.immunization.db.VaccineRepo;
import org.smartregister.immunization.repository.RecurringServiceRecordRepository;
import org.smartregister.immunization.repository.RecurringServiceTypeRepository;
import org.smartregister.immunization.repository.VaccineNameRepository;
import org.smartregister.immunization.repository.VaccineOverdueCountRepository;
import org.smartregister.immunization.repository.VaccineRepository;
import org.smartregister.immunization.repository.VaccineTypeRepository;
import org.smartregister.immunization.util.IMConstants;
import org.smartregister.immunization.util.Utils;
import org.smartregister.immunization.util.VaccineCache;
import org.smartregister.repository.EventClientRepository;
import org.smartregister.repository.Repository;
import org.smartregister.util.AppProperties;
import org.smartregister.util.AssetHandler;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Created by keyman on 31/07/17.
 */
public class ImmunizationLibrary {

    public static List<String> COMBINED_VACCINES = new ArrayList<>();
    public static Map<String, String> COMBINED_VACCINES_MAP = new HashMap<>();
    private static ImmunizationLibrary instance;
    private static boolean allowExpiredVaccineEntry;
    private static Map<String, VaccineCache> vaccineCacheMap = new HashMap<>();
    private final Repository repository;
    private final Context context;
    private final Map<String, String> conditionalVaccinesMap = new HashMap<>();
    private EventClientRepository eventClientRepository;
    private VaccineRepository vaccineRepository;
    private RecurringServiceRecordRepository recurringServiceRecordRepository;
    private RecurringServiceTypeRepository recurringServiceTypeRepository;
    private VaccineTypeRepository vaccineTypeRepository;
    private VaccineNameRepository vaccineNameRepository;
    private CommonFtsObject commonFtsObject;
    private int applicationVersion;
    private int databaseVersion;
    private String applicationVersionName;
    private Map<String, Object> jsonMap = new HashMap<>();
    private String currentConditionalVaccine;
    private boolean allowSyncImmediately = false;
    private List<VaccineRepo.Vaccine> skippableVaccines = new ArrayList<>();
    private VaccineOverdueCountRepository vaccineOverdueCountRepository;

    private long vaccineSyncTime = -1;

    private ImmunizationLibrary(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion) {
        this.repository = repository;
        this.context = context;
        this.commonFtsObject = commonFtsObject;
        this.applicationVersion = applicationVersion;
        this.applicationVersionName = applicationVersionName;
        this.databaseVersion = databaseVersion;
        setCurrentConditionalVaccine(null);
        setSkippableVaccines(Arrays.asList(VaccineRepo.Vaccine.bcg2, VaccineRepo.Vaccine.measles1));
    }

    public static void init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion) {
        if (instance == null) {
            instance = new ImmunizationLibrary(context, repository, commonFtsObject, applicationVersion, applicationVersionName, databaseVersion);

            allowExpiredVaccineEntry = instance.getProperties().isTrue(IMConstants.APP_PROPERTIES.VACCINE_EXPIRED_ENTRY_ALLOW);

            Utils.processVaccineCache(context.applicationContext(), IMConstants.VACCINE_TYPE.CHILD);
            Utils.processVaccineCache(context.applicationContext(), IMConstants.VACCINE_TYPE.WOMAN);

            //Auto populated vaccines

            Utils.processVaccineCache(context.applicationContext());

        }
    }

    /**
     * This init method is deprecated, use {@link #init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion.
     */
    @Deprecated
    public static void init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, int databaseVersion) {
        init(context, repository, commonFtsObject, applicationVersion, null, databaseVersion);
    }

    public static <T> T assetJsonToJava(Map<String, Object> jsonMap, android.content.Context context, String fileName, Class<T> clazz, Type type) {
        return AssetHandler.assetJsonToJava(jsonMap, context, fileName, clazz, type);
    }

    public static ImmunizationLibrary getInstance() {
        if (instance == null) {
            throw new IllegalStateException(" Instance does not exist!!! Call " + ImmunizationLibrary.class
                    .getName() + ".init method in the onCreate method of your Application class ");
        }
        return instance;
    }

    public static Map<String, VaccineCache> getVaccineCacheMap() {
        return vaccineCacheMap;
    }

    /**
     * Public method to clear the instance/destroy useful for testing
     */
    public static void destroy() {
        instance = null;
    }

    public Map<String, String> getConditionalVaccinesMap() {
        return conditionalVaccinesMap;
    }

    public <T> T assetJsonToJava(String fileName, Class<T> clazz, Type type) {
        return AssetHandler.assetJsonToJava(jsonMap, context.applicationContext(), fileName, clazz, type);
    }

    public EventClientRepository eventClientRepository() {
        if (eventClientRepository == null) {
            eventClientRepository = new EventClientRepository();
        }

        return eventClientRepository;
    }

    public Repository getRepository() {
        return repository;
    }

    public VaccineRepository vaccineRepository() {
        if (vaccineRepository == null) {
            vaccineRepository = new VaccineRepository(commonFtsObject(), context.alertService());
        }
        return vaccineRepository;
    }

    private CommonFtsObject commonFtsObject() {
        return commonFtsObject;
    }

    public RecurringServiceTypeRepository recurringServiceTypeRepository() {
        if (recurringServiceTypeRepository == null) {
            recurringServiceTypeRepository = new RecurringServiceTypeRepository();
        }
        return recurringServiceTypeRepository;
    }

    public RecurringServiceRecordRepository recurringServiceRecordRepository() {
        if (recurringServiceRecordRepository == null) {
            recurringServiceRecordRepository = new RecurringServiceRecordRepository();
        }
        return recurringServiceRecordRepository;
    }

    public VaccineTypeRepository vaccineTypeRepository() {
        if (vaccineTypeRepository == null) {
            vaccineTypeRepository = new VaccineTypeRepository(commonFtsObject(), context().alertService());
        }
        return vaccineTypeRepository;
    }

    public Context context() {
        return context;
    }

    public VaccineNameRepository vaccineNameRepository() {
        if (vaccineNameRepository == null) {
            vaccineNameRepository = new VaccineNameRepository(commonFtsObject(), context().alertService());
        }
        return vaccineNameRepository;
    }

    public VaccineOverdueCountRepository getVaccineOverdueCountRepository() {
        if (vaccineOverdueCountRepository == null) {
            vaccineOverdueCountRepository = new VaccineOverdueCountRepository();
        }
        return vaccineOverdueCountRepository;
    }

    public int getApplicationVersion() {
        return applicationVersion;
    }

    public String getApplicationVersionName() {
        return applicationVersionName;
    }

    public int getDatabaseVersion() {
        return databaseVersion;
    }

    public Locale getLocale() {
        return ImmunizationLibrary.getInstance().context().applicationContext().getResources().getConfiguration().locale;
    }

    public Map<String, Object> getVaccinesConfigJsonMap() {
        return jsonMap;
    }

    public AppProperties getProperties() {
        return ImmunizationLibrary.getInstance().context().getAppProperties();
    }

    /**
     * @param vaccines the vaccines repo enum values
     * @param category the category the vaccines are for e.g. CHILD, WOMAN
     */
    public void setVaccines(VaccineRepo.Vaccine[] vaccines, String category) {
        vaccineCacheMap.get(category).vaccines = vaccines;
    }

    /**
     * @param category the category of the vaccines to be retrieved
     *                 returns an array of the vaccines from the specified category
     */
    public VaccineRepo.Vaccine[]
    getVaccines(String category) {
        return vaccineCacheMap.get(category).vaccines;
    }

    public boolean isAllowExpiredVaccineEntry() {
        return allowExpiredVaccineEntry;
    }

    public boolean isExpiredVaccineCardRed() {
        return getProperties().isTrue(IMConstants.APP_PROPERTIES.EXPIRED_CARD_AS_RED);
    }

    public boolean hideOverdueVaccineStatus() {
        return getProperties().hasProperty(IMConstants.APP_PROPERTIES.HIDE_OVERDUE_VACCINE_STATUS) && instance.getProperties().getPropertyBoolean(IMConstants.APP_PROPERTIES.HIDE_OVERDUE_VACCINE_STATUS);
    }

    public long getVaccineSyncTime() {
        if (vaccineSyncTime == -1) {
            setVaccineSyncTime(BuildConfig.VACCINE_SYNC_TIME);
        }

        return vaccineSyncTime;
    }

    public void setVaccineSyncTime(int vaccineSyncTime) {
        setVaccineSyncTime(vaccineSyncTime, TimeUnit.HOURS);
    }

    public void setVaccineSyncTime(int vaccineSyncTime, @NonNull TimeUnit timeUnit) {
        this.vaccineSyncTime = timeUnit.toMinutes(vaccineSyncTime);
    }

    public String getCurrentConditionalVaccine() {
        return currentConditionalVaccine;
    }

    public void setCurrentConditionalVaccine(String currentConditionalVaccine) {
        this.currentConditionalVaccine = currentConditionalVaccine;
    }

    public boolean allowSyncImmediately() {
        if (instance.getProperties().hasProperty(IMConstants.APP_PROPERTIES.VACCINE_SYNC_IMMEDIATE))
            allowSyncImmediately = instance.getProperties().getPropertyBoolean(IMConstants.APP_PROPERTIES.VACCINE_SYNC_IMMEDIATE);

        return allowSyncImmediately;
    }

    @Deprecated
    public void setAllowSyncImmediately(boolean allowSyncImmediately) {
        this.allowSyncImmediately = allowSyncImmediately;
    }

    public List<VaccineRepo.Vaccine> getSkippableVaccines() {
        return skippableVaccines;
    }

    /**
     * Set the Vaccines to skip from normal processing e.g. bcg2
     *
     * @param skippableVaccines vaccines to skip
     */
    public void setSkippableVaccines(List<VaccineRepo.Vaccine> skippableVaccines) {
        this.skippableVaccines = skippableVaccines;
    }
}

1	package org.smartregister.immunization;
2
3	import androidx.annotation.NonNull;
4
5	import org.smartregister.Context;
6	import org.smartregister.commonregistry.CommonFtsObject;
7	import org.smartregister.immunization.db.VaccineRepo;
8	import org.smartregister.immunization.repository.RecurringServiceRecordRepository;
9	import org.smartregister.immunization.repository.RecurringServiceTypeRepository;
10	import org.smartregister.immunization.repository.VaccineNameRepository;
11	import org.smartregister.immunization.repository.VaccineOverdueCountRepository;
12	import org.smartregister.immunization.repository.VaccineRepository;
13	import org.smartregister.immunization.repository.VaccineTypeRepository;
14	import org.smartregister.immunization.util.IMConstants;
15	import org.smartregister.immunization.util.Utils;
16	import org.smartregister.immunization.util.VaccineCache;
17	import org.smartregister.repository.EventClientRepository;
18	import org.smartregister.repository.Repository;
19	import org.smartregister.util.AppProperties;
20	import org.smartregister.util.AssetHandler;
21
22	import java.lang.reflect.Type;
23	import java.util.ArrayList;
24	import java.util.Arrays;
25	import java.util.HashMap;
26	import java.util.List;
27	import java.util.Locale;
28	import java.util.Map;
29	import java.util.concurrent.TimeUnit;
30
31	/**
32	* Created by keyman on 31/07/17.
33	*/
34	public class ImmunizationLibrary {
35
36	public static List<String> COMBINED_VACCINES = new ArrayList<>();	1✔
37	public static Map<String, String> COMBINED_VACCINES_MAP = new HashMap<>();	1✔
38	private static ImmunizationLibrary instance;
39	private static boolean allowExpiredVaccineEntry;
40	private static Map<String, VaccineCache> vaccineCacheMap = new HashMap<>();	1✔
41	private final Repository repository;
42	private final Context context;
43	private final Map<String, String> conditionalVaccinesMap = new HashMap<>();	1✔
44	private EventClientRepository eventClientRepository;
45	private VaccineRepository vaccineRepository;
46	private RecurringServiceRecordRepository recurringServiceRecordRepository;
47	private RecurringServiceTypeRepository recurringServiceTypeRepository;
48	private VaccineTypeRepository vaccineTypeRepository;
49	private VaccineNameRepository vaccineNameRepository;
50	private CommonFtsObject commonFtsObject;
51	private int applicationVersion;
52	private int databaseVersion;
53	private String applicationVersionName;
54	private Map<String, Object> jsonMap = new HashMap<>();	1✔
55	private String currentConditionalVaccine;
56	private boolean allowSyncImmediately = false;	1✔
57	private List<VaccineRepo.Vaccine> skippableVaccines = new ArrayList<>();	1✔
58	private VaccineOverdueCountRepository vaccineOverdueCountRepository;
59
60	private long vaccineSyncTime = -1;	1✔
61
62	private ImmunizationLibrary(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion) {	1✔
63	this.repository = repository;	1✔
64	this.context = context;	1✔
65	this.commonFtsObject = commonFtsObject;	1✔
66	this.applicationVersion = applicationVersion;	1✔
67	this.applicationVersionName = applicationVersionName;	1✔
68	this.databaseVersion = databaseVersion;	1✔
69	setCurrentConditionalVaccine(null);	1✔
70	setSkippableVaccines(Arrays.asList(VaccineRepo.Vaccine.bcg2, VaccineRepo.Vaccine.measles1));	1✔
71	}	1✔
72
73	public static void init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion) {
74	if (instance == null) {	1✔
75	instance = new ImmunizationLibrary(context, repository, commonFtsObject, applicationVersion, applicationVersionName, databaseVersion);	1✔
76
77	allowExpiredVaccineEntry = instance.getProperties().isTrue(IMConstants.APP_PROPERTIES.VACCINE_EXPIRED_ENTRY_ALLOW);	1✔
78
79	Utils.processVaccineCache(context.applicationContext(), IMConstants.VACCINE_TYPE.CHILD);	1✔
80	Utils.processVaccineCache(context.applicationContext(), IMConstants.VACCINE_TYPE.WOMAN);	1✔
81
82	//Auto populated vaccines
83
84	Utils.processVaccineCache(context.applicationContext());	1✔
85
86	}
87	}	1✔
88
89	/**
90	* This init method is deprecated, use {@link #init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, String applicationVersionName, int databaseVersion.
91	*/
92	@Deprecated
93	public static void init(Context context, Repository repository, CommonFtsObject commonFtsObject, int applicationVersion, int databaseVersion) {
94	init(context, repository, commonFtsObject, applicationVersion, null, databaseVersion);	1✔
95	}	1✔
96
97	public static <T> T assetJsonToJava(Map<String, Object> jsonMap, android.content.Context context, String fileName, Class<T> clazz, Type type) {
98	return AssetHandler.assetJsonToJava(jsonMap, context, fileName, clazz, type);	1✔
99	}
100
101	public static ImmunizationLibrary getInstance() {
102	if (instance == null) {	1✔
103	throw new IllegalStateException(" Instance does not exist!!! Call " + ImmunizationLibrary.class	1✔
104	.getName() + ".init method in the onCreate method of your Application class ");	1✔
105	}
106	return instance;	1✔
107	}
108
109	public static Map<String, VaccineCache> getVaccineCacheMap() {
110	return vaccineCacheMap;	1✔
111	}
112
113	/**
114	* Public method to clear the instance/destroy useful for testing
115	*/
116	public static void destroy() {
117	instance = null;	1✔
118	}	1✔
119
120	public Map<String, String> getConditionalVaccinesMap() {
121	return conditionalVaccinesMap;	1✔
122	}
123
124	public <T> T assetJsonToJava(String fileName, Class<T> clazz, Type type) {
125	return AssetHandler.assetJsonToJava(jsonMap, context.applicationContext(), fileName, clazz, type);	×
126	}
127
128	public EventClientRepository eventClientRepository() {
129	if (eventClientRepository == null) {	1✔
130	eventClientRepository = new EventClientRepository();	1✔
131	}
132
133	return eventClientRepository;	1✔
134	}
135
136	public Repository getRepository() {
137	return repository;	1✔
138	}
139
140	public VaccineRepository vaccineRepository() {
141	if (vaccineRepository == null) {	1✔
142	vaccineRepository = new VaccineRepository(commonFtsObject(), context.alertService());	1✔
143	}
144	return vaccineRepository;	1✔
145	}
146
147	private CommonFtsObject commonFtsObject() {
148	return commonFtsObject;	1✔
149	}
150
151	public RecurringServiceTypeRepository recurringServiceTypeRepository() {
152	if (recurringServiceTypeRepository == null) {	1✔
153	recurringServiceTypeRepository = new RecurringServiceTypeRepository();	1✔
154	}
155	return recurringServiceTypeRepository;	1✔
156	}
157
158	public RecurringServiceRecordRepository recurringServiceRecordRepository() {
159	if (recurringServiceRecordRepository == null) {	1✔
160	recurringServiceRecordRepository = new RecurringServiceRecordRepository();	1✔
161	}
162	return recurringServiceRecordRepository;	1✔
163	}
164
165	public VaccineTypeRepository vaccineTypeRepository() {
166	if (vaccineTypeRepository == null) {	1✔
167	vaccineTypeRepository = new VaccineTypeRepository(commonFtsObject(), context().alertService());	1✔
168	}
169	return vaccineTypeRepository;	1✔
170	}
171
172	public Context context() {
173	return context;	1✔
174	}
175
176	public VaccineNameRepository vaccineNameRepository() {
177	if (vaccineNameRepository == null) {	1✔
178	vaccineNameRepository = new VaccineNameRepository(commonFtsObject(), context().alertService());	1✔
179	}
180	return vaccineNameRepository;	1✔
181	}
182
183	public VaccineOverdueCountRepository getVaccineOverdueCountRepository() {
184	if (vaccineOverdueCountRepository == null) {	1✔
185	vaccineOverdueCountRepository = new VaccineOverdueCountRepository();	1✔
186	}
187	return vaccineOverdueCountRepository;	1✔
188	}
189
190	public int getApplicationVersion() {
191	return applicationVersion;	1✔
192	}
193
194	public String getApplicationVersionName() {
195	return applicationVersionName;	1✔
196	}
197
198	public int getDatabaseVersion() {
199	return databaseVersion;	1✔
200	}
201
202	public Locale getLocale() {
203	return ImmunizationLibrary.getInstance().context().applicationContext().getResources().getConfiguration().locale;	×
204	}
205
206	public Map<String, Object> getVaccinesConfigJsonMap() {
207	return jsonMap;	1✔
208	}
209
210	public AppProperties getProperties() {
211	return ImmunizationLibrary.getInstance().context().getAppProperties();	1✔
212	}
213
214	/**
215	* @param vaccines the vaccines repo enum values
216	* @param category the category the vaccines are for e.g. CHILD, WOMAN
217	*/
218	public void setVaccines(VaccineRepo.Vaccine[] vaccines, String category) {
219	vaccineCacheMap.get(category).vaccines = vaccines;	×
220	}	×
221
222	/**
223	* @param category the category of the vaccines to be retrieved
224	* returns an array of the vaccines from the specified category
225	*/
226	public VaccineRepo.Vaccine[]
227	getVaccines(String category) {
228	return vaccineCacheMap.get(category).vaccines;	×
229	}
230
231	public boolean isAllowExpiredVaccineEntry() {
232	return allowExpiredVaccineEntry;	1✔
233	}
234
235	public boolean isExpiredVaccineCardRed() {
236	return getProperties().isTrue(IMConstants.APP_PROPERTIES.EXPIRED_CARD_AS_RED);	1✔
237	}
238
239	public boolean hideOverdueVaccineStatus() {
240	return getProperties().hasProperty(IMConstants.APP_PROPERTIES.HIDE_OVERDUE_VACCINE_STATUS) && instance.getProperties().getPropertyBoolean(IMConstants.APP_PROPERTIES.HIDE_OVERDUE_VACCINE_STATUS);	1✔
241	}
242
243	public long getVaccineSyncTime() {
244	if (vaccineSyncTime == -1) {	1✔
245	setVaccineSyncTime(BuildConfig.VACCINE_SYNC_TIME);	1✔
246	}
247
248	return vaccineSyncTime;	1✔
249	}
250
251	public void setVaccineSyncTime(int vaccineSyncTime) {
252	setVaccineSyncTime(vaccineSyncTime, TimeUnit.HOURS);	1✔
253	}	1✔
254
255	public void setVaccineSyncTime(int vaccineSyncTime, @NonNull TimeUnit timeUnit) {
256	this.vaccineSyncTime = timeUnit.toMinutes(vaccineSyncTime);	1✔
257	}	1✔
258
259	public String getCurrentConditionalVaccine() {
260	return currentConditionalVaccine;	×
261	}
262
263	public void setCurrentConditionalVaccine(String currentConditionalVaccine) {
264	this.currentConditionalVaccine = currentConditionalVaccine;	1✔
265	}	1✔
266
267	public boolean allowSyncImmediately() {
268	if (instance.getProperties().hasProperty(IMConstants.APP_PROPERTIES.VACCINE_SYNC_IMMEDIATE))	×
269	allowSyncImmediately = instance.getProperties().getPropertyBoolean(IMConstants.APP_PROPERTIES.VACCINE_SYNC_IMMEDIATE);	×
270
271	return allowSyncImmediately;	×
272	}
273
274	@Deprecated
275	public void setAllowSyncImmediately(boolean allowSyncImmediately) {
276	this.allowSyncImmediately = allowSyncImmediately;	×
277	}	×
278
279	public List<VaccineRepo.Vaccine> getSkippableVaccines() {
280	return skippableVaccines;	×
281	}
282
283	/**
284	* Set the Vaccines to skip from normal processing e.g. bcg2
285	*
286	* @param skippableVaccines vaccines to skip
287	*/
288	public void setSkippableVaccines(List<VaccineRepo.Vaccine> skippableVaccines) {
289	this.skippableVaccines = skippableVaccines;	1✔
290	}	1✔
291	}

OpenSRP / opensrp-client-immunization / #901

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