#173

pending completion

Build # #173

Build Type

Pull #919

github-actions

Committed by

web-flow

Commit Message

Merge a10bd445f into 5668d546b

Pull Request Pull Request #919: v5 - Set Locales When Formatting Dates

Run Details

18784 of 26961 relevant lines covered (69.67%)

0.7 hits per line

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

0.0

opensrp-core/src/main/java/org/smartregister/clientandeventmodel/populateform/PopulateEnketoFormUtils.java

package org.smartregister.clientandeventmodel.populateform;

import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person;
import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_address;
import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_attribute;
import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_identifier;
import static org.smartregister.clientandeventmodel.FormEntityConstants.Person;
import static org.smartregister.util.JsonFormUtils.gson;

import android.content.Context;
import android.text.TextUtils;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

import org.joda.time.DateTime;
import org.joda.time.Years;
import org.json.JSONException;
import org.json.JSONObject;
import org.smartregister.clientandeventmodel.Address;
import org.smartregister.clientandeventmodel.Client;
import org.smartregister.clientandeventmodel.FormEntityConstants;
import org.smartregister.clientandeventmodel.Obs;
import org.smartregister.domain.form.FieldOverrides;
import org.smartregister.repository.EventClientRepository;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.lang.reflect.Type;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import timber.log.Timber;

/**
 * Created by samuelgithengi on 1/19/18.
 */

public class PopulateEnketoFormUtils {

    private static PopulateEnketoFormUtils instance;

    private static List<String> personProperties = new ArrayList<>();
    private static List<String> addressProperties = new ArrayList<>();

    private EventClientRepository eventClientRepository;

