private List<InterpretationComment> updateInterpretationComments(
List<Interpretation> interpretations) {
List<InterpretationComment> interpretationComments = new ArrayList<>();
if (interpretations != null && !interpretations.isEmpty()) {
for (Interpretation interpretation : interpretations) {
interpretationComments.addAll(interpretation.getComments());
}
}
return interpretationComments;
}
private List<User> updateInterpretationUsers(
List<Interpretation> interpretations, List<InterpretationComment> comments) {
Map<String, User> users = new HashMap<>();
UserAccount currentUserAccount = mUserAccountService.getCurrentUserAccount();
User currentUser = mUserStore.queryByUid(currentUserAccount.getUId());
if (currentUser == null) {
currentUser = mUserAccountService.toUser(currentUserAccount);
}
users.put(currentUser.getUId(), currentUser);
if (interpretations != null && !interpretations.isEmpty()) {
for (Interpretation interpretation : interpretations) {
User user = interpretation.getUser();
if (users.containsKey(user.getUId())) {
user = users.get(user.getUId());
interpretation.setUser(user);
} else {
users.put(user.getUId(), user);
}
}
}
if (comments != null && !comments.isEmpty()) {
for (InterpretationComment comment : comments) {
User user = comment.getUser();
if (users.containsKey(user.getUId())) {
user = users.get(user.getUId());
comment.setUser(user);
} else {
users.put(user.getUId(), user);
}
}
}
return new ArrayList<>(users.values());
}
public void postInterpretation(Interpretation interpretation) throws ApiException {
try {
Response response;
switch (interpretation.getType()) {
/* case Interpretation.TYPE_CHART: {
response = mDhisApi.postChartInterpretation(
interpretation.getChart().getUId(), new TypedString(interpretation.getText()));
break;
}
case Interpretation.TYPE_MAP: {
response = mDhisApi.postMapInterpretation(
interpretation.getMap().getUId(), new TypedString(interpretation.getText()));
break;
}
case Interpretation.TYPE_REPORT_TABLE: {
response = mDhisApi.postReportTableInterpretation(
interpretation.getReportTable().getUId(), new TypedString(interpretation.getText()));
break;
}
default:
throw new IllegalArgumentException("Unsupported interpretation type");
*/
}
/* Header header = NetworkUtils.findLocationHeader(response.getHeaders());
String interpretationUid = Uri.parse(header
.getValue()).getLastPathSegment(); */
// interpretation.setUId(interpretationUid);
// interpretation.setAction(Action.SYNCED);
mInterpretationStore.save(interpretation);
updateInterpretationTimeStamp(interpretation);
} catch (ApiException apiException) {
// ApiExceptionHandler.handleApiException(apiException, interpretation, mInterpretationStore);
}
}
private List<DbOperation> createOperations(
List<Interpretation> oldModels, List<Interpretation> newModels) {
List<DbOperation> ops = new ArrayList<>();
Map<String, Interpretation> newModelsMap = modelUtils.toMap(newModels);
Map<String, Interpretation> oldModelsMap = modelUtils.toMap(oldModels);
for (String oldModelKey : oldModelsMap.keySet()) {
Interpretation newModel = newModelsMap.get(oldModelKey);
Interpretation oldModel = oldModelsMap.get(oldModelKey);
if (newModel == null) {
ops.add(DbOperation.with(mInterpretationStore).delete(oldModel));
continue;
}
if (newModel.getLastUpdated().isAfter(oldModel.getLastUpdated())) {
newModel.setId(oldModel.getId());
ops.add(DbOperation.with(mInterpretationStore).update(newModel));
}
newModelsMap.remove(oldModelKey);
}
for (String newModelKey : newModelsMap.keySet()) {
Interpretation item = newModelsMap.get(newModelKey);
// we also have to insert interpretation elements here
ops.add(DbOperation.with(mInterpretationStore).insert(item));
List<InterpretationElement> elements = new ArrayList<>();
// = mInterpretationService.getInterpretationElements(item);
for (InterpretationElement element : elements) {
ops.add(DbOperation.with(mInterpretationElementStore).insert(element));
}
}
return ops;
}
private List<Interpretation> updateInterpretations(DateTime lastUpdated) {
final Map<String, String> QUERY_MAP_BASIC = new HashMap<>();
final Map<String, String> QUERY_MAP_FULL = new HashMap<>();
final String BASE = "id,created,lastUpdated,name,displayName,access";
QUERY_MAP_BASIC.put("fields", "id");
QUERY_MAP_FULL.put(
"fields",
BASE
+ ",text,type,"
+ "chart"
+ "["
+ BASE
+ "],"
+ "map"
+ "["
+ BASE
+ "],"
+ "reportTable"
+ "["
+ BASE
+ "],"
+ "user"
+ "["
+ BASE
+ "],"
+ "dataSet"
+ "["
+ BASE
+ "],"
+ "period"
+ "["
+ BASE
+ "],"
+ "organisationUnit"
+ "["
+ BASE
+ "],"
+ "comments"
+ "["
+ BASE
+ ",user,text"
+ "]");
if (lastUpdated != null) {
QUERY_MAP_FULL.put("filter", "lastUpdated:gt:" + lastUpdated.toString());
}
/* List<Interpretation> actualInterpretations = NetworkUtils.unwrapResponse(mDhisApi
.getInterpretations(QUERY_MAP_BASIC), "interpretations");
List<Interpretation> updatedInterpretations = NetworkUtils.unwrapResponse(mDhisApi
.getInterpretations(QUERY_MAP_FULL), "interpretations"); */
List<Interpretation> updatedInterpretations = new ArrayList<>();
if (updatedInterpretations != null && !updatedInterpretations.isEmpty()) {
for (Interpretation interpretation : updatedInterpretations) {
// build relationship with comments
if (interpretation.getComments() != null && !interpretation.getComments().isEmpty()) {
for (InterpretationComment comment : interpretation.getComments()) {
comment.setInterpretation(interpretation);
}
}
// we need to set mime type and interpretation to each element
switch (interpretation.getType()) {
case Interpretation.TYPE_CHART:
{
interpretation.getChart().setType(InterpretationElement.TYPE_CHART);
interpretation.getChart().setInterpretation(interpretation);
break;
}
case Interpretation.TYPE_MAP:
{
interpretation.getMap().setType(InterpretationElement.TYPE_MAP);
interpretation.getMap().setInterpretation(interpretation);
break;
}
case Interpretation.TYPE_REPORT_TABLE:
{
interpretation.getReportTable().setType(InterpretationElement.TYPE_REPORT_TABLE);
interpretation.getReportTable().setInterpretation(interpretation);
break;
}
case Interpretation.TYPE_DATA_SET_REPORT:
{
interpretation.getDataSet().setType(InterpretationElement.TYPE_DATA_SET);
interpretation.getPeriod().setType(InterpretationElement.TYPE_PERIOD);
interpretation
.getOrganisationUnit()
.setType(InterpretationElement.TYPE_ORGANISATION_UNIT);
interpretation.getDataSet().setInterpretation(interpretation);
interpretation.getPeriod().setInterpretation(interpretation);
interpretation.getOrganisationUnit().setInterpretation(interpretation);
break;
}
}
}
}
List<Interpretation> persistedInterpretations = null;
// mInterpretationStore.filter(Action.TO_POST);
if (persistedInterpretations != null && !persistedInterpretations.isEmpty()) {
for (Interpretation interpretation : persistedInterpretations) {
List<InterpretationElement> elements = mInterpretationElementStore.list(interpretation);
// mInterpretationService.setInterpretationElements(interpretation, elements);
List<InterpretationComment> comments = null;
// mInterpretationCommentStore.queryByInterpretation(interpretation, Action.TO_POST);
interpretation.setComments(comments);
}
}
// return merge(actualInterpretations, updatedInterpretations, persistedInterpretations);
return null;
}