#902

pending completion

Build # #902

Build Type

Pull #194

github-actions

Committed by

web-flow

Commit Message

Merge 81d659c36 into ce201bbb0

Pull Request Pull Request #194: Remove async task

Run Details

5222 of 6751 relevant lines covered (77.35%)

0.77 hits per line

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

75.86

opensrp-immunization/src/main/java/org/smartregister/immunization/adapter/VaccineCardAdapter.java

package org.smartregister.immunization.adapter;

import static org.smartregister.immunization.util.VaccinatorUtils.generateScheduleList;
import static org.smartregister.util.Utils.getName;
import static org.smartregister.util.Utils.getValue;

import android.content.Context;
import android.os.AsyncTask;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.smartregister.commonregistry.CommonPersonObjectClient;
import org.smartregister.domain.Alert;
import org.smartregister.domain.Photo;
import org.smartregister.immunization.db.VaccineRepo;
import org.smartregister.immunization.domain.State;
import org.smartregister.immunization.domain.Vaccine;
import org.smartregister.immunization.domain.VaccineWrapper;
import org.smartregister.immunization.listener.VaccineCardAdapterLoadingListener;
import org.smartregister.immunization.repository.VaccineRepository;
import org.smartregister.immunization.util.CallableInteractorCallBack;
import org.smartregister.immunization.util.GenericInteractor;
import org.smartregister.immunization.util.ImageUtils;
import org.smartregister.immunization.util.VaccinatorUtils;
import org.smartregister.immunization.view.VaccineCard;
import org.smartregister.immunization.view.VaccineGroup;
import org.smartregister.util.Utils;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import timber.log.Timber;

import timber.log.Timber;

/**
 * Created by Jason Rogena - jrogena@ona.io on 22/02/2017.
 */
public class VaccineCardAdapter extends BaseAdapter {
    private static final String TAG = "VaccineCardAdapter";
    private final Context context;
    private final VaccineGroup vaccineGroup;
    private final String type;
    private HashMap<String, VaccineCard> vaccineCards;
    private List<Vaccine> vaccineList;
    private List<Alert> alertList;

    private boolean isChildActive = true;
    private int remainingAsyncTasks;
    private VaccineCardAdapterLoadingListener vaccineCardAdapterLoadingListener;

    public VaccineCardAdapter(Context context, VaccineGroup vaccineGroup, String type,
                              List<Vaccine> vaccineList, List<Alert> alertList) {
        this.context = context;
        this.vaccineGroup = vaccineGroup;
        this.vaccineList = vaccineList;
        this.alertList = alertList;
        vaccineCards = new HashMap<>();
        this.type = type;
        remainingAsyncTasks = vaccineGroup.getVaccineData().vaccines.size();
    }

    @Override
    public int getCount() {
        return vaccineGroup.getVaccineData().vaccines.size();
    }

    @Override
    public Object getItem(int position) {
        return vaccineCards.get(position);
    }

    @Override
    public long getItemId(int position) {
        return 231231 + position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        try {
            org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData
                    = vaccineGroup.getVaccineData().vaccines.get(position);
            String vaccineName = vaccineData.name;
            if (!vaccineCards.containsKey(vaccineName)) {
                VaccineCard vaccineCard = new VaccineCard(context);
                vaccineCard.setChildActive(isChildActive);
                vaccineCard.setId((int) getItemId(position));
                vaccineCards.put(vaccineName, vaccineCard);

                VaccineWrapperCallableTask vaccineWrapperCallableTask =
                        new VaccineWrapperCallableTask(vaccineCard,
                                vaccineData,
                                vaccineGroup.getChildDetails(),
                                vaccineGroup.getVaccineData().days_after_birth_due,
                                position);

                VaccineRowTaskCallableInteractorCallback vaccineRowTaskCallableInteractorCallback =
                        new VaccineRowTaskCallableInteractorCallback(vaccineCard, position);

                GenericInteractor interactor = getGenericInteractor();

                interactor.execute(vaccineWrapperCallableTask, vaccineRowTaskCallableInteractorCallback);

            }

            return vaccineCards.get(vaccineName);
        } catch (Exception e) {
            Timber.e(e);
            return null;
        }
    }