    private DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);

    private String assetsPath = "www/form/";

    private Context context;

    public static PopulateEnketoFormUtils getInstance(Context context, EventClientRepository eventClientRepository) {
        if (instance == null) {
            instance = new PopulateEnketoFormUtils(context, eventClientRepository);
            for (Person property : Person.values())
                personProperties.add(property.name());
            for (FormEntityConstants.Address property : FormEntityConstants.Address.values())
                addressProperties.add(property.name());
        }
        return instance;
    }

    private PopulateEnketoFormUtils(Context context, EventClientRepository eventClientRepository) {
        this.context = context;
        this.eventClientRepository = eventClientRepository;
    }

    public FieldOverrides populateFormOverrides(String baseEntityId, String formSubmissionId, String enketoForm) {
        Map fields = new HashMap();
        Gson gson = new GsonBuilder().create();
        String model = readFileAssets(assetsPath + enketoForm + "/model.xml");
        ModelXMLHandler modelXMLHandler = new ModelXMLHandler();
        List<Model> tags = parseXML(modelXMLHandler, model);
        JSONObject event;
        Client client = null;
        if (formSubmissionId != null) {
            event = eventClientRepository.getEventsByFormSubmissionId(formSubmissionId);
        } else {
            event = eventClientRepository.getEventsByBaseEntityIdAndEventType(baseEntityId, modelXMLHandler.getEventType());
        }
        if (event == null)
            return new FieldOverrides(new JSONObject().toString());
        Type listType = new TypeToken<List<Obs>>() {
        }.getType();
        try {
            List<Obs> obs = gson.fromJson(event.getJSONArray("obs").toString(), listType);
            Map<String, Obs> formObservations = new HashMap<>();
            for (Obs observation : obs)
                formObservations.put(observation.getFormSubmissionField(), observation);
            for (Model tag : tags) {
                Obs observation = formObservations.get(tag.getTag());
                if (observation != null) {
                    if (!observation.getHumanReadableValues().isEmpty())
                        fields.put(tag.getTag(), TextUtils.join(",", observation.getHumanReadableValues()));
                    else
                        fields.put(tag.getTag(), observation.getValue());
                } else if (tag.getOpenMRSEntity() != null) {
                    if (client == null && tag.getOpenMRSEntity().startsWith(person.name()))
                        client = fetchClient(baseEntityId);
                    if (tag.getOpenMRSEntity().equals(person.name())) {
                        fields.put(tag.getTag(), retrieveClientPropertyValue(client, tag));
                    } else if (tag.getOpenMRSEntity().equals(person_identifier.name())) {
                        fields.put(tag.getTag(), client.getIdentifier(tag.getOpenMRSEntityId()));
                    } else if (tag.getOpenMRSEntity().equals(person_attribute.name())) {
                        fields.put(tag.getTag(), client.getAttribute(tag.getOpenMRSEntityId()));
                    } else if (tag.getOpenMRSEntity().equals(person_address.name())) {
                        fields.put(tag.getTag(), retrieveAddressPropertyValue(client.getAddress(tag.getOpenMRSEntityParent()), tag));
                    }
                }
            }
        } catch (JSONException e) {
            Timber.e(e, "populateFormOverrides: Error Parsing Json ");
        }
        JSONObject fieldOverridesJson = new JSONObject(fields);
        FieldOverrides fieldOverrides = new FieldOverrides(fieldOverridesJson.toString());
        return fieldOverrides;
    }

    private Client fetchClient(String baseEntityId) {
        JSONObject clientJSON = eventClientRepository.getClientByBaseEntityId(baseEntityId);
        return gson.fromJson(clientJSON.toString(), Client.class);
    }

    private String retrieveClientPropertyValue(Client client, Model tag) {
        if (tag.getTag().equalsIgnoreCase("age"))
            return Years.yearsBetween(new DateTime(client.getBirthdate()), DateTime.now()).getYears() + "";
        else if (!personProperties.contains(tag.getTag()))
            return null;
        Person personProperty = Person.valueOf(tag.getTag());
        switch (personProperty) {
            case first_name:
                return client.getFirstName();
            case middle_name:
                return client.getMiddleName();
            case last_name:
                return client.getLastName();
            case gender:
                return client.getGender();
            case birthdate:
                return dateFormat.format(client.getBirthdate());
            case birthdate_estimated:
                return client.getBirthdateApprox().toString();
            case deathdate:
                return dateFormat.format(client.getDeathdate());
            case deathdate_estimated:
                return client.getDeathdateApprox().toString();
            case client_type:
                return client.getClientType();
            default:
                return null;
        }
    }

    /**
     * Retrieve address property Value as populated by
     * org.smartregister.clientandeventmodel.FormEntityConverter.fillAddressFields
     */
    private String retrieveAddressPropertyValue(Address address, Model tag) {
        if (address == null)
            return null;
        else if (!addressProperties.contains(tag.getOpenMRSEntityId()))
            return address.getAddressField(tag.getOpenMRSEntityId());
        FormEntityConstants.Address addressProperty = FormEntityConstants.Address.valueOf(tag.getOpenMRSEntityId());
        switch (addressProperty) {
            case start_date:
            case startDate:
                return dateFormat.format(address.getStartDate());
            case end_date:
            case endDate:
                return dateFormat.format(address.getEndDate());
            case latitude:
                return address.getLatitude();
            case longitute:
                return address.getLongitude();
            case geopoint:
                return address.getGeopoint();
            case postal_code:
            case postalCode:
                return address.getPostalCode();
            case sub_town:
            case subTown:
                return address.getSubTown();
            case town:
                return address.getTown();
            case sub_district:
            case subDistrict:
                return address.getSubDistrict();
            case district:
            case county:
            case county_district:
            case countyDistrict:
                return address.getCountyDistrict();
            case city:
            case village:
            case cityVillage:
            case city_village:
                return address.getCityVillage();
            case state:
            case state_province:
            case stateProvince:
                return address.getStateProvince();
            case country:
                return address.getCountry();
            default:
                return null;
        }
    }

    private List<Model> parseXML(ModelXMLHandler modelXMLHandler, String xmlInput) {
        List<Model> modelTags = new ArrayList<>();
        try {
            Timber.i("Start Parsing ModelXML");
            SAXParserFactory spf = SAXParserFactory.newInstance();
            SAXParser sp = spf.newSAXParser();
            XMLReader xr = sp.getXMLReader();

            xr.setContentHandler(modelXMLHandler);
            InputSource inStream = new InputSource();

            inStream.setCharacterStream(new StringReader(xmlInput));

            xr.parse(inStream);

            modelTags = modelXMLHandler.getTags();
        } catch (SAXTerminationException e) {
            modelTags = modelXMLHandler.getTags();
            Timber.i("Finished Parsing the Model");
        } catch (Exception e) {
            Timber.w(e);
        }
        return modelTags;
    }

    private String readFileAssets(String fileName) {
        String fileContents;
        try {
            InputStream is = context.getAssets().open(fileName);
            int size = is.available();
            byte[] buffer = new byte[size];
            is.read(buffer);
            is.close();
            fileContents = new String(buffer, "UTF-8");
        } catch (IOException ex) {
            Timber.e(ex);
            return null;
        }
        return fileContents;
    }

}

