#907

pending completion

Build # #907

Build Type

Pull #194

github-actions

Committed by

web-flow

Commit Message

Merge e31496ca4 into ce201bbb0

Pull Request Pull Request #194: Remove async task

Run Details

5180 of 6703 relevant lines covered (77.28%)

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

OpenSRP / opensrp-client-immunization / #907

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