    public void update(ArrayList<VaccineWrapper> vaccinesToUpdate) {
        if (vaccineCards != null) {
            if (vaccinesToUpdate == null) {// Update all vaccines
                for (VaccineCard curCard : vaccineCards.values()) {
                    if (curCard != null) curCard.updateState();
                }
            } else {// Update just the vaccines specified
                for (VaccineWrapper currWrapper : vaccinesToUpdate) {
                    if (vaccineCards.containsKey(currWrapper.getName())) {
                        vaccineCards.get(currWrapper.getName()).setVaccineWrapper(currWrapper);
                    }
                }
            }
        }
    }

    public void setChildActive(boolean childActive) {
        isChildActive = childActive;
    }

    public void updateChildsActiveStatus() {
        if (vaccineCards != null) {
            for (VaccineCard curCard : vaccineCards.values()) {
                curCard.setChildActive(isChildActive);
                curCard.updateChildsActiveStatus();
            }
        }
    }

    public ArrayList<VaccineWrapper> getDueVaccines() {
        ArrayList<VaccineWrapper> dueVaccines = new ArrayList<>();
        if (vaccineCards != null) {
            for (VaccineCard curCard : vaccineCards.values()) {
                if (curCard != null && (curCard.getState().equals(State.DUE)
                        || curCard.getState().equals(State.OVERDUE))) {
                    dueVaccines.add(curCard.getVaccineWrapper());
                }
            }
        }

        return dueVaccines;
    }

    public ArrayList<VaccineWrapper> getAllVaccineWrappers() {
        ArrayList<VaccineWrapper> allWrappers = new ArrayList<>();
        for (VaccineCard curCard : vaccineCards.values()) {
            allWrappers.add(curCard.getVaccineWrapper());
        }

        return allWrappers;
    }

    public void updateWrapperStatus(ArrayList<VaccineWrapper> tags, String type, CommonPersonObjectClient childDetails) {
        if (tags == null) {
            return;
        }

        for (VaccineWrapper tag : tags) {
            updateWrapperStatus(tag, type, childDetails);
        }
    }

    public void updateWrapperStatus(VaccineWrapper tag, String type, CommonPersonObjectClient childDetails) {
        List<Vaccine> vaccineList = getVaccineList();

        List<Alert> alertList = getAlertList();

        Map<String, Date> receivedVaccines = VaccinatorUtils.receivedVaccines(vaccineList);

        String dobString = getValue(childDetails.getColumnmaps(), "dob", false);
        List<Map<String, Object>> sch = generateScheduleList(type, new DateTime(dobString), receivedVaccines, alertList);


        for (Map<String, Object> m : sch) {
            VaccineRepo.Vaccine vaccine = (VaccineRepo.Vaccine) m.get("vaccine");
            if (tag.getName().toLowerCase().contains(vaccine.display().toLowerCase())) {

                //Add exceptions
                if (VaccinatorUtils.isSkippableVaccine(tag.getName()) && !tag.getName().equalsIgnoreCase(vaccine.display())) {
                    continue;
                }

                if ((vaccine.equals(VaccineRepo.Vaccine.measles2)
                        || vaccine.equals(VaccineRepo.Vaccine.mr2)
                        || vaccine.equals(VaccineRepo.Vaccine.measles1)
                        || vaccine.equals(VaccineRepo.Vaccine.mr1) && tag.getAlert() != null) && tag.getStatus() != null) {
                    break;
                }
                tag.setStatus(m.get("status").toString());
                tag.setAlert((Alert) m.get("alert"));

                updateVaccineDate(m, vaccine, tag, receivedVaccines);
            }
        }
    }