1	package org.smartregister.clientandeventmodel.populateform;
2
3	import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person;
4	import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_address;
5	import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_attribute;
6	import static org.smartregister.clientandeventmodel.FormEntityConstants.FieldType.person_identifier;
7	import static org.smartregister.clientandeventmodel.FormEntityConstants.Person;
8	import static org.smartregister.util.JsonFormUtils.gson;
9
10	import android.content.Context;
11	import android.text.TextUtils;
12
13	import com.google.gson.Gson;
14	import com.google.gson.GsonBuilder;
15	import com.google.gson.reflect.TypeToken;
16
17	import org.joda.time.DateTime;
18	import org.joda.time.Years;
19	import org.json.JSONException;
20	import org.json.JSONObject;
21	import org.smartregister.clientandeventmodel.Address;
22	import org.smartregister.clientandeventmodel.Client;
23	import org.smartregister.clientandeventmodel.FormEntityConstants;
24	import org.smartregister.clientandeventmodel.Obs;
25	import org.smartregister.domain.form.FieldOverrides;
26	import org.smartregister.repository.EventClientRepository;
27	import org.xml.sax.InputSource;
28	import org.xml.sax.XMLReader;
29
30	import java.io.IOException;
31	import java.io.InputStream;
32	import java.io.StringReader;
33	import java.lang.reflect.Type;
34	import java.text.DateFormat;
35	import java.text.SimpleDateFormat;
36	import java.util.ArrayList;
37	import java.util.HashMap;
38	import java.util.List;
39	import java.util.Locale;
40	import java.util.Map;
41
42	import javax.xml.parsers.SAXParser;
43	import javax.xml.parsers.SAXParserFactory;
44
45	import timber.log.Timber;
46
47	/**
48	* Created by samuelgithengi on 1/19/18.
49	*/
50
51	public class PopulateEnketoFormUtils {
52
53	private static PopulateEnketoFormUtils instance;
54
55	private static List<String> personProperties = new ArrayList<>();	×
56	private static List<String> addressProperties = new ArrayList<>();	×
57
58	private EventClientRepository eventClientRepository;
59
60	private DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);	×
61
62	private String assetsPath = "www/form/";	×
63
64	private Context context;
65
66	public static PopulateEnketoFormUtils getInstance(Context context, EventClientRepository eventClientRepository) {
67	if (instance == null) {	×
68	instance = new PopulateEnketoFormUtils(context, eventClientRepository);	×
69	for (Person property : Person.values())	×
70	personProperties.add(property.name());	×
71	for (FormEntityConstants.Address property : FormEntityConstants.Address.values())	×
72	addressProperties.add(property.name());	×
73	}
74	return instance;	×
75	}
76
77	private PopulateEnketoFormUtils(Context context, EventClientRepository eventClientRepository) {	×
78	this.context = context;	×
79	this.eventClientRepository = eventClientRepository;	×
80	}	×
81
82	public FieldOverrides populateFormOverrides(String baseEntityId, String formSubmissionId, String enketoForm) {
83	Map fields = new HashMap();	×
84	Gson gson = new GsonBuilder().create();	×
85	String model = readFileAssets(assetsPath + enketoForm + "/model.xml");	×
86	ModelXMLHandler modelXMLHandler = new ModelXMLHandler();	×
87	List<Model> tags = parseXML(modelXMLHandler, model);	×
88	JSONObject event;
89	Client client = null;	×
90	if (formSubmissionId != null) {	×
91	event = eventClientRepository.getEventsByFormSubmissionId(formSubmissionId);	×
92	} else {
93	event = eventClientRepository.getEventsByBaseEntityIdAndEventType(baseEntityId, modelXMLHandler.getEventType());	×
94	}
95	if (event == null)	×
96	return new FieldOverrides(new JSONObject().toString());	×
97	Type listType = new TypeToken<List<Obs>>() {	×
98	}.getType();	×
99	try {
100	List<Obs> obs = gson.fromJson(event.getJSONArray("obs").toString(), listType);	×
101	Map<String, Obs> formObservations = new HashMap<>();	×
102	for (Obs observation : obs)	×
103	formObservations.put(observation.getFormSubmissionField(), observation);	×
104	for (Model tag : tags) {	×
105	Obs observation = formObservations.get(tag.getTag());	×
106	if (observation != null) {	×
107	if (!observation.getHumanReadableValues().isEmpty())	×
108	fields.put(tag.getTag(), TextUtils.join(",", observation.getHumanReadableValues()));	×
109	else
110	fields.put(tag.getTag(), observation.getValue());	×
111	} else if (tag.getOpenMRSEntity() != null) {	×
112	if (client == null && tag.getOpenMRSEntity().startsWith(person.name()))	×
113	client = fetchClient(baseEntityId);	×
114	if (tag.getOpenMRSEntity().equals(person.name())) {	×
115	fields.put(tag.getTag(), retrieveClientPropertyValue(client, tag));	×
116	} else if (tag.getOpenMRSEntity().equals(person_identifier.name())) {	×
117	fields.put(tag.getTag(), client.getIdentifier(tag.getOpenMRSEntityId()));	×
118	} else if (tag.getOpenMRSEntity().equals(person_attribute.name())) {	×
119	fields.put(tag.getTag(), client.getAttribute(tag.getOpenMRSEntityId()));	×
120	} else if (tag.getOpenMRSEntity().equals(person_address.name())) {	×
121	fields.put(tag.getTag(), retrieveAddressPropertyValue(client.getAddress(tag.getOpenMRSEntityParent()), tag));	×
122	}
123	}
124	}	×
125	} catch (JSONException e) {	×
126	Timber.e(e, "populateFormOverrides: Error Parsing Json ");	×
127	}	×
128	JSONObject fieldOverridesJson = new JSONObject(fields);	×
129	FieldOverrides fieldOverrides = new FieldOverrides(fieldOverridesJson.toString());	×
130	return fieldOverrides;	×
131	}
132
133	private Client fetchClient(String baseEntityId) {
134	JSONObject clientJSON = eventClientRepository.getClientByBaseEntityId(baseEntityId);	×
135	return gson.fromJson(clientJSON.toString(), Client.class);	×
136	}
137
138	private String retrieveClientPropertyValue(Client client, Model tag) {
139	if (tag.getTag().equalsIgnoreCase("age"))	×
140	return Years.yearsBetween(new DateTime(client.getBirthdate()), DateTime.now()).getYears() + "";	×
141	else if (!personProperties.contains(tag.getTag()))	×
142	return null;	×
143	Person personProperty = Person.valueOf(tag.getTag());	×
144	switch (personProperty) {	×
145	case first_name:
146	return client.getFirstName();	×
147	case middle_name:
148	return client.getMiddleName();	×
149	case last_name:
150	return client.getLastName();	×
151	case gender:
152	return client.getGender();	×
153	case birthdate:
154	return dateFormat.format(client.getBirthdate());	×
155	case birthdate_estimated:
156	return client.getBirthdateApprox().toString();	×
157	case deathdate:
158	return dateFormat.format(client.getDeathdate());	×
159	case deathdate_estimated:
160	return client.getDeathdateApprox().toString();	×
161	case client_type:
162	return client.getClientType();	×
163	default:
164	return null;	×
165	}
166	}
167
168	/**
169	* Retrieve address property Value as populated by
170	* org.smartregister.clientandeventmodel.FormEntityConverter.fillAddressFields
171	*/
172	private String retrieveAddressPropertyValue(Address address, Model tag) {
173	if (address == null)	×
174	return null;	×
175	else if (!addressProperties.contains(tag.getOpenMRSEntityId()))	×
176	return address.getAddressField(tag.getOpenMRSEntityId());	×
177	FormEntityConstants.Address addressProperty = FormEntityConstants.Address.valueOf(tag.getOpenMRSEntityId());	×
178	switch (addressProperty) {	×
179	case start_date:
180	case startDate:
181	return dateFormat.format(address.getStartDate());	×
182	case end_date:
183	case endDate:
184	return dateFormat.format(address.getEndDate());	×
185	case latitude:
186	return address.getLatitude();	×
187	case longitute:
188	return address.getLongitude();	×
189	case geopoint:
190	return address.getGeopoint();	×
191	case postal_code:
192	case postalCode:
193	return address.getPostalCode();	×
194	case sub_town:
195	case subTown:
196	return address.getSubTown();	×
197	case town:
198	return address.getTown();	×
199	case sub_district:
200	case subDistrict:
201	return address.getSubDistrict();	×
202	case district:
203	case county:
204	case county_district:
205	case countyDistrict:
206	return address.getCountyDistrict();	×
207	case city:
208	case village:
209	case cityVillage:
210	case city_village:
211	return address.getCityVillage();	×
212	case state:
213	case state_province:
214	case stateProvince:
215	return address.getStateProvince();	×
216	case country:
217	return address.getCountry();	×
218	default:
219	return null;	×
220	}
221	}
222
223	private List<Model> parseXML(ModelXMLHandler modelXMLHandler, String xmlInput) {
224	List<Model> modelTags = new ArrayList<>();	×
225	try {
226	Timber.i("Start Parsing ModelXML");	×
227	SAXParserFactory spf = SAXParserFactory.newInstance();	×
228	SAXParser sp = spf.newSAXParser();	×
229	XMLReader xr = sp.getXMLReader();	×
230
231	xr.setContentHandler(modelXMLHandler);	×
232	InputSource inStream = new InputSource();	×
233
234	inStream.setCharacterStream(new StringReader(xmlInput));	×
235
236	xr.parse(inStream);	×
237
238	modelTags = modelXMLHandler.getTags();	×
239	} catch (SAXTerminationException e) {	×
240	modelTags = modelXMLHandler.getTags();	×
241	Timber.i("Finished Parsing the Model");	×
242	} catch (Exception e) {	×
243	Timber.w(e);	×
244	}	×
245	return modelTags;	×
246	}
247
248	private String readFileAssets(String fileName) {
249	String fileContents;
250	try {
251	InputStream is = context.getAssets().open(fileName);	×
252	int size = is.available();	×
253	byte[] buffer = new byte[size];	×
254	is.read(buffer);	×
255	is.close();	×
256	fileContents = new String(buffer, "UTF-8");	×
257	} catch (IOException ex) {	×
258	Timber.e(ex);	×
259	return null;	×
260	}	×
261	return fileContents;	×
262	}
263
264	}

opensrp / opensrp-client-core / #173

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