@kenyaemr/esm-patient-registration-app 8.1.1-pre.129 → 8.1.2-pre.152

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kenyaemr/esm-patient-registration-app",
-  "version": "8.1.1-pre.129",
+  "version": "8.1.2-pre.152",
   "description": "Patient registration microfrontend for the OpenMRS SPA",
   "browser": "dist/kenyaemr-esm-patient-registration-app.js",
   "main": "src/index.ts",
@@ -37,14 +37,14 @@
     "url": "https://github.com/openmrs/openmrs-esm-patient-management/issues"
   },
   "dependencies": {
-    "@carbon/react": "~1.37.0",
+    "@carbon/react": "^1.71.0",
     "formik": "^2.1.5",
     "lodash-es": "^4.17.15",
     "uuid": "^8.3.2",
     "yup": "^0.29.1"
   },
   "peerDependencies": {
-    "@openmrs/esm-framework": "5.x",
+    "@openmrs/esm-framework": "6.x",
     "dayjs": "1.x",
     "react": "18.x",
     "react-i18next": "11.x",
@@ -54,5 +54,5 @@
   "devDependencies": {
     "webpack": "^5.74.0"
   },
-  "stableVersion": "8.1.0"
+  "stableVersion": "8.0.2"
 }

package/src/client-registry/hie-client-registry/dependants/dependants.component.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import styles from '../modal/confirm-hie.scss';
+import PatientInfo from '../patient-info/patient-info.component';
+
+const DependentInfo: React.FC<{ dependents: any[] }> = ({ dependents }) => {
+  const { t } = useTranslation();
+
+  if (dependents && dependents.length > 0) {
+    return (
+      <div>
+        <span className={styles.header}>{t('dependants', 'Dependants')}</span>
+        {dependents.map((dependent, index) => {
+          const name = dependent?.name?.text;
+          const relationship =
+            dependent?.relationship?.[0]?.coding?.[0]?.display || t('unknownRelationship', 'Unknown');
+
+          const nationalID = dependent?.extension?.find(
+            (ext) => ext?.valueIdentifier?.type?.coding?.some((coding) => coding.code === 'national-id'),
+          )?.valueIdentifier?.value;
+
+          const birthCertificate = dependent?.extension?.find(
+            (ext) => ext?.valueIdentifier?.type?.coding?.some((coding) => coding.code === 'birth-certificate'),
+          )?.valueIdentifier?.value;
+
+          const primaryIdentifier = nationalID || birthCertificate;
+          const identifierLabel = nationalID
+            ? t('nationalID', 'National ID')
+            : t('birthCertificate', 'Birth Certificate');
+
+          return (
+            <div key={index} className={styles.dependentInfo}>
+              <PatientInfo label={t('name', 'Name')} value={name} />
+              <PatientInfo label={t('relationship', 'Relationship')} value={relationship} />
+              {primaryIdentifier && <PatientInfo label={identifierLabel} value={primaryIdentifier} />}
+            </div>
+          );
+        })}
+      </div>
+    );
+  }
+
+  return null;
+};
+
+export default DependentInfo;

package/src/client-registry/hie-client-registry/hie-client-registry.component.tsx

@@ -11,7 +11,7 @@ import { type RegistrationConfig } from '../../config-schema';
 import { useForm, Controller, type SubmitHandler } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
 import { fetchPatientFromHIE, mapHIEPatientToFormValues } from './hie-resource';