    protected void updateVaccineDate(Map<String, Object> m, VaccineRepo.Vaccine vaccine, VaccineWrapper tag, Map<String, Date> receivedVaccines) {
        if (m.get("status") != null
                && ((String) m.get("status")).equalsIgnoreCase("due")
                && vaccine.prerequisite() != null) {
            Date preReq = receivedVaccines.get(vaccine.prerequisite().display().toLowerCase(Locale.ENGLISH));
            if (preReq != null) {
                DateTime preReqDateTime = new DateTime(preReq);
                DateTime vaccineDate = preReqDateTime.plusDays(vaccine.prerequisiteGapDays());
                tag.setVaccineDate(vaccineDate);
            }
        }
    }

    public List<Vaccine> getVaccineList() {
        return vaccineList;
    }

    public List<Alert> getAlertList() {
        return alertList;
    }

    public void updateWrapper(VaccineWrapper tag) {
        List<Vaccine> vaccineList = getVaccineList();

        if (!vaccineList.isEmpty()) {
            for (Vaccine vaccine : vaccineList) {
                if (tag.getName().toLowerCase().contains(vaccine.getName().toLowerCase()) && vaccine.getDate() != null) {

                    //Add exceptions
                    if (VaccinatorUtils.isSkippableVaccine(tag.getName()) && !tag.getName().equalsIgnoreCase(vaccine.getName())) {
                        continue;
                    }

                    long diff = vaccine.getUpdatedAt() - vaccine.getDate().getTime();
                    tag.setUpdatedVaccineDate(new DateTime(vaccine.getDate()), diff <= 0 || TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS) <= 1);
                    tag.setDbKey(vaccine.getId());
                    tag.setSynced(vaccine.getSyncStatus() != null && vaccine.getSyncStatus().equals(VaccineRepository.TYPE_Synced));
                    tag.setOutOfCatchment("1".equals(vaccine.getOutOfCatchment()));
                    if (tag.getName().contains("/")) {
                        String[] array = tag.getName().split("/");

                        if ((array[0]).toLowerCase().contains(vaccine.getName().toLowerCase())) {
                            tag.setName(array[0]);
                        } else if ((array[1]).toLowerCase().contains(vaccine.getName().toLowerCase())) {

                            tag.setName(array[1]);
                        }
                    }
                }
            }
        }

    }

    private void notifyAsyncTaskCompleted() {
        remainingAsyncTasks--;
        checkRemainingAsyncTasksStatus();
    }

    private void checkRemainingAsyncTasksStatus() {
        if (remainingAsyncTasks == 0 && vaccineCardAdapterLoadingListener != null) {
            vaccineCardAdapterLoadingListener.onFinishedLoadingVaccineWrappers();
        }
    }

    public VaccineCardAdapterLoadingListener getVaccineCardAdapterLoadingListener() {
        return vaccineCardAdapterLoadingListener;
    }

    public void setVaccineCardAdapterLoadingListener(VaccineCardAdapterLoadingListener vaccineCardAdapterLoadingListener) {
        this.vaccineCardAdapterLoadingListener = vaccineCardAdapterLoadingListener;

        checkRemainingAsyncTasksStatus();
    }

    public GenericInteractor getGenericInteractor() {
        return new GenericInteractor();
    }

    private class VaccineWrapperCallableTask implements Callable<VaccineWrapper> {
        private VaccineCard vaccineCard;

        private String vaccineName;

        private CommonPersonObjectClient childDetails;

        private int days_after_birth_due;
        private int position;

        private org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData;
         VaccineWrapperCallableTask (VaccineCard vaccineCard, org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData,
                CommonPersonObjectClient childDetails, Integer days_after_birth_due, int position){
             this.vaccineCard = vaccineCard;
             vaccineName = vaccineData.name;
             this.childDetails = childDetails;
             this.days_after_birth_due = days_after_birth_due;
             this.position = position;
             this.vaccineData = vaccineData;
         }


        @Override
        public VaccineWrapper call() throws Exception {
            VaccineWrapper vaccineWrapper = new VaccineWrapper();
            vaccineWrapper.setId(childDetails.entityId());
            vaccineWrapper.setGender(childDetails.getDetails().get("gender"));
            vaccineWrapper.setName(vaccineData.name);
            vaccineWrapper.setDefaultName(vaccineData.name);
            if (vaccineData.schedule != null && vaccineData.schedule.conditions != null) {
                vaccineWrapper.setNotGivenCondition(vaccineData.schedule.conditions.get(0).vaccine);
            }

            String dobString = getValue(childDetails.getColumnmaps(), "dob", false);
            if (StringUtils.isNotBlank(dobString)) {
                Calendar dobCalender = Calendar.getInstance();
                DateTime dateTime = new DateTime(dobString);
                dobCalender.setTime(dateTime.toDate());
                dobCalender.add(Calendar.DATE, days_after_birth_due);
                vaccineWrapper.setVaccineDate(new DateTime(dobCalender.getTime()));
            }

            Photo photo = ImageUtils.profilePhotoByClient(childDetails);
            vaccineWrapper.setPhoto(photo);

            String zeirId = getValue(childDetails.getColumnmaps(), "zeir_id", false);
            vaccineWrapper.setPatientNumber(zeirId);

            String firstName = getValue(childDetails.getColumnmaps(), "first_name", true);
            String lastName = getValue(childDetails.getColumnmaps(), "last_name", true);
            String childName = getName(firstName, lastName);
            vaccineWrapper.setPatientName(childName.trim());

            updateWrapper(vaccineWrapper);
            updateWrapperStatus(vaccineWrapper, type, childDetails);
            return vaccineWrapper;
        }

    }

    public class VaccineRowTaskCallableInteractorCallback implements CallableInteractorCallBack<VaccineWrapper>{
        private VaccineCard vaccineCard;
        private int position;
        VaccineRowTaskCallableInteractorCallback(VaccineCard vaccineCard, int position){
            this.vaccineCard  = vaccineCard;
            this.position = position;
        }
        @Override
        public void onResult(VaccineWrapper vaccineWrapper) {
            this.vaccineCard.setVaccineWrapper(vaccineWrapper);

            //If last position, toggle RecordAll
            if (position == (getCount() - 1)) {
                vaccineGroup.toggleRecordAllTV();
            }
            notifyDataSetChanged();
            notifyAsyncTaskCompleted();
        }

        @Override
        public void onError(Exception ex) {
            Timber.e(ex);
        }
    }


}

