Change to use gs1 parse from front end code

client/packages/coldchain/src/Equipment/ListView/AddFromScannerButton.tsx

@@ -34,7 +34,8 @@ export const AddFromScannerButtonComponent = () => {
   const equipmentRoute = RouteBuilder.create(AppRoute.Coldchain).addPart(
     AppRoute.Equipment
   );
-  const { mutateAsync: scanAsset } = useAssets.document.scan();
+  const { mutateAsync: fetchAsset } = useAssets.document.fetch();
+  const { mutateAsync: fetchGS1 } = useAssets.document.gs1();
   const { mutateAsync: saveNewAsset } = useAssets.document.insert();
   const { insertLog, invalidateQueries } = useAssets.log.insert();
   const newAssetData = useRef<DraftAsset>();
@@ -64,9 +65,24 @@ export const AddFromScannerButtonComponent = () => {
 
   const handleScanResult = async (result: ScanResult) => {
     if (!!result.content) {
-      const { content } = result;
+      const { gs1 } = result;
 
-      const asset = await scanAsset(content).catch(() => {});
+      if (!gs1) {
+        // try to fetch the asset by id, as it could be an id from our own barcode
+        const { content } = result;
+        const id = content;
+        const asset = await fetchAsset(id).catch(() => {});
+        if (asset) {
+          navigate(equipmentRoute.addPart(id).build());
+
+          return;
+        }
+        error(t('error.no-matching-asset', { id }))();
+        return;
+      }
+
+      // send the GS1 data to backend to handle
+      const asset = await fetchGS1(gs1).catch(() => {});
 
       if (asset?.__typename !== 'AssetNode') {
         error(t('error.no-matching-asset', { id: result.content }))();

client/packages/coldchain/src/Equipment/api/api.ts

@@ -7,10 +7,12 @@ import {
   setNullableInput,
   InsertAssetLogInput,
   AssetLogSortFieldInput,
+  Gs1DataElement,
 } from '@openmsupply-client/common';
 import { Sdk, AssetFragment } from './operations.generated';
 import { CCE_CLASS_ID } from '../utils';
 import { DraftAsset } from '../types';
+import { Gs1Barcode } from 'gs1-barcode-parser-mod';
 
 export type ListParams<T> = {
   first: number;
@@ -97,12 +99,15 @@ export const getAssetQueries = (sdk: Sdk, storeId: string) => ({
 
       throw new Error('Asset not found');
     },
-    byScannerString: async (inputText: string) => {
-      const { assetByScannedString } = await sdk.assetByScannedString({
+    byGs1Elements: async (data: Gs1Barcode) => {
+      let dataElements: Gs1DataElement[] = data.parsedCodeItems.map(item => {
+        return { ai: item.ai, data: item.data.toString() };
+      });
+      const { assetFromGs1Data } = await sdk.assetFromGs1Data({
         storeId,
-        inputText,
+        data: dataElements,
       });
-      return assetByScannedString;
+      return assetFromGs1Data;
     },
     list: async (
       { first, offset, sortBy, filterBy }: ListParams<AssetFragment>,

client/packages/coldchain/src/Equipment/api/hooks/document/index.ts

@@ -1,8 +1,4 @@
-import {
-  useAsset,
-  useFetchAssetById,
-  useFetchAssetByScannerString,
-} from './useAsset';
+import { useAsset, useFetchAssetById, useFetchAssetByGS1 } from './useAsset';
 import { useAssetDelete } from './useAssetDelete';
 import { useAssetFields } from './useAssetFields';
 import { useAssetInsert } from './useAssetInsert';
@@ -22,6 +18,6 @@ export const Document = {
   useAssetsDelete,
   useAssetUpdate,
   useFetchAssetById,
-  useFetchAssetByScannerString,
+  useFetchAssetByGS1,
   useAssetProperties,
 };

client/packages/coldchain/src/Equipment/api/hooks/document/useAsset.ts

@@ -29,9 +29,9 @@ export const useFetchAssetById = () => {
   });
 };
 
-export const useFetchAssetByScannerString = () => {
+export const useFetchAssetByGS1 = () => {
   const api = useAssetApi();
-  return useMutation(api.get.byScannerString, {
+  return useMutation(api.get.byGs1Elements, {
     onError: () => {},
   });
 };

client/packages/coldchain/src/Equipment/api/hooks/index.ts

@@ -10,7 +10,7 @@ export const useAssets = {
 
   document: {
     fetch: Document.useFetchAssetById,
-    scan: Document.useFetchAssetByScannerString,
+    gs1: Document.useFetchAssetByGS1,
     get: Document.useAsset,
     list: Document.useAssets,
     listAll: Document.useAssetsAll,

client/packages/coldchain/src/Equipment/api/operations.generated.ts

@@ -29,13 +29,13 @@ export type AssetByIdQueryVariables = Types.Exact<{
 
 export type AssetByIdQuery = { __typename: 'Queries', assets: { __typename: 'AssetConnector', totalCount: number, nodes: Array<{ __typename: 'AssetNode', catalogueItemId?: string | null, assetNumber?: string | null, createdDatetime: any, id: string, installationDate?: string | null, properties: string, catalogProperties?: string | null, modifiedDatetime: any, notes?: string | null, replacementDate?: string | null, serialNumber?: string | null, storeId?: string | null, donorNameId?: string | null, warrantyStart?: string | null, warrantyEnd?: string | null, needsReplacement?: boolean | null, documents: { __typename: 'SyncFileReferenceConnector', nodes: Array<{ __typename: 'SyncFileReferenceNode', fileName: string, id: string, mimeType?: string | null }> }, locations: { __typename: 'LocationConnector', totalCount: number, nodes: Array<{ __typename: 'LocationNode', id: string, code: string, name: string, onHold: boolean, coldStorageType?: { __typename: 'ColdStorageTypeNode', id: string, name: string, maxTemperature: number, minTemperature: number } | null }> }, statusLog?: { __typename: 'AssetLogNode', logDatetime: any, status?: Types.StatusType | null, reason?: { __typename: 'AssetLogReasonNode', reason: string } | null } | null, store?: { __typename: 'StoreNode', id: string, code: string, storeName: string } | null, catalogueItem?: { __typename: 'AssetCatalogueItemNode', manufacturer?: string | null, model: string } | null, assetType?: { __typename: 'AssetTypeNode', id: string, name: string } | null, assetClass?: { __typename: 'AssetClassNode', id: string, name: string } | null, assetCategory?: { __typename: 'AssetCategoryNode', id: string, name: string } | null, donor?: { __typename: 'NameNode', id: string, name: string } | null }> } };
 
-export type AssetByScannedStringQueryVariables = Types.Exact<{
+export type AssetFromGs1DataQueryVariables = Types.Exact<{
   storeId: Types.Scalars['String']['input'];
-  inputText: Types.Scalars['String']['input'];
+  data: Array<Types.Gs1DataElement> | Types.Gs1DataElement;
 }>;
 
 
-export type AssetByScannedStringQuery = { __typename: 'Queries', assetByScannedString: { __typename: 'AssetNode', catalogueItemId?: string | null, assetNumber?: string | null, createdDatetime: any, id: string, installationDate?: string | null, properties: string, catalogProperties?: string | null, modifiedDatetime: any, notes?: string | null, replacementDate?: string | null, serialNumber?: string | null, storeId?: string | null, donorNameId?: string | null, warrantyStart?: string | null, warrantyEnd?: string | null, needsReplacement?: boolean | null, documents: { __typename: 'SyncFileReferenceConnector', nodes: Array<{ __typename: 'SyncFileReferenceNode', fileName: string, id: string, mimeType?: string | null }> }, locations: { __typename: 'LocationConnector', totalCount: number, nodes: Array<{ __typename: 'LocationNode', id: string, code: string, name: string, onHold: boolean, coldStorageType?: { __typename: 'ColdStorageTypeNode', id: string, name: string, maxTemperature: number, minTemperature: number } | null }> }, statusLog?: { __typename: 'AssetLogNode', logDatetime: any, status?: Types.StatusType | null, reason?: { __typename: 'AssetLogReasonNode', reason: string } | null } | null, store?: { __typename: 'StoreNode', id: string, code: string, storeName: string } | null, catalogueItem?: { __typename: 'AssetCatalogueItemNode', manufacturer?: string | null, model: string } | null, assetType?: { __typename: 'AssetTypeNode', id: string, name: string } | null, assetClass?: { __typename: 'AssetClassNode', id: string, name: string } | null, assetCategory?: { __typename: 'AssetCategoryNode', id: string, name: string } | null, donor?: { __typename: 'NameNode', id: string, name: string } | null } | { __typename: 'ScannedDataParseError' } };
+export type AssetFromGs1DataQuery = { __typename: 'Queries', assetFromGs1Data: { __typename: 'AssetNode', catalogueItemId?: string | null, assetNumber?: string | null, createdDatetime: any, id: string, installationDate?: string | null, properties: string, catalogProperties?: string | null, modifiedDatetime: any, notes?: string | null, replacementDate?: string | null, serialNumber?: string | null, storeId?: string | null, donorNameId?: string | null, warrantyStart?: string | null, warrantyEnd?: string | null, needsReplacement?: boolean | null, documents: { __typename: 'SyncFileReferenceConnector', nodes: Array<{ __typename: 'SyncFileReferenceNode', fileName: string, id: string, mimeType?: string | null }> }, locations: { __typename: 'LocationConnector', totalCount: number, nodes: Array<{ __typename: 'LocationNode', id: string, code: string, name: string, onHold: boolean, coldStorageType?: { __typename: 'ColdStorageTypeNode', id: string, name: string, maxTemperature: number, minTemperature: number } | null }> }, statusLog?: { __typename: 'AssetLogNode', logDatetime: any, status?: Types.StatusType | null, reason?: { __typename: 'AssetLogReasonNode', reason: string } | null } | null, store?: { __typename: 'StoreNode', id: string, code: string, storeName: string } | null, catalogueItem?: { __typename: 'AssetCatalogueItemNode', manufacturer?: string | null, model: string } | null, assetType?: { __typename: 'AssetTypeNode', id: string, name: string } | null, assetClass?: { __typename: 'AssetClassNode', id: string, name: string } | null, assetCategory?: { __typename: 'AssetCategoryNode', id: string, name: string } | null, donor?: { __typename: 'NameNode', id: string, name: string } | null } | { __typename: 'ScannedDataParseError' } };
 
 export type AssetLogsQueryVariables = Types.Exact<{
   filter: Types.AssetLogFilterInput;
@@ -250,9 +250,9 @@ export const AssetByIdDocument = gql`
   }
 }
     ${AssetFragmentDoc}`;
-export const AssetByScannedStringDocument = gql`
-    query assetByScannedString($storeId: String!, $inputText: String!) {
-  assetByScannedString(storeId: $storeId, inputText: $inputText) {
+export const AssetFromGs1DataDocument = gql`
+    query assetFromGs1Data($storeId: String!, $data: [Gs1DataElement!]!) {
+  assetFromGs1Data(storeId: $storeId, gs1: $data) {
     ... on AssetNode {
       ...Asset
     }
@@ -363,8 +363,8 @@ export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper =
     assetById(variables: AssetByIdQueryVariables, requestHeaders?: GraphQLClientRequestHeaders): Promise<AssetByIdQuery> {
       return withWrapper((wrappedRequestHeaders) => client.request<AssetByIdQuery>(AssetByIdDocument, variables, {...requestHeaders, ...wrappedRequestHeaders}), 'assetById', 'query', variables);
     },
-    assetByScannedString(variables: AssetByScannedStringQueryVariables, requestHeaders?: GraphQLClientRequestHeaders): Promise<AssetByScannedStringQuery> {
-      return withWrapper((wrappedRequestHeaders) => client.request<AssetByScannedStringQuery>(AssetByScannedStringDocument, variables, {...requestHeaders, ...wrappedRequestHeaders}), 'assetByScannedString', 'query', variables);
+    assetFromGs1Data(variables: AssetFromGs1DataQueryVariables, requestHeaders?: GraphQLClientRequestHeaders): Promise<AssetFromGs1DataQuery> {
+      return withWrapper((wrappedRequestHeaders) => client.request<AssetFromGs1DataQuery>(AssetFromGs1DataDocument, variables, {...requestHeaders, ...wrappedRequestHeaders}), 'assetFromGs1Data', 'query', variables);
     },
     assetLogs(variables: AssetLogsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders): Promise<AssetLogsQuery> {
       return withWrapper((wrappedRequestHeaders) => client.request<AssetLogsQuery>(AssetLogsDocument, variables, {...requestHeaders, ...wrappedRequestHeaders}), 'assetLogs', 'query', variables);

client/packages/coldchain/src/Equipment/api/operations.graphql

@@ -167,8 +167,8 @@ query assetById($storeId: String!, $assetId: String!) {
   }
 }
 
-query assetByScannedString($storeId: String!, $inputText: String!) {
-  assetByScannedString(storeId: $storeId, inputText: $inputText) {
+query assetFromGs1Data($storeId: String!, $data: [Gs1DataElement!]!) {
+  assetFromGs1Data(storeId: $storeId, gs1: $data) {
     ... on AssetNode {
       ...Asset
     }

client/packages/common/src/types/schema.ts

@@ -2344,6 +2344,11 @@ export type GeneratedCustomerReturnLineConnector = {
   totalCount: Scalars['Int']['output'];
 };
 
+export type Gs1DataElement = {
+  ai: Scalars['String']['input'];
+  data: Scalars['String']['input'];
+};
+
 export type InboundInvoiceCounts = {
   __typename: 'InboundInvoiceCounts';
   created: InvoiceCountsSummary;
@@ -5457,13 +5462,13 @@ export type Queries = {
   activeProgramEvents: ProgramEventResponse;
   activityLogs: ActivityLogResponse;
   apiVersion: Scalars['String']['output'];
-  assetByScannedString: AssetParseResponse;
   assetCatalogueItem: AssetCatalogueItemResponse;
   assetCatalogueItems: AssetCatalogueItemsResponse;
   assetCategories: AssetCategoriesResponse;
   assetCategory: AssetCategoryResponse;
   assetClass: AssetClassResponse;
   assetClasses: AssetClassesResponse;
+  assetFromGs1Data: AssetParseResponse;
   assetLogReasons: AssetLogReasonsResponse;
   assetLogs: AssetLogsResponse;
   assetProperties: AssetPropertiesResponse;
@@ -5630,12 +5635,6 @@ export type QueriesActivityLogsArgs = {
 };
 
 
-export type QueriesAssetByScannedStringArgs = {
-  inputText: Scalars['String']['input'];
-  storeId: Scalars['String']['input'];
-};
-
-
 export type QueriesAssetCatalogueItemArgs = {
   id: Scalars['String']['input'];
 };
@@ -5672,6 +5671,12 @@ export type QueriesAssetClassesArgs = {
 };
 
 
+export type QueriesAssetFromGs1DataArgs = {
+  gs1: Array<Gs1DataElement>;
+  storeId: Scalars['String']['input'];
+};
+
+
 export type QueriesAssetLogReasonsArgs = {
   filter?: InputMaybe<AssetLogReasonFilterInput>;
   page?: InputMaybe<PaginationInput>;

client/packages/common/src/utils/BarcodeScannerContext.tsx

@@ -5,13 +5,14 @@ import { Capacitor } from '@capacitor/core';
 import { GlobalStyles } from '@mui/material';
 import { useNotification } from '../hooks/useNotification';
 import { useTranslation } from '@common/intl';
-import { parseBarcode } from 'gs1-barcode-parser-mod';
+import { Gs1Barcode, parseBarcode } from 'gs1-barcode-parser-mod';
 import { Formatter } from './formatters';
 import { BarcodeScanner, ScannerType } from '@openmsupply-client/common';
 
 const SCAN_TIMEOUT_IN_MS = 5000;
 
 export interface ScanResult {
+  gs1?: Gs1Barcode;
   batch?: string;
   content?: string;
   expiryDate?: string | null;

server/graphql/asset/src/lib.rs

@@ -15,7 +15,7 @@ use service::auth::{Resource, ResourceAccessRequest};
 
 use types::{
     map_parse_error, AssetConnector, AssetFilterInput, AssetNode, AssetParseResponse,
-    AssetSortInput, AssetsResponse, ScannedDataParseError,
+    AssetSortInput, AssetsResponse, GS1DataElement, ScannedDataParseError,
 };
 
 #[derive(Default, Clone)]
@@ -61,11 +61,11 @@ impl AssetQueries {
         )))
     }
 
-    pub async fn asset_by_scanned_string(
+    pub async fn asset_from_gs1_data(
         &self,
         ctx: &Context<'_>,
         store_id: String,
-        input_text: String,
+        gs1: Vec<GS1DataElement>,
     ) -> Result<AssetParseResponse> {
         let user = validate_auth(
             ctx,
@@ -78,9 +78,10 @@ impl AssetQueries {
         let service_provider = ctx.service_provider();
         let service_context = service_provider.context(store_id.clone(), user.user_id)?;
 
-        let result = service_provider
-            .asset_service
-            .parse_scanned_data(&service_context, input_text);
+        let result = service_provider.asset_service.asset_from_gs1_data(
+            &service_context,
+            gs1.into_iter().map(GS1DataElement::to_domain).collect(),
+        );
 
         match result {
             Ok(asset) => Ok(AssetParseResponse::Response(AssetNode::from_domain(asset))),

server/graphql/asset/src/types/asset.rs

@@ -28,7 +28,7 @@ use repository::{
     EqualFilter,
 };
 use repository::{DateFilter, StringFilter};
-use service::asset::parse::ScannedDataParseError as ServiceScannedDataParseError;
+use service::asset::parse::AssetFromGs1Error as ServiceScannedDataParseError;
 use service::{usize_to_u32, ListResult};
 
 use super::{AssetLogNode, AssetLogStatusInput, EqualFilterStatusInput};

server/graphql/asset/src/types/gs1.rs

@@ -0,0 +1,17 @@
+use async_graphql::*;
+use util::GS1DataElement as DomainGS1DataElement;
+
+#[derive(InputObject, Clone)]
+pub struct GS1DataElement {
+    ai: String,
+    data: String,
+}
+
+impl GS1DataElement {
+    pub fn to_domain(self) -> DomainGS1DataElement {
+        DomainGS1DataElement {
+            ai: self.ai.clone(),
+            data: self.data.clone(),
+        }
+    }
+}

server/graphql/asset/src/types/mod.rs

@@ -4,3 +4,5 @@ pub mod asset;
 pub use asset::*;
 pub mod asset_property;
 pub use asset_property::*;
+pub mod gs1;
+pub use gs1::*;

server/service/src/asset/mod.rs

@@ -13,13 +13,14 @@ use self::update::{update_asset, UpdateAsset, UpdateAssetError};
 
 use super::{ListError, ListResult};
 use crate::{service_provider::ServiceContext, SingleRecordError};
-use parse::ScannedDataParseError;
+use parse::AssetFromGs1Error;
 use repository::asset_log_reason::{AssetLogReason, AssetLogReasonFilter, AssetLogReasonSort};
 use repository::asset_property::AssetPropertyFilter;
 use repository::asset_property_row::AssetPropertyRow;
 use repository::assets::asset::{Asset, AssetFilter, AssetSort};
 use repository::assets::asset_log::{AssetLog, AssetLogFilter, AssetLogSort};
 use repository::{PaginationOption, StorageConnection};
+use util::GS1DataElement;
 
 pub mod delete;
 pub mod delete_log_reason;
@@ -139,12 +140,12 @@ pub trait AssetServiceTrait: Sync + Send {
         get_asset_properties(connection, filter)
     }
 
-    fn parse_scanned_data(
+    fn asset_from_gs1_data(
         &self,
         ctx: &ServiceContext,
-        scanned_data: String,
-    ) -> Result<Asset, ScannedDataParseError> {
-        parse::parse_from_scanned_data(ctx, scanned_data)
+        gs1_data: Vec<GS1DataElement>,
+    ) -> Result<Asset, AssetFromGs1Error> {
+        parse::create_from_gs1_data(ctx, gs1_data)
     }
 }