-import { type HIEPatient } from './hie-types';
+import { type HIEPatientResponse, type HIEPatient, type ErrorResponse } from './hie-types';
 
 type HIEClientRegistryProps = {
   props: FormikProps<FormValues>;
@@ -39,26 +39,56 @@ const HIEClientRegistry: React.FC<HIEClientRegistryProps> = ({ setInitialFormVal
     hieClientRegistry: { identifierTypes },
   } = useConfig<RegistrationConfig>();
 
+  const isHIEPatientResponse = (
+    response: HIEPatientResponse | ErrorResponse | undefined,
+  ): response is HIEPatientResponse => {
+    return response?.resourceType === 'Bundle' && 'total' in response;
+  };
+
+  const isOperationOutcome = (response: HIEPatientResponse | ErrorResponse | undefined): response is ErrorResponse => {
+    return response?.resourceType === 'OperationOutcome' && 'issue' in response;
+  };
+
   const onSubmit: SubmitHandler<HIEFormValues> = async (data: HIEFormValues, event: React.BaseSyntheticEvent) => {
     try {
       const hieClientRegistry = await fetchPatientFromHIE(data.identifierType, data.identifierValue);
 
-      if (hieClientRegistry && hieClientRegistry.resourceType === 'Patient') {
+      if (isHIEPatientResponse(hieClientRegistry)) {
+        if (hieClientRegistry.total === 0) {
+          const dispose = showModal('empty-client-registry-modal', {
+            onConfirm: () => dispose(),
+            close: () => dispose(),
+            title: t('clientRegistryEmptys', 'Create Patient'),
+            message: t(
+              'patientNotFounds',
+              `The patient records could not be found in the client registry, proceed to create patient or try again.`,
+            ),
+          });
+          return;
+        }
+
         const dispose = showModal('hie-confirmation-modal', {
           patient: hieClientRegistry,
           closeModal: () => dispose(),
           onUseValues: () =>
-            setInitialFormValues(mapHIEPatientToFormValues(hieClientRegistry as HIEPatient, props.values)),
+            setInitialFormValues(
+              mapHIEPatientToFormValues(hieClientRegistry as unknown as HIEPatientResponse, props.values),
+            ),
         });
-      }
-
-      if (hieClientRegistry && hieClientRegistry.resourceType === 'OperationOutcome') {
-        const issueMessage = hieClientRegistry?.['issue']?.map((issue) => issue.diagnostics).join(', ');
+      } else if (isOperationOutcome(hieClientRegistry)) {
+        const issueMessage = hieClientRegistry?.issue?.map((issue) => issue.diagnostics).join(', ');
         const dispose = showModal('empty-client-registry-modal', {
           onConfirm: () => dispose(),
           close: () => dispose(),
           title: t('clientRegistryEmpty', 'Create & Post Patient'),
-          message: issueMessage,
+          message: issueMessage || t('errorOccurred', ' There was an error processing the request. Try again later'),
+        });
+      } else {
+        showSnackbar({
+          title: t('unexpectedResponse', 'Unexpected Response'),
+          subtitle: t('contactAdmin', 'Please contact the administrator.'),
+          kind: 'error',
+          isLowContrast: true,
         });
       }
     } catch (error) {

package/src/client-registry/hie-client-registry/hie-resource.ts

@@ -1,8 +1,10 @@
 import capitalize from 'lodash-es/capitalize';
 import { type PatientIdentifierValue, type FormValues } from '../../patient-registration/patient-registration.types';
-import { type MapperConfig, type HIEPatient, type ErrorResponse } from './hie-types';
+import { type MapperConfig, type HIEPatient, type ErrorResponse, type HIEPatientResponse } from './hie-types';
 import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 import { v4 } from 'uuid';
+import { z } from 'zod';
+import dayjs from 'dayjs';
 /**
  * Represents a client for interacting with a Health Information Exchange (HIE) resource.
  * @template T - The type of the resource being fetched.
@@ -11,7 +13,6 @@ class HealthInformationExchangeClient<T> {
   async fetchResource(resourceType: string, params: Record<string, string>): Promise<T> {
     const [identifierType, identifierValue] = Object.entries(params)[0];
     const url = `${restBaseUrl}/kenyaemr/getSHAPatient/${identifierValue}/${identifierType}`;
-
     const response = await openmrsFetch(url);
     return response.json();
   }
@@ -33,23 +34,23 @@ class Mapper<T, U> {
 /**
  * Maps HIEPatient objects to FormValues objects.
  */
-class PatientMapper extends Mapper<HIEPatient, FormValues> {
-  mapHIEPatientToFormValues(hiePatient: HIEPatient, currentFormValues: FormValues): FormValues {
-    const name = hiePatient.name?.[0] || {};
-    const telecom = hiePatient.telecom || [];
+class PatientMapper extends Mapper<HIEPatientResponse, FormValues> {
+  mapHIEPatientToFormValues(hiePatient: HIEPatientResponse, currentFormValues: FormValues): FormValues {
+    const { familyName, givenName, middleName } = getPatientName(hiePatient);
+    const telecom = hiePatient?.entry[0]?.resource.telecom || [];
 
     const telecomAttributes = this.mapTelecomToAttributes(telecom);
     const updatedIdentifiers = this.mapIdentifiers(hiePatient, currentFormValues);
-    const extensionAddressEntries = this.mapExtensionsToAddress(hiePatient.extension);
-
+    const extensionAddressEntries = this.mapExtensionsToAddress(hiePatient?.entry[0]?.resource.extension);
+    // TODO: In the event isDead is true, additional information such as caused of death, date e.tc is required
     return {
-      isDead: hiePatient.deceasedBoolean || false,
-      gender: hiePatient.gender || '',
-      birthdate: hiePatient.birthDate || '',
-      givenName: name.given?.[0] || '',
-      familyName: name.family || '',
+      isDead: hiePatient?.entry[0]?.resource?.active ? false : true,
+      gender: hiePatient?.entry[0]?.resource.gender ?? '',
+      birthdate: hiePatient?.entry[0]?.resource?.birthDate ?? '',
+      givenName,
+      familyName,
       telephoneNumber: telecom.find((t) => t.system === 'phone')?.value || '',
-      middleName: name.given?.[1],
+      middleName,
       address: extensionAddressEntries,
       identifiers: updatedIdentifiers,
       attributes: telecomAttributes,
@@ -71,7 +72,7 @@ class PatientMapper extends Mapper<HIEPatient, FormValues> {
   }
 
   private mapIdentifiers(
-    hiePatient: HIEPatient,
+    hiePatient: HIEPatientResponse,
     currentFormValues: FormValues,
   ): Record<string, PatientIdentifierValue> {
     const updatedIdentifiers: Record<string, PatientIdentifierValue> = { ...currentFormValues.identifiers };
@@ -79,11 +80,11 @@ class PatientMapper extends Mapper<HIEPatient, FormValues> {
     // See https://github.com/palladiumkenya/openmrs-module-kenyaemr/blob/1e1d281eaba8041c45318e60ca0730449b8e4197/api/src/main/distro/metadata/identifierTypes.xml#L33
     updatedIdentifiers.socialHealthAuthorityIdentificationNumber = {
       ...currentFormValues.identifiers['socialHealthAuthorityIdentificationNumber'],
-      identifierValue: hiePatient.id,
+      identifierValue: hiePatient?.entry[0]?.resource?.id,
     };
 
     // Map fhir.Patient.Identifier to identifiers
-    hiePatient.identifier?.forEach((identifier: fhir.Identifier) => {
+    hiePatient.entry[0]?.resource.identifier?.forEach((identifier: fhir.Identifier) => {
       const identifierType = identifier.type?.coding?.[0]?.code;
       const mappedIdentifierType = this.convertToCamelCase(identifierType);
       const identifierValue = identifier.value;
@@ -146,17 +147,121 @@ const mapperConfig: MapperConfig = {
 };
 
 // Create instances
-const hieApiClient = new HealthInformationExchangeClient<HIEPatient | ErrorResponse>();
+const hieApiClient = new HealthInformationExchangeClient<HIEPatientResponse | ErrorResponse>();
 const patientMapper = new PatientMapper(mapperConfig);
 
 // Exported functions
 export const fetchPatientFromHIE = async (
   identifierType: string,
   identifierValue: string,
-): Promise<HIEPatient | ErrorResponse> => {
-  return hieApiClient.fetchResource('Patient', { [identifierType]: identifierValue });
+): Promise<HIEPatientResponse | ErrorResponse> => {
+  return hieApiClient.fetchResource('Bundle', { [identifierType]: identifierValue });
 };
 
-export const mapHIEPatientToFormValues = (hiePatient: HIEPatient, currentFormValues: FormValues): FormValues => {
+export const mapHIEPatientToFormValues = (
+  hiePatient: HIEPatientResponse,
+  currentFormValues: FormValues,
+): FormValues => {
   return patientMapper.mapHIEPatientToFormValues(hiePatient, currentFormValues);
 };
+
+/**
+ * Mask sensitive data by replacing end digits starting from the 2nd to last with '*'
+ * @param data {string} - The data to mask
+ * @returns {string} - The masked data
+ */
+export const maskData = (data: string): string => {
+  const maskedData = data.slice(0, 2) + '*'.repeat(Math.max(0, data.length - 2));
+  return maskedData;
+};
+
+/**
+ * Get patient name from FHIR Patient resource
+ * @param patient {fhir.Patient} - The FHIR Patient resource
+ * @returns {object} - The patient name
+ */
+export const getPatientName = (patient: HIEPatientResponse) => {
+  const familyName = patient?.entry?.[0]?.resource?.name?.[0]?.family ?? ''; // Safely access the family name
+  const givenNames = patient?.entry?.[0]?.resource?.name?.[0]?.given ?? []; // Safely access the given names array
+
+  const givenName = givenNames?.[0] ?? ''; // The first item is the given name (first name)
+  const middleName = givenNames.slice(1).join(' ').trim(); // Combine all other given names as middle name(s)
+
+  return { familyName, givenName, middleName };
+};
+
+export const authorizationFormSchema = z.object({
+  otp: z.string().min(1, 'Required'),
+  receiver: z
+    .string()
+    .regex(/^(\+?254|0)((7|1)\d{8})$/)
+    .optional(),
+});
+
+export function generateOTP(length = 5) {
+  let otpNumbers = '0123456789';
+  let OTP = '';
+  const len = otpNumbers.length;
+  for (let i = 0; i < length; i++) {
+    OTP += otpNumbers[Math.floor(Math.random() * len)];
+  }
+  return OTP;
+}
+
+export function persistOTP(otp: string, patientUuid: string) {
+  sessionStorage.setItem(
+    patientUuid,
+    JSON.stringify({
+      otp,
+      timestamp: new Date().toISOString(),
+    }),
+  );
+}
+
+export async function sendOtp({ otp, receiver }: z.infer<typeof authorizationFormSchema>, patientName: string) {
+  const payload = parseMessage(
+    { otp, patient_name: patientName, expiry_time: 5 },
+    'Dear {{patient_name}}, your OTP for accessing your Shared Health Records (SHR) is {{otp}}. Please enter this code to proceed. The code is valid for {{expiry_time}} minutes.',
+  );
+
+  const url = `${restBaseUrl}/kenyaemr/send-kenyaemr-sms?message=${payload}&phone=${receiver}`;
+
+  const res = await openmrsFetch(url, {
+    method: 'POST',
+    redirect: 'follow',
+  });
+  if (res.ok) {
+    return await res.json();
+  }
+  throw new Error('Error sending otp');
+}
+
+function parseMessage(object, template) {
+  const placeholderRegex = /{{(.*?)}}/g;
+
+  const parsedMessage = template.replace(placeholderRegex, (match, fieldName) => {
+    if (object.hasOwnProperty(fieldName)) {
+      return object[fieldName];
+    } else {
+      return match;
+    }
+  });
+
+  return parsedMessage;
+}
+export function verifyOtp(otp: string, patientUuid: string) {
+  const data = sessionStorage.getItem(patientUuid);
+  if (!data) {
+    throw new Error('Invalid OTP');
+  }
+  const { otp: storedOtp, timestamp } = JSON.parse(data);
+  const isExpired = dayjs(timestamp).add(5, 'minutes').isBefore(dayjs());
+  if (storedOtp !== otp) {
+    throw new Error('Invalid OTP');
+  }
+  if (isExpired) {
+    throw new Error('OTP Expired');
+  }
+  sessionStorage.removeItem(patientUuid);
+  return 'Verification success';
+}

package/src/client-registry/hie-client-registry/hie-types.ts

@@ -5,6 +5,108 @@ export type HIEPatient = fhir.Patient & {
   }>;
 };
 
+export interface HIEPatientResponse {
+  resourceType: string;
+  id: string;
+  total: number;
+  meta: Metadata;
+  link: Link[];
+  entry: Entry[];
+}
+
+interface Metadata {
+  lastUpdated: string;
+}
+
+interface Link {
+  relation: string;
+  url: string;
+}
+
+interface Entry {
+  resource: Resource;
+}
+
+interface Resource {
+  id: string;
+  extension: Extension[];
+  identifier: Identifier[];
+  active: boolean;
+  name: Name[];
+  telecom: Telecom[];
+  birthDate: string;
+  address: Address[];
+  gender: string;
+  maritalStatus: MaritalStatus;
+  contact: Contact[];
+}
+
+interface Extension {
+  url: string;
+  valueString: string;
+}
+
+interface Identifier {
+  type: CodingType;
+  value: string;
+}
+
+interface CodingType {
+  coding: Coding[];
+}
+
+interface Coding {
+  system?: string;
+  code: string;
+  display: string;
+}
+
+interface Name {
+  text: string;
+  family: string;
+  given: string[];
+}
+
+interface Telecom {
+  system: string;
+  value?: string;
+}
+
+interface Address {
+  extension: AddressExtension[];
+  city: string;
+  country: string;
+}
+
+interface AddressExtension {
+  url: string;
+  valueString: string;
+}
+
+interface MaritalStatus {
+  coding: Coding[];
+}
+
+interface Contact {
+  id: string;
+  extension: ContactExtension[];
+  relationship: Relationship[];
+  name: Name;
+  telecom: Telecom[];
+  address: Address;
+  gender: string;
+}
+
+interface ContactExtension {
+  url: string;
+  valueIdentifier?: Identifier;
+  valueString?: string;
+}
+
+interface Relationship {
+  coding: Coding[];
+}
+
 export type APIClientConfig = {
   baseUrl: string;
   credentials: string;

package/src/client-registry/hie-client-registry/modal/confirm-hie.modal.tsx

@@ -1,82 +1,98 @@
-import React from 'react';
+import { Button, ModalBody, ModalFooter, ModalHeader , Form } from '@carbon/react';
+import React, { useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Button, ModalBody, ModalHeader, ModalFooter, Accordion, AccordionItem, CodeSnippet } from '@carbon/react';
+import { type HIEPatientResponse, type HIEPatient } from '../hie-types';
 import styles from './confirm-hie.scss';
-import { age, ExtensionSlot, formatDate } from '@openmrs/esm-framework';
-import { type HIEPatient } from '../hie-types';
-import capitalize from 'lodash-es/capitalize';
-
-const PatientInfo: React.FC<{ label: string; value: string }> = ({ label, value }) => {
-  return (
-    <div style={{ display: 'grid', gridTemplateColumns: '0.25fr 0.75fr', margin: '0.25rem' }}>
-      <span style={{ minWidth: '5rem', fontWeight: 'bold' }}>{label}</span>
-      <span>{value}</span>
-    </div>
-  );
-};
+import { authorizationFormSchema, generateOTP, getPatientName, persistOTP, sendOtp, verifyOtp } from '../hie-resource';
+import HIEPatientDetailPreview from './hie-patient-detail-preview.component';
+import HIEOTPVerficationForm from './hie-otp-verification-form.component';
+import { FormProvider, useForm } from 'react-hook-form';
+import { type z } from 'zod';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { showSnackbar } from '@openmrs/esm-framework';
 
 interface HIEConfirmationModalProps {
   closeModal: () => void;
-  patient: HIEPatient;
+  patient: HIEPatientResponse;
   onUseValues: () => void;
 }
 
 const HIEConfirmationModal: React.FC<HIEConfirmationModalProps> = ({ closeModal, patient, onUseValues }) => {
   const { t } = useTranslation();
-  const firstName = patient?.name[0]['given']?.[0];
-  const lastName = patient?.name[0]['family'];
+  const [mode, setMode] = useState<'authorization' | 'preview'>('preview');
+  const [status, setStatus] = useState<'loadingOtp' | 'otpSendSuccessfull' | 'otpFetchError'>();
+  const phoneNumber = patient?.entry[0]?.resource.telecom?.find((num) => num.system === 'phone')?.value;
+  const getidentifier = (code: string) =>
+    patient?.entry[0]?.resource.identifier?.find(
+      (identifier) => identifier?.type?.coding?.some((coding) => coding?.code === code),
+    );
+  const patientId = patient?.id ?? getidentifier('SHA-number')?.value;
+  const form = useForm<z.infer<typeof authorizationFormSchema>>({
+    defaultValues: {
+      receiver: phoneNumber,
+    },
+    resolver: zodResolver(authorizationFormSchema),
+  });
+  const patientName = getPatientName(patient);
 
-  const handleUseValues = () => {
-    onUseValues();
-    closeModal();
+  const onSubmit = async (values: z.infer<typeof authorizationFormSchema>) => {
+    try {
+      verifyOtp(values.otp, patientId);
+      showSnackbar({ title: 'Success', kind: 'success', subtitle: 'Access granted successfully' });
+      onUseValues();
+      closeModal();
+    } catch (error) {
+      showSnackbar({ title: 'Faulure', kind: 'error', subtitle: `${error}` });
+    }
   };
 
   return (
-    <div>
-      <ModalHeader closeModal={closeModal}>
-        <span className={styles.header}>{t('hieModal', 'HIE Patient Record Found')}</span>
-      </ModalHeader>
-      <ModalBody>
-        <div style={{ display: 'flex', margin: '1rem' }}>
-          <ExtensionSlot
-            style={{ display: 'flex', alignItems: 'center' }}
-            name="patient-photo-slot"
-            state={{ patientName: `${firstName} ${lastName}` }}
-          />
-          <div style={{ width: '100%', marginLeft: '0.625rem' }}>
-            <PatientInfo label={t('healthID', 'HealthID')} value={patient?.id} />
-            <PatientInfo label={t('patientName', 'Patient name')} value={`${firstName} ${lastName}`} />
-            <PatientInfo label={t('age', 'Age')} value={age(patient?.birthDate)} />
-            <PatientInfo label={t('dateOfBirth', 'Date of birth')} value={formatDate(new Date(patient?.birthDate))} />
-            <PatientInfo label={t('gender', 'Gender')} value={capitalize(patient?.gender)} />
-            <PatientInfo
-              label={t('maritalStatus', 'Marital status')}
-              value={patient?.maritalStatus?.coding?.map((m) => m.code).join('')}
+    <FormProvider {...form}>
+      <Form onSubmit={form.handleSubmit(onSubmit)}>
+        <ModalHeader closeModal={closeModal}>
+          <span className={styles.header}>
+            {mode === 'authorization'
+              ? t('hiePatientVerification', 'HIE Patient Verification')
+              : t('hieModal', 'HIE Patient Record Found')}
+          </span>
+        </ModalHeader>
+        <ModalBody>
+          {mode === 'authorization' ? (
+            <HIEOTPVerficationForm
+              name={`${patientName.givenName} ${patientName.middleName}`}
+              patientId={patientId}
+              status={status}
+              setStatus={setStatus}
             />
-            <PatientInfo label={t('dependents', 'Dependents')} value="--" />
-          </div>
-        </div>
-        <div>
-          <Accordion>
-            <AccordionItem title={t('viewFullResponse', 'View full response')}>
-              <CodeSnippet type="multi" feedback="Copied to clipboard">
-                {JSON.stringify(patient, null, 2)}
-              </CodeSnippet>
-            </AccordionItem>
-          </Accordion>
-        </div>
-      </ModalBody>
-      <ModalFooter>
-        <Button kind="secondary" onClick={closeModal}>
-          {t('cancel', 'Cancel')}
-        </Button>
+          ) : (
+            <HIEPatientDetailPreview patient={patient} />
+          )}
+        </ModalBody>
+        <ModalFooter>
+          <Button kind="secondary" onClick={closeModal}>
+            {t('cancel', 'Cancel')}
+          </Button>
 
-        <Button onClick={handleUseValues} kind="primary">
-          {t('useValues', 'Use values')}
-        </Button>
-      </ModalFooter>
-    </div>
+          {mode === 'preview' && (
+            <Button onClick={() => setMode('authorization')} kind="primary">
+              {t('useValues', 'Use values')}
+            </Button>
+          )}
+          {mode === 'authorization' && (
+            <Button
+              kind="primary"
+              type="submit"
+              disabled={form.formState.isSubmitting || status !== 'otpSendSuccessfull'}>
+              {t('verifyAndUseValues', 'Verify & Use values')}
+            </Button>
+          )}
+        </ModalFooter>
+      </Form>
+    </FormProvider>
   );
 };
 
 export default HIEConfirmationModal;
+function onVerificationSuccesfull() {
+  throw new Error('Function not implemented.');
+}