1	package org.smartregister.immunization.adapter;
2
3	import static org.smartregister.immunization.util.VaccinatorUtils.generateScheduleList;
4	import static org.smartregister.util.Utils.getName;
5	import static org.smartregister.util.Utils.getValue;
6
7	import android.content.Context;
8	import android.os.AsyncTask;
9	import android.view.View;
10	import android.view.ViewGroup;
11	import android.widget.BaseAdapter;
12
13	import org.apache.commons.lang3.StringUtils;
14	import org.joda.time.DateTime;
15	import org.smartregister.commonregistry.CommonPersonObjectClient;
16	import org.smartregister.domain.Alert;
17	import org.smartregister.domain.Photo;
18	import org.smartregister.immunization.db.VaccineRepo;
19	import org.smartregister.immunization.domain.State;
20	import org.smartregister.immunization.domain.Vaccine;
21	import org.smartregister.immunization.domain.VaccineWrapper;
22	import org.smartregister.immunization.listener.VaccineCardAdapterLoadingListener;
23	import org.smartregister.immunization.repository.VaccineRepository;
24	import org.smartregister.immunization.util.CallableInteractorCallBack;
25	import org.smartregister.immunization.util.GenericInteractor;
26	import org.smartregister.immunization.util.ImageUtils;
27	import org.smartregister.immunization.util.VaccinatorUtils;
28	import org.smartregister.immunization.view.VaccineCard;
29	import org.smartregister.immunization.view.VaccineGroup;
30	import org.smartregister.util.Utils;
31
32	import java.util.ArrayList;
33	import java.util.Calendar;
34	import java.util.Date;
35	import java.util.HashMap;
36	import java.util.List;
37	import java.util.Locale;
38	import java.util.Map;
39	import java.util.concurrent.Callable;
40	import java.util.concurrent.TimeUnit;
41
42	import timber.log.Timber;
43
44	import timber.log.Timber;
45
46	/**
47	* Created by Jason Rogena - jrogena@ona.io on 22/02/2017.
48	*/
49	public class VaccineCardAdapter extends BaseAdapter {
50	private static final String TAG = "VaccineCardAdapter";
51	private final Context context;
52	private final VaccineGroup vaccineGroup;
53	private final String type;
54	private HashMap<String, VaccineCard> vaccineCards;
55	private List<Vaccine> vaccineList;
56	private List<Alert> alertList;
57
58	private boolean isChildActive = true;	1✔
59	private int remainingAsyncTasks;
60	private VaccineCardAdapterLoadingListener vaccineCardAdapterLoadingListener;
61
62	public VaccineCardAdapter(Context context, VaccineGroup vaccineGroup, String type,
63	List<Vaccine> vaccineList, List<Alert> alertList) {	1✔
64	this.context = context;	1✔
65	this.vaccineGroup = vaccineGroup;	1✔
66	this.vaccineList = vaccineList;	1✔
67	this.alertList = alertList;	1✔
68	vaccineCards = new HashMap<>();	1✔
69	this.type = type;	1✔
70	remainingAsyncTasks = vaccineGroup.getVaccineData().vaccines.size();	1✔
71	}	1✔
72
73	@Override
74	public int getCount() {
75	return vaccineGroup.getVaccineData().vaccines.size();	1✔
76	}
77
78	@Override
79	public Object getItem(int position) {
80	return vaccineCards.get(position);	1✔
81	}
82
83	@Override
84	public long getItemId(int position) {
85	return 231231 + position;	1✔
86	}
87
88	@Override
89	public View getView(int position, View convertView, ViewGroup parent) {
90	try {
91	org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData	1✔
92	= vaccineGroup.getVaccineData().vaccines.get(position);	1✔
93	String vaccineName = vaccineData.name;	1✔
94	if (!vaccineCards.containsKey(vaccineName)) {	1✔
95	VaccineCard vaccineCard = new VaccineCard(context);	1✔
96	vaccineCard.setChildActive(isChildActive);	1✔
97	vaccineCard.setId((int) getItemId(position));	1✔
98	vaccineCards.put(vaccineName, vaccineCard);	1✔
99
100	VaccineWrapperCallableTask vaccineWrapperCallableTask =	1✔
101	new VaccineWrapperCallableTask(vaccineCard,
102	vaccineData,
103	vaccineGroup.getChildDetails(),	1✔
104	vaccineGroup.getVaccineData().days_after_birth_due,	1✔
105	position);
106
107	VaccineRowTaskCallableInteractorCallback vaccineRowTaskCallableInteractorCallback =	1✔
108	new VaccineRowTaskCallableInteractorCallback(vaccineCard, position);
109
110	GenericInteractor interactor = getGenericInteractor();	1✔
111
112	interactor.execute(vaccineWrapperCallableTask, vaccineRowTaskCallableInteractorCallback);	1✔
113
114	}
115
116	return vaccineCards.get(vaccineName);	1✔
117	} catch (Exception e) {	×
118	Timber.e(e);	×
119	return null;	×
120	}
121	}
122
123	public void update(ArrayList<VaccineWrapper> vaccinesToUpdate) {
124	if (vaccineCards != null) {	1✔
125	if (vaccinesToUpdate == null) {// Update all vaccines	1✔
126	for (VaccineCard curCard : vaccineCards.values()) {	×
127	if (curCard != null) curCard.updateState();	×
128	}	×
129	} else {// Update just the vaccines specified
130	for (VaccineWrapper currWrapper : vaccinesToUpdate) {	1✔
131	if (vaccineCards.containsKey(currWrapper.getName())) {	1✔
132	vaccineCards.get(currWrapper.getName()).setVaccineWrapper(currWrapper);	×
133	}
134	}	1✔
135	}
136	}
137	}	1✔
138
139	public void setChildActive(boolean childActive) {
140	isChildActive = childActive;	1✔
141	}	1✔
142
143	public void updateChildsActiveStatus() {
144	if (vaccineCards != null) {	1✔
145	for (VaccineCard curCard : vaccineCards.values()) {	×
146	curCard.setChildActive(isChildActive);	×
147	curCard.updateChildsActiveStatus();	×
148	}	×
149	}
150	}	1✔
151
152	public ArrayList<VaccineWrapper> getDueVaccines() {
153	ArrayList<VaccineWrapper> dueVaccines = new ArrayList<>();	1✔
154	if (vaccineCards != null) {	1✔
155	for (VaccineCard curCard : vaccineCards.values()) {	1✔
156	if (curCard != null && (curCard.getState().equals(State.DUE)	×
157	\|\| curCard.getState().equals(State.OVERDUE))) {	×
158	dueVaccines.add(curCard.getVaccineWrapper());	×
159	}
160	}	×
161	}
162
163	return dueVaccines;	1✔
164	}
165
166	public ArrayList<VaccineWrapper> getAllVaccineWrappers() {
167	ArrayList<VaccineWrapper> allWrappers = new ArrayList<>();	1✔
168	for (VaccineCard curCard : vaccineCards.values()) {	1✔
169	allWrappers.add(curCard.getVaccineWrapper());	×
170	}	×
171
172	return allWrappers;	1✔
173	}
174
175	public void updateWrapperStatus(ArrayList<VaccineWrapper> tags, String type, CommonPersonObjectClient childDetails) {
176	if (tags == null) {	1✔
177	return;	×
178	}
179
180	for (VaccineWrapper tag : tags) {	1✔
181	updateWrapperStatus(tag, type, childDetails);	1✔
182	}	1✔
183	}	1✔
184
185	public void updateWrapperStatus(VaccineWrapper tag, String type, CommonPersonObjectClient childDetails) {
186	List<Vaccine> vaccineList = getVaccineList();	1✔
187
188	List<Alert> alertList = getAlertList();	1✔
189
190	Map<String, Date> receivedVaccines = VaccinatorUtils.receivedVaccines(vaccineList);	1✔
191
192	String dobString = getValue(childDetails.getColumnmaps(), "dob", false);	1✔
193	List<Map<String, Object>> sch = generateScheduleList(type, new DateTime(dobString), receivedVaccines, alertList);	1✔
194
195
196	for (Map<String, Object> m : sch) {	1✔
197	VaccineRepo.Vaccine vaccine = (VaccineRepo.Vaccine) m.get("vaccine");	×
198	if (tag.getName().toLowerCase().contains(vaccine.display().toLowerCase())) {	×
199
200	//Add exceptions
201	if (VaccinatorUtils.isSkippableVaccine(tag.getName()) && !tag.getName().equalsIgnoreCase(vaccine.display())) {	×
202	continue;	×
203	}
204
205	if ((vaccine.equals(VaccineRepo.Vaccine.measles2)	×
206	\|\| vaccine.equals(VaccineRepo.Vaccine.mr2)	×
207	\|\| vaccine.equals(VaccineRepo.Vaccine.measles1)	×
208	\|\| vaccine.equals(VaccineRepo.Vaccine.mr1) && tag.getAlert() != null) && tag.getStatus() != null) {	×
209	break;	×
210	}
211	tag.setStatus(m.get("status").toString());	×
212	tag.setAlert((Alert) m.get("alert"));	×
213
214	updateVaccineDate(m, vaccine, tag, receivedVaccines);	×
215	}
216	}	×
217	}	1✔
218
219	protected void updateVaccineDate(Map<String, Object> m, VaccineRepo.Vaccine vaccine, VaccineWrapper tag, Map<String, Date> receivedVaccines) {
220	if (m.get("status") != null	1✔
221	&& ((String) m.get("status")).equalsIgnoreCase("due")	1✔
222	&& vaccine.prerequisite() != null) {	1✔
223	Date preReq = receivedVaccines.get(vaccine.prerequisite().display().toLowerCase(Locale.ENGLISH));	1✔
224	if (preReq != null) {	1✔
225	DateTime preReqDateTime = new DateTime(preReq);	1✔
226	DateTime vaccineDate = preReqDateTime.plusDays(vaccine.prerequisiteGapDays());	1✔
227	tag.setVaccineDate(vaccineDate);	1✔
228	}
229	}
230	}	1✔
231
232	public List<Vaccine> getVaccineList() {
233	return vaccineList;	1✔
234	}
235
236	public List<Alert> getAlertList() {
237	return alertList;	1✔
238	}
239
240	public void updateWrapper(VaccineWrapper tag) {
241	List<Vaccine> vaccineList = getVaccineList();	1✔
242
243	if (!vaccineList.isEmpty()) {	1✔
244	for (Vaccine vaccine : vaccineList) {	1✔
245	if (tag.getName().toLowerCase().contains(vaccine.getName().toLowerCase()) && vaccine.getDate() != null) {	1✔
246
247	//Add exceptions
248	if (VaccinatorUtils.isSkippableVaccine(tag.getName()) && !tag.getName().equalsIgnoreCase(vaccine.getName())) {	1✔
249	continue;	×
250	}
251
252	long diff = vaccine.getUpdatedAt() - vaccine.getDate().getTime();	1✔
253	tag.setUpdatedVaccineDate(new DateTime(vaccine.getDate()), diff <= 0 \|\| TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS) <= 1);	1✔
254	tag.setDbKey(vaccine.getId());	1✔
255	tag.setSynced(vaccine.getSyncStatus() != null && vaccine.getSyncStatus().equals(VaccineRepository.TYPE_Synced));	1✔
256	tag.setOutOfCatchment("1".equals(vaccine.getOutOfCatchment()));	1✔
257	if (tag.getName().contains("/")) {	1✔
258	String[] array = tag.getName().split("/");	1✔
259
260	if ((array[0]).toLowerCase().contains(vaccine.getName().toLowerCase())) {	1✔
261	tag.setName(array[0]);	1✔
262	} else if ((array[1]).toLowerCase().contains(vaccine.getName().toLowerCase())) {	×
263
264	tag.setName(array[1]);	×
265	}
266	}
267	}
268	}	1✔
269	}
270
271	}	1✔
272
273	private void notifyAsyncTaskCompleted() {
274	remainingAsyncTasks--;	1✔
275	checkRemainingAsyncTasksStatus();	1✔
276	}	1✔
277
278	private void checkRemainingAsyncTasksStatus() {
279	if (remainingAsyncTasks == 0 && vaccineCardAdapterLoadingListener != null) {	1✔
280	vaccineCardAdapterLoadingListener.onFinishedLoadingVaccineWrappers();	×
281	}
282	}	1✔
283
284	public VaccineCardAdapterLoadingListener getVaccineCardAdapterLoadingListener() {
285	return vaccineCardAdapterLoadingListener;	×
286	}
287
288	public void setVaccineCardAdapterLoadingListener(VaccineCardAdapterLoadingListener vaccineCardAdapterLoadingListener) {
289	this.vaccineCardAdapterLoadingListener = vaccineCardAdapterLoadingListener;	×
290
291	checkRemainingAsyncTasksStatus();	×
292	}	×
293
294	public GenericInteractor getGenericInteractor() {
295	return new GenericInteractor();	1✔
296	}
297
298	private class VaccineWrapperCallableTask implements Callable<VaccineWrapper> {
299	private VaccineCard vaccineCard;
300
301	private String vaccineName;
302
303	private CommonPersonObjectClient childDetails;
304
305	private int days_after_birth_due;
306	private int position;
307
308	private org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData;
309	VaccineWrapperCallableTask (VaccineCard vaccineCard, org.smartregister.immunization.domain.jsonmapping.Vaccine vaccineData,
310	CommonPersonObjectClient childDetails, Integer days_after_birth_due, int position){	1✔
311	this.vaccineCard = vaccineCard;	1✔
312	vaccineName = vaccineData.name;	1✔
313	this.childDetails = childDetails;	1✔
314	this.days_after_birth_due = days_after_birth_due;	1✔
315	this.position = position;	1✔
316	this.vaccineData = vaccineData;	1✔
317	}	1✔
318
319
320	@Override
321	public VaccineWrapper call() throws Exception {
322	VaccineWrapper vaccineWrapper = new VaccineWrapper();	1✔
323	vaccineWrapper.setId(childDetails.entityId());	1✔
324	vaccineWrapper.setGender(childDetails.getDetails().get("gender"));	1✔
325	vaccineWrapper.setName(vaccineData.name);	1✔
326	vaccineWrapper.setDefaultName(vaccineData.name);	1✔
327	if (vaccineData.schedule != null && vaccineData.schedule.conditions != null) {	1✔
328	vaccineWrapper.setNotGivenCondition(vaccineData.schedule.conditions.get(0).vaccine);	1✔
329	}
330
331	String dobString = getValue(childDetails.getColumnmaps(), "dob", false);	1✔
332	if (StringUtils.isNotBlank(dobString)) {	1✔
333	Calendar dobCalender = Calendar.getInstance();	1✔
334	DateTime dateTime = new DateTime(dobString);	1✔
335	dobCalender.setTime(dateTime.toDate());	1✔
336	dobCalender.add(Calendar.DATE, days_after_birth_due);	1✔
337	vaccineWrapper.setVaccineDate(new DateTime(dobCalender.getTime()));	1✔
338	}
339
340	Photo photo = ImageUtils.profilePhotoByClient(childDetails);	1✔
341	vaccineWrapper.setPhoto(photo);	1✔
342
343	String zeirId = getValue(childDetails.getColumnmaps(), "zeir_id", false);	1✔
344	vaccineWrapper.setPatientNumber(zeirId);	1✔
345
346	String firstName = getValue(childDetails.getColumnmaps(), "first_name", true);	1✔
347	String lastName = getValue(childDetails.getColumnmaps(), "last_name", true);	1✔
348	String childName = getName(firstName, lastName);	1✔
349	vaccineWrapper.setPatientName(childName.trim());	1✔
350
351	updateWrapper(vaccineWrapper);	1✔
352	updateWrapperStatus(vaccineWrapper, type, childDetails);	1✔
353	return vaccineWrapper;	1✔
354	}
355
356	}
357
358	public class VaccineRowTaskCallableInteractorCallback implements CallableInteractorCallBack<VaccineWrapper>{
359	private VaccineCard vaccineCard;
360	private int position;
361	VaccineRowTaskCallableInteractorCallback(VaccineCard vaccineCard, int position){	1✔
362	this.vaccineCard = vaccineCard;	1✔
363	this.position = position;	1✔
364	}	1✔
365	@Override
366	public void onResult(VaccineWrapper vaccineWrapper) {
367	this.vaccineCard.setVaccineWrapper(vaccineWrapper);	1✔
368
369	//If last position, toggle RecordAll
370	if (position == (getCount() - 1)) {	1✔
371	vaccineGroup.toggleRecordAllTV();	×
372	}
373	notifyDataSetChanged();	1✔
374	notifyAsyncTaskCompleted();	1✔
375	}	1✔
376
377	@Override
378	public void onError(Exception ex) {
379	Timber.e(ex);	×
380	}	×
381	}
382
383
384	}

OpenSRP / opensrp-client-immunization / #902

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