patient-lib.js

export const patientLib = {
  handleFormSubmit,
  getFormPermanentContent,
  getFormHistorical,
  getHistoricalContent,
  navGetPages
}

// --------------- navigation - to be replaced if built-in framework ------- //

const pagesByTypes = {
  home: 'patient.html',
  permanent: 'patient-profile.html',
  recurring: 'patient-history.html'
};

async function navGetPages(collectorClient) {
  const pages = [{
    type: 'home',
    url: pagesByTypes.home,
    label: 'Home',
    formKey: null
  }];
  for (const section of collectorClient.request.sections) {
    pages.push({
      type: section.type,
      label: HDSLib.l(section.name),
      url: pagesByTypes[section.type] + '?formKey=' + section.key,
      formKey: section.key
    });
  }
  console.log("NNNN ", collectorClient.request, pages);
  return pages;
}


// ---------------- form content ---------------- //



async function getFormHistorical (collectorClient, formKey) {
  await HDSLib.initHDSModel();
  const section = collectorClient.request.getSectionByKey(formKey);
  const formFields = section.itemKeys.map((itemKey) => {
    const itemDef = HDSLib.getHDSModel().itemsDefs.forKey(itemKey);
    
    return {
      id: itemDef.key,
      label: itemDef.label,
      type: itemDef.data.type,
      options: itemDef.data.options,
      itemDef
    } 
  });
  return formFields;
}

// local copy of formProfileContent + actual values
/**
 * @param {*} form 
 * @param {*} date 
 * @returns 
 */
async function getFormPermanentContent (collectorClient, formKey) {
  await HDSLib.initHDSModel();
  const section = collectorClient.request.getSectionByKey(formKey);
  console.log('## getFormPermanentContent ', {section, formKey, collectorClient})
  // get formItems
  const formItemDefs = section.itemKeys.map((itemKey) => (HDSLib.getHDSModel().itemsDefs.forKey(itemKey)));
  // get the values from the API
  const apiCalls = formItemDefs.map(itemDef => ({
    method: 'events.get',
    params: {
      streams: [itemDef.data.streamId],
      types: itemDef.eventTypes,
      limit: 1,
    }
  }));



  const formContent = [];
  const res = await collectorClient.app.connection.api(apiCalls);
  for (let i = 0; i < res.length; i++) {
    const e = res[i];
    const itemDef = formItemDefs[i];
    const content = {
      id: itemDef.key,
      type: itemDef.data.type,
      label: itemDef.label,
      options: itemDef.data.options,
      itemDef,
    }
    if (e.events && e.events.length > 0) {
      const event = e.events[0];
      const valueAndTxt = valueAndTxtForField(event, itemDef);
      console.log('>> valueAndtxt', {event, valueAndTxt});
      content.value = valueAndTxt.value;
      content.valueTxt = valueAndTxt.txt;
      content.eventId = event.id; // will allow t track if the event is to be updated
    } else {
      console.log('>> no event', e);
    }
    formContent.push(content);
  }
  return formContent;
};


async function getHistoricalContent(collectorClient, formKey) {
  await HDSLib.initHDSModel();
  const section = collectorClient.request.getSectionByKey(formKey);
  const itemDefs = section.itemKeys.map((itemKey) => (HDSLib.getHDSModel().itemsDefs.forKey(itemKey)));
  const tableHeaders = itemDefs.map(itemDef => ({
    fieldId: itemDef.key,
    label: itemDef.label,
    type: itemDef.data.type
  }));

  const valuesByDateStr = {};
  function addEntry (event) {
    const itemDef = HDSLib.getHDSModel().itemsDefs.forEvent(event, false);
    if (itemDef == null) {
      console.log('Historical content -- unkown event', event);
      return;
    }
    const dateStr = (new Date(event.time * 1000)).toISOString().split('T')[0];
    if (valuesByDateStr[dateStr] == null) valuesByDateStr[dateStr] = {
      dateNum: (new Date(dateStr)).getTime() / 1000,
      dateStr,
    };
    const valueAndTxt = valueAndTxtForField(event, itemDef);
    valuesByDateStr[dateStr][itemDef.key] = {
      value: valueAndTxt.value,
      valueTxt: valueAndTxt.txt,
      eventId: event.id
    }
  }

  // get the values from the API
  const apiCalls = itemDefs.map(itemDef => ({
    method: 'events.get',
    params: {
      streams: [itemDef.data.streamId],
      types: itemDef.eventTypes,
      limit: 20, // last 20 of each item is enough for a demo
    }
  }));
  const res = await collectorClient.app.connection.api(apiCalls);
  for (let i = 0; i < res.length; i++) {
    const e = res[i];
    if (e.events) {
      for (const event of e.events) {
        addEntry(event);
      }
    } 
  }

  // order by date
  const valuesByDate = Object.values(valuesByDateStr).sort((a, b) => b.dateNum - a.dateNum);
  return { tableHeaders, valuesByDate };
}

