#898

pending completion

Build # #898

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Merge pull request #195 from opensrp/check-vaccine-duplicates

Add Duplicate Vaccines & Recurring Service Record Checks

Run Details

5076 of 6673 relevant lines covered (76.07%)

0.76 hits per line

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

69.7

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.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.TimeUnit;

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);

                VaccineRowTask vaccineRowTask = new VaccineRowTask(vaccineCard, vaccineData,
                        vaccineGroup.getChildDetails(),
                        vaccineGroup.getVaccineData().days_after_birth_due, position);
                Utils.startAsyncTask(vaccineRowTask, null);
            }

            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();
    }

    class VaccineRowTask extends AsyncTask<Void, Void, 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;

        VaccineRowTask(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
        protected VaccineWrapper doInBackground(Void... params) {
            VaccineWrapper vaccineWrapper = new VaccineWrapper();
            vaccineWrapper.setId(childDetails.entityId());
            vaccineWrapper.setGender(childDetails.getDetails().get("gender"));
            vaccineWrapper.setName(vaccineName);
            vaccineWrapper.setDefaultName(vaccineName);
            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;
        }

        @Override
        protected void onPostExecute(VaccineWrapper vaccineWrapper) {
            vaccineCard.setVaccineWrapper(vaccineWrapper);

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

}

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

OpenSRP / opensrp-client-immunization / #898

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