function(
$q,
DB
) {
'ngInject';
'use strict';
var lineage = lineageFactory($q,DB());
var get = function(id) {
return lineage.fetchLineageById(id)
.then(function(docs) {
if (!docs.length) {
var err = new Error(`Document not found: ${id}`);
err.code = 404;
throw err;
}
return docs;
});
};
var hydrate = function(docs) {
return lineage.fetchContacts(docs)
.then(function(contacts) {
lineage.fillContactsInDocs(docs, contacts);
return docs;
});
};
return {
/**
* Fetch a contact and its lineage by the given uuid. Returns a
* contact model, or if options.merge is true the doc with the
* lineage inline.
*/
contact: function(id, options) {
options = options || {};
return get(id)
.then(function(docs) {
return hydrate(docs);
})
.then(function(docs) {
// the first row is the contact
var doc = docs.shift();
// everything else is the lineage
var result = {
_id: id,
lineage: docs
};
if (options.merge) {
result.doc = lineage.fillParentsInDocs(doc, docs);
} else {
result.doc = doc;
}
return result;
});
},
/**
* Fetch a contact and its lineage by the given uuid. Returns a
* report model.
*/
report: function(id, options) {
options = options || {};
return get(id)
.then(function(docs) {
return hydrate(docs);
})
.then(function(docs) {
// the first row is the report
var doc = docs.shift();
// the second row is the report's contact
var contact = docs.shift();
// everything else is the lineage
if (options.merge) {
lineage.fillParentsInDocs(doc.contact, docs);
}
return {
_id: id,
doc: doc,
contact: contact,
lineage: docs
};
});
},
reportSubjects: function(ids) {
return lineage.fetchLineageByIds(ids)
.then(function(docsList) {
return docsList.map(function(docs){
return {
_id: docs[0]._id,
doc: docs.shift(),
lineage: docs
};
});
});
}
};
}
.factory('FormatDataRecord', function(
$log,
$q,
$translate,
DB,
FormatDate,
Language,
Settings
) {
'ngInject';
'use strict';
var lineage = lineageFactory($q, DB());
const patientFields = ['patient_id', 'patient_uuid', 'patient_name'];
var getRegistrations = function(patientId) {
var options = {
key: patientId,
include_docs: true,
};
return DB()
.query('medic-client/registered_patients', options)
.then(function(result) {
return result.rows.map(function(row) {
return row.doc;
});
});
};
var getPatient = function(patientId) {
var options = { key: ['shortcode', patientId] };
return DB()
.query('medic-client/contacts_by_reference', options)
.then(function(result) {
if (!result.rows.length) {
return;
}
if (result.rows.length > 1) {
$log.warn(
'More than one patient person document for shortcode "' +
patientId +
'"'
);
}
return lineage.fetchHydratedDoc(result.rows[0].id);
});
};
var fieldsToHtml = function(
settings,
keys,
labels,
data_record,
def,
locale
) {
if (!def && data_record && data_record.form) {
def = getForm(settings, data_record.form);
}
if (_.isString(def)) {
def = getForm(settings, def);
}
var fields = {
headers: [],
data: [],
};
var data = _.extend({}, data_record, data_record.fields);
_.each(keys, function(key) {
if (_.isArray(key)) {
fields.headers.push({ head: titleize(key[0]) });
fields.data.push(
_.extend(fieldsToHtml(key[1], labels, data[key[0]], def, locale), {
isArray: true,
})
);
} else {
var label = labels.shift();
fields.headers.push({ head: getMessage(settings, label) });
if (def && def[key]) {
def = def[key];
}
fields.data.push({
isArray: false,
value: prettyVal(settings, data, key, def, locale),
label: label,
hasUrl: patientFields.includes(key)
});
}
});
return fields;
};
/*
* Get an array of keys from the form. If dot notation is used it will be an
* array of arrays.
*
* @param Object def - form definition
*
* @return Array - form field keys based on forms definition
*/
var getFormKeys = function(def) {
var keys = {};
var getKeys = function(key, hash) {
if (key.length > 1) {
var tmp = key.shift();
if (!hash[tmp]) {
hash[tmp] = {};
}
getKeys(key, hash[tmp]);
} else {
hash[key[0]] = '';
}
};
var hashToArray = function(hash) {
var array = [];
_.each(hash, function(value, key) {
if (typeof value === 'string') {
array.push(key);
} else {
array.push([key, hashToArray(hash[key])]);
}
});
return array;
};
if (def) {
Object.keys(def.fields).forEach(function(key) {
getKeys(key.split('.'), keys);
});
}
return hashToArray(keys);
};
var translateKey = function(settings, key, field, locale) {
var label;
if (field) {
label = getMessage(
settings,
field.labels && field.labels.short,
locale
);
} else {
label = translate(settings, key, locale);
}
// still haven't found a proper label; then titleize
if (key === label) {
return titleize(key);
} else {
return label;
}
};
// returns the deepest array from `key`
var unrollKey = function(array) {
var target = [].concat(array),
root = [];
while (_.isArray(_.last(target))) {
root.push(_.first(target));
target = _.last(target);
}
return _.map(target, function(item) {
return root.concat([item]).join('.');
});
};
/**
* Return a title-case version of the supplied string.
* @name titleize(str)
* @param str The string to transform.
* @returns {String}
*/
var titleize = function(s) {
return s
.trim()
.toLowerCase()
.replace(/([a-z\d])([A-Z]+)/g, '$1_$2')
.replace(/[-\s]+/g, '_')
.replace(/_/g, ' ')
.replace(/(?:^|\s|-)\S/g, function(c) {
return c.toUpperCase();
});
};
var formatDateField = function(date, field) {
if (!date) {
return;
}
var formatted;
var relative;
if (_.contains(['child_birth_date', 'birth_date'], field)) {
formatted = FormatDate.date(date);
relative = FormatDate.relative(date, { withoutTime: true });
} else {
formatted = FormatDate.datetime(date);
relative = FormatDate.relative(date);
}
return formatted + '(' + relative + ')';
};
/*
* @param {Object} data_record - typically a data record or portion (hash)
* @param {String} key - key for field
* @param {Object} def - form or field definition
*/
var prettyVal = function(settings, data_record, key, def, locale) {
if (
!data_record ||
_.isUndefined(key) ||
_.isUndefined(data_record[key])
) {
return;
}
var val = data_record[key];
if (!def) {
return val;
}
if (def.fields && def.fields[key]) {
def = def.fields[key];
}
if (def.type === 'boolean') {
return val === true ? 'True' : 'False';
}
if (def.type === 'date') {
return formatDateField(data_record[key], key);
}
if (def.type === 'integer') {
// use list value for month
if (def.validate && def.validate.is_numeric_month) {
if (def.list) {
for (var i in def.list) {
if (def.list.hasOwnProperty(i)) {
var item = def.list[i];
if (item[0] === val) {
return translate(settings, item[1], locale);
}
}
}
}
}
}
return val;
};
var translate = function(settings, key, locale, ctx, skipInterpolation) {
if (_.isObject(key)) {
return getMessage(settings, key, locale) || key;
}
var interpolation = skipInterpolation ? 'no-interpolation' : null;
// NB: The 5th parameter must be explicitely null to disable sanitization.
// The result will be sanitized by angular when it's rendered, so using
// the default sanitization would result in double encoding.
// Issue: medic/medic#4618
return $translate.instant(key, ctx, interpolation, locale, null);
};
/*
* With some forms like ORPT (patient registration), we add additional data to
* it based on other form submissions. Form data from other reports is used to
* create these fields and it is useful to show these new fields in the data
* records screen/render even though they are not defined in the form.
*/
var includeNonFormFields = function(settings, doc, form_keys, locale) {
var fields = [
'mother_outcome',
'child_birth_outcome',
'child_birth_weight',
'child_birth_date',
'expected_date',
'birth_date',
'patient_id',
];
var dateFields = ['child_birth_date', 'expected_date', 'birth_date'];
_.each(fields, function(field) {
var label = translate(settings, field, locale),
value = doc[field];
// Only include the property if we find it on the doc and not as a form
// key since then it would be duplicated.
if (!value || form_keys.indexOf(field) !== -1) {
return;
}
if (_.contains(dateFields, field)) {
value = formatDateField(value, field);
}
doc.fields.data.unshift({
label: label,
value: value,
isArray: false,
generated: true,
hasUrl: patientFields.includes(field)
});
doc.fields.headers.unshift({
head: label,
});
});
};
var getGroupName = function(task) {
if (task.group) {
return task.type + ':' + task.group;
}
return task.type;
};
var getGroupDisplayName = function(settings, task, language) {
if (task.translation_key) {
return translate(settings, task.translation_key, language, {
group: task.group,
});
}
return getGroupName(task);
};
/*
* Fetch labels from translation strings or jsonform object, maintaining order
* in the returned array.
*
* @param Array keys - keys we want to resolve labels for
* @param String form - form code string
* @param String locale - locale string, e.g. 'en', 'fr', 'en-gb'
*
* @return Array - form field labels based on forms definition.
*
* @api private
*/
var getLabels = function(settings, keys, form, locale) {
var def = getForm(settings, form),
fields = def && def.fields;
return _.reduce(
keys,
function(memo, key) {
var field = fields && fields[key];
if (_.isString(key)) {
memo.push(translateKey(settings, key, field, locale));
} else if (_.isArray(key)) {
_.each(unrollKey(key), function(key) {
var field = fields && fields[key];
memo.push(translateKey(settings, key, field, locale));
});
}
return memo;
},
[]
);
};
var getForm = function(settings, code) {
return settings.forms && settings.forms[code];
};
var getMessage = function(settings, value, locale) {
function _findTranslation(value, locale) {
if (value.translations) {
var translation = _.findWhere(value.translations, { locale: locale });
return translation && translation.content;
} else {
// fallback to old translation definition to support
// backwards compatibility with existing forms
return value[locale];
}
}
if (!_.isObject(value)) {
return value;
}
var test = false;
if (locale === 'test') {
test = true;
locale = 'en';
}
var result =
// 0) does it have a translation_key
(value.translation_key &&
translate(settings, value.translation_key, locale)) ||
// 1) Look for the requested locale
_findTranslation(value, locale) ||
// 2) Look for the default
value.default ||
// 3) Look for the English value
_findTranslation(value, 'en') ||
// 4) Look for the first translation
(value.translations &&
value.translations[0] &&
value.translations[0].content) ||
// 5) Look for the first value
value[_.first(_.keys(value))];
if (test) {
result = '-' + result + '-';
}
return result;
};
const getFields = function(doc, results, values, labelPrefix, depth) {
if (depth > 3) {
depth = 3;
}
Object.keys(values).forEach(function(key) {
const value = values[key];
const label = labelPrefix + '.' + key;
if (_.isObject(value)) {
results.push({
label: label,
depth: depth
});
getFields(doc, results, value, label, depth + 1);
} else {
const result = {
label: label,
value: value,
depth: depth,
hasUrl: patientFields.includes(key)
};
const filePath = 'user-file/' + label.split('.').slice(1).join('/');
if (doc &&
doc._attachments &&
doc._attachments[filePath] &&
doc._attachments[filePath].content_type &&
doc._attachments[filePath].content_type.startsWith('image/')) {
result.imagePath = filePath;
}
results.push(result);
}
});
return results;
};
const getDisplayFields = function(doc) {
// calculate fields to display
if (!doc.fields) {
return [];
}
const label = 'report.' + doc.form;
const fields = getFields(doc, [], doc.fields, label, 0);
const hide = doc.hidden_fields || [];
hide.push('inputs');
return _.reject(fields, function(field) {
return _.some(hide, function(h) {
const hiddenLabel = label + '.' + h;
return hiddenLabel === field.label || field.label.indexOf(hiddenLabel + '.') === 0;
});
});
};
const formatXmlFields = function(doc) {
doc.fields = getDisplayFields(doc);
};
const formatJsonFields = function(doc, settings, language) {
if (!doc.form) {
return;
}
const keys = getFormKeys(getForm(settings, doc.form));
const labels = getLabels(settings, keys, doc.form, language);
doc.fields = fieldsToHtml(
settings,
keys,
labels,
doc,
language
);
includeNonFormFields(settings, doc, keys, language);
};
const formatScheduledTasks = function(doc, settings, language, context) {
doc.scheduled_tasks_by_group = [];
const groups = {};
doc.scheduled_tasks.forEach(function(task) {
// avoid crash if item is falsey
if (!task) {
return;
}
const copy = _.clone(task);
const content = {
translationKey: task.message_key,
message: task.message,
};
if (!copy.messages) {
// backwards compatibility
copy.messages = messages.generate(
settings,
_.partial(translate, settings, _, _, null, true),
doc,
content,
task.recipient,
context
);
if (messages.hasError(copy.messages)) {
copy.error = true;
}
}
// timestamp is used for sorting in the frontend
if (task.timestamp) {
copy.timestamp = task.timestamp;
} else if (task.due) {
copy.timestamp = task.due;
}
// translation key used to identify translatable messages
if (task.message_key) {
copy.message_key = task.message_key;
}
// setup scheduled groups
const groupName = getGroupName(task);
let group = groups[groupName];
if (!group) {
const displayName = getGroupDisplayName(settings, task, language);
groups[groupName] = group = {
group: groupName,
name: displayName,
type: task.type,
number: task.group,
rows: [],
};
}
group.rows.push(copy);
});
Object.keys(groups).forEach(function(key) {
doc.scheduled_tasks_by_group.push(groups[key]);
});
};
/*
* Prepare outgoing messages for render. Reduce messages to organize by
* properties: sent_by, from, state and message. This helps for easier
* display especially in the case of bulk sms.
*
* messages = [
* {
* recipients: [
* {
* to: '+123',
* facility: <facility>,
* timestamp: <timestamp>,
* uuid: <uuid>,
* },
* ...
* ],
* sent_by: 'admin',
* from: '+998',
* state: 'sent',
* message: 'good morning'
* }
* ]
*/
const formatOutgoingMessages = function(doc) {
var outgoing_messages = [];
var outgoing_messages_recipients = [];
doc.tasks.forEach(function(task) {
task.messages.forEach(function(msg) {
var recipient = {
to: msg.to,
facility: msg.facility,
timestamp: task.timestamp,
uuid: msg.uuid,
};
var done = false;
// append recipient to existing
outgoing_messages.forEach(function(m) {
if (
msg.message === m.message &&
msg.sent_by === m.sent_by &&
msg.from === m.from &&
task.state === m.state
) {
m.recipients.push(recipient);
outgoing_messages_recipients.push(recipient);
done = true;
}
});
// create new entry
if (!done) {
outgoing_messages.push({
recipients: [recipient],
sent_by: msg.sent_by,
from: msg.from,
state: task.state,
message: msg.message,
});
outgoing_messages_recipients.push(recipient);
}
});
});
doc.outgoing_messages = outgoing_messages;
doc.outgoing_messages_recipients = outgoing_messages_recipients;
};
/*
* Take data record document and return nice formated JSON object.
*/
var makeDataRecordReadable = function(doc, settings, language, context) {
var formatted = _.clone(doc);
if (formatted.content_type === 'xml') {
formatXmlFields(formatted);
} else {
formatJsonFields(formatted, settings, language);
}
if (formatted.scheduled_tasks) {
formatScheduledTasks(formatted, settings, language, context);
}
if (formatted.kujua_message) {
formatOutgoingMessages(formatted);
}
return formatted;
};
return function(doc) {
var promises = [Settings(), Language()];
var patientId = doc.patient_id || (doc.fields && doc.fields.patient_id);
if (doc.scheduled_tasks && patientId) {
promises.push(getPatient(patientId));
promises.push(getRegistrations(patientId));
}
return $q.all(promises).then(function(results) {
var settings = results[0];
var language = results[1];
var context = {};
if (results.length === 4) {
context.patient = results[2];
context.registrations = results[3].filter(function(registration) {
return registrationUtils.isValidRegistration(
registration,
settings
);
});
}
return makeDataRecordReadable(doc, settings, language, context);
});
};
});