function valueAndTxtForField (event, itemDef) {
  if (event.type === 'activity/plain' ) {
    return { value: 'x', txt:  'X'};
  }
  if (itemDef.data.type === 'date' && event.content != null ) {
    // convert the date to a Date object
    const date = new Date(event.content);
    if (!isNaN(date)) {
      const dayStr = date.toISOString().split('T')[0];
      return { value: dayStr, txt: dayStr }; // format YYYY-MM-DD
    } 
    console.error('## Error parsing date', event.content);
    return {value: '', txt: 'Error parsing date'};
  }
  if (itemDef.data.type === 'select') {
    let value = event.content;
    let txt = value;
    if (event.type === 'ratio/generic') {
      value = event.content.value;
    }
    console.log({value, event})
    const selected = itemDef.data.options.find((o) => ( o.value === value ));
    if (selected) {
      txt = selected != null ? HDSLib.l(selected.label) : ' - ';
    }
    return { value, txt };
  } 
  if (event.type === 'ratio/generic' && event.content != null ) {
    return { value: event.content.value, txt:  event.content.value};
  }
  return { value: event.content, txt: event.content };
}

// ---------------- create / update data ---------------- //

function parseValue (value, field) {
  const type = field.itemDef.data.type;
  console.log('>> parsValue', {value, field});
  if (value === undefined || value === null || value === '') {
    return '';
  }
  if (type === 'number') {
    return parseFloatCustom(value);
  }
  if (type === 'date') {
    if (value instanceof Date && !isNaN(value)) {
      return value.toISOString();
    }
    return value === '';
  }
  if (type === 'select' && field.itemDef.eventTypes[0] === 'ratio/generic') {
    const numValue = parseFloatCustom(value);
    if (numValue === '') return '';
    // relative to is the latest value of options
    const relativeTo = field.options[field.options.length -1].value;
    return {
      value: numValue,
      relativeTo
    }
  }
  if (type === 'checkbox' && field.itemDef.eventTypes[0] === 'activity/plain') {
    if (value === 'true') return null; // will be handled as a value
    return '';
  }
  if (type === 'checkbox') {
    return value === 'true';
  }
  return value;
}

function parseFloatCustom(value) {
  const parsedValue = parseFloat(value);
  if (isNaN(parsedValue)) {
    console.error('## Error parsing number', value);
    return '';
  }
  return parsedValue;
}

async function handleFormSubmit (collectorClient, formData, formKey, values, date) {
  console.log('## handleForm', {formData, values, date});
  const apiCalls = [];
  // list of items that will be created or updated
  const itemDefsToCreateOrUpdate = new Set();
  for (const field of formData) {
    const streamId = field.itemDef.data.streamId;
    const eventType = field.itemDef.eventTypes[0];
    const eventId = field.eventId;
    const value = parseValue(values[field.id], field);
    console.log('>> parsed value:', value);
    if (value === '' && eventId) {
      // delete the event
      apiCalls.push({
        method: 'events.delete',
        params: {
          id: eventId,
        }
      });
      continue;
    }

    if (value === field.value || value === '') {
      // no change or noting to create
      continue;
    }

    // bellow update or create
    itemDefsToCreateOrUpdate.add(field.itemDef);

    if (eventId) {
      // update the event
      apiCalls.push({
        method: 'events.update',
        params: {
          id: eventId,
          update: {
            content: value
          }
        }
      });
      continue;
    } 
    // create a new event
    const eventData = {
      streamId: streamId,
      type: eventType,
      content: value
    };
    if (date) eventData.time = date.getTime() / 1000;

    apiCalls.push({
      method: 'events.create',
      params: eventData
    });
  }
  if (apiCalls.length === 0) {
    console.log('## No changes to submit');
    return;
  }

  // ensure streams exists
  await collectorClient.app.connection.streamsAutoCreate.ensureExistsForItems(itemDefsToCreateOrUpdate);

  // send the API calls
  const res = await collectorClient.app.connection.api(apiCalls);
  console.log('## Form submitted', res);
}