@openmrs/esm-stock-management-app 1.0.1-pre.783 → 1.0.1-pre.785

package/src/stock-operations/add-stock-operation/stock-operation-submission.component.tsx

@@ -1,189 +0,0 @@
-import React, { useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { StockOperationDTO } from '../../core/api/types/stockOperation/StockOperationDTO';
-import { SaveStockOperation, SaveStockOperationAction } from '../../stock-items/types';
-import { StockOperationType } from '../../core/api/types/stockOperation/StockOperationType';
-import { InitializeResult } from './types';
-import { Button, InlineLoading, RadioButton, RadioButtonGroup, TextInput } from '@carbon/react';
-import { Departure, ListChecked, Save, SendFilled, Undo } from '@carbon/react/icons';
-
-interface StockOperationSubmissionProps {
-  isEditing?: boolean;
-  model?: StockOperationDTO;
-  onSave?: SaveStockOperation;
-  operation: StockOperationType;
-  setup: InitializeResult;
-  canEdit?: boolean;
-  locked?: boolean;
-  requiresDispatchAcknowledgement?: boolean;
-  actions: {
-    onGoBack: () => void;
-    onSave?: SaveStockOperation;
-    onComplete: SaveStockOperationAction;
-    onSubmit: SaveStockOperationAction;
-    onDispatch: SaveStockOperationAction;
-  };
-}
-
-const StockOperationSubmission: React.FC<StockOperationSubmissionProps> = ({
-  canEdit,
-  locked,
-  model,
-  requiresDispatchAcknowledgement,
-  actions,
-  isEditing,
-}) => {
-  const { t } = useTranslation();
-  const [isSaving, setIsSaving] = useState(false);
-  const [approvalRequired, setApprovalRequired] = useState<boolean | null>(model?.approvalRequired);
-
-  const handleRadioButtonChange = (selectedItem: boolean) => {
-    setApprovalRequired(selectedItem);
-  };
-
-  return (
-    <div style={{ margin: '10px' }}>
-      {canEdit && !locked && (
-        <div style={{ margin: '10px' }}>
-          <RadioButtonGroup
-            name="rbgApprovelRequired"
-            legendText={t('doesThisTransactionRequireApproval', 'Does the transaction require approval ?')}
-            onChange={handleRadioButtonChange}
-          >
-            <RadioButton value={true} id="rbgApprovelRequired-true" labelText={t('yes', 'Yes')} />
-            <RadioButton value={false} id="rbgApprovelRequired-false" labelText={t('no', 'No')} />
-          </RadioButtonGroup>
-        </div>
-      )}
-      {!canEdit && (
-        <>
-          <TextInput
-            style={{ margin: '5px' }}
-            id="rbgApproveRequiredLbl"
-            value={approvalRequired ? t('yes', 'Yes') : t('no', 'No')}
-            readOnly={true}
-            labelText={t('doesThisTransactionRequireApproval', 'Does the transaction require approval ?')}
-          />
-        </>
-      )}
-
-      {canEdit && !locked && (
-        <div className="stkpg-form-buttons" style={{ margin: '10px' }}>
-          {approvalRequired != null && (
-            <>
-              {!requiresDispatchAcknowledgement && !approvalRequired && (
-                <Button
-                  name="complete"
-                  type="button"
-                  style={{ margin: '4px' }}
-                  className="submitButton"
-                  kind="primary"
-                  onClick={async () => {
-                    delete model?.dateCreated;
-                    setIsSaving(true);
-                    if (!isEditing) {
-                      delete model.status;
-                      await actions.onSave(model);
-                      setIsSaving(false);
-                    }
-                    model.status = 'COMPLETED';
-                    actions.onComplete(model);
-                    setIsSaving(false);
-                  }}
-                  renderIcon={ListChecked}
-                >
-                  {t('complete', 'Complete')}
-                </Button>
-              )}
-              {requiresDispatchAcknowledgement && !approvalRequired && (
-                <Button
-                  name="dispatch"
-                  type="button"
-                  style={{ margin: '4px' }}
-                  className="submitButton"
-                  kind="primary"
-                  onClick={async () => {
-                    delete model?.dateCreated;
-                    delete model?.status;
-                    setIsSaving(true);
-                    await actions.onSave(model).then(() => {
-                      model.status = 'DISPATCHED';
-                      actions.onDispatch(model);
-                      setIsSaving(false);
-                    });
-                  }}
-                  renderIcon={Departure}
-                >
-                  {isSaving ? (
-                    <InlineLoading description={t('dispatching', 'Dispatching')} />
-                  ) : (
-                    t('dispatch', 'Dispatch')
-                  )}
-                </Button>
-              )}
-              {approvalRequired && (
-                <Button
-                  name="submit"
-                  type="button"
-                  style={{ margin: '4px' }}
-                  className="submitButton"
-                  kind="primary"
-                  onClick={async () => {
-                    delete model?.dateCreated;
-                    delete model?.status;
-                    setIsSaving(true);
-                    await actions.onSave(model).then(() => {
-                      model.status = 'SUBMITTED';
-                      actions.onSubmit(model);
-                      setIsSaving(false);
-                    });
-                  }}
-                  renderIcon={SendFilled}
-                >
-                  {isSaving ? (
-                    <InlineLoading description={t('submittingForReview', 'Submitting for review')} />
-                  ) : (
-                    t('submitForReview', 'Submit For Review')
-                  )}
-                </Button>
-              )}
-            </>
-          )}
-          <Button
-            name="save"
-            type="button"
-            className="submitButton"
-            style={{ margin: '4px' }}
-            disabled={isSaving}
-            onClick={async () => {
-              delete model?.dateCreated;
-              delete model?.status;
-              setIsSaving(true);
-              model.approvalRequired = approvalRequired ? true : false;
-              await actions.onSave(model);
-              setIsSaving(false);
-            }}
-            kind="secondary"
-            renderIcon={Save}
-          >
-            {isSaving ? <InlineLoading /> : t('save', 'Save')}
-          </Button>
-          {!isSaving && (
-            <Button
-              type="button"
-              style={{ margin: '4px' }}
-              className="cancelButton"
-              kind="tertiary"
-              onClick={actions.onGoBack}
-              renderIcon={Undo}
-            >
-              {t('goBack', 'Go Back')}
-            </Button>
-          )}
-        </div>
-      )}
-    </div>
-  );
-};
-
-export default StockOperationSubmission;

package/src/stock-operations/add-stock-operation/stock-operation-submission.test.tsx

@@ -1,138 +0,0 @@
-import React from 'react';
-import { render, waitFor, screen } from '@testing-library/react';
-import StockOperationSubmission from './stock-operation-submission.component';
-import { StockOperationDTO } from '../../core/api/types/stockOperation/StockOperationDTO';
-import { StockOperationType } from '../../core/api/types/stockOperation/StockOperationType';
-import { InitializeResult } from './types';
-import userEvent from '@testing-library/user-event';
-
-const mockOnGoBack = jest.fn();
-const mockOnSave = jest.fn();
-const mockOnComplete = jest.fn();
-const mockOnSubmit = jest.fn();
-const mockOnDispatch = jest.fn();
-const defaultProps = {
-  canEdit: true,
-  locked: false,
-  model: { approvalRequired: null } as StockOperationDTO,
-  operation: {
-    name: 'Stock Issue',
-    description: 'Issuing stock',
-    operationType: 'stockissue',
-    hasSource: true,
-    sourceType: {},
-    hasDestination: true,
-    destinationType: {},
-    hasRecipient: false,
-    recipientRequired: false,
-    availableWhenReserved: false,
-    allowExpiredBatchNumbers: false,
-    stockOperationTypeLocationScopes: [],
-  } as StockOperationType,
-  setup: {
-    isNegativeQuantityAllowed: false,
-    requiresBatchUuid: false,
-    requiresActualBatchInfo: false,
-    isQuantityOptional: false,
-  } as InitializeResult,
-  actions: {
-    onGoBack: mockOnGoBack,
-    onSave: mockOnSave,
-    onComplete: mockOnComplete,
-    onSubmit: mockOnSubmit,
-    onDispatch: mockOnDispatch,
-  },
-};
-
-describe('StockOperationSubmission', () => {
-  let user;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    user = userEvent.setup();
-  });
-
-  it('renders without crashing', () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    expect(screen.getByText(/does the transaction require approval/i)).toBeInTheDocument();
-  });
-
-  it('allows approval required to be selected', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByLabelText(/yes/i));
-    const yesRadioButton = screen.getByLabelText(/yes/i) as HTMLInputElement;
-    expect(yesRadioButton.checked).toBe(true);
-  });
-
-  it('allows approval not required to be selected', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByLabelText(/no/i));
-    const noRadioButton = screen.getByLabelText(/no/i) as HTMLInputElement;
-    expect(noRadioButton.checked).toBe(true);
-  });
-
-  it('calls onGoBack when Go Back button is clicked', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByText(/go back/i));
-    expect(mockOnGoBack).toHaveBeenCalled();
-  });
-
-  it('shows loading indicator when saving', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByText(/save/i));
-    await waitFor(() => {
-      expect(mockOnSave).toHaveBeenCalled();
-    });
-  });
-
-  it('calls onSave when save button is clicked', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByText(/save/i));
-    await waitFor(() => {
-      expect(mockOnSave).toHaveBeenCalled();
-    });
-  });
-
-  it('disables the save button while saving', async () => {
-    const mockOnSave = jest.fn<Promise<void>, [StockOperationDTO]>(
-      (model) => new Promise((resolve) => setTimeout(resolve, 500)),
-    );
-
-    const testProps = {
-      ...defaultProps,
-      actions: {
-        ...defaultProps.actions,
-        onSave: mockOnSave,
-      },
-    };
-
-    render(<StockOperationSubmission {...testProps} />);
-    const saveButton = screen.getByRole('button', { name: 'Save' });
-    await user.click(saveButton);
-
-    expect(saveButton).toBeDisabled();
-
-    await waitFor(() => {
-      expect(saveButton).not.toBeDisabled();
-    });
-  });
-
-  it('calls onComplete when Complete button is clicked', async () => {
-    render(<StockOperationSubmission {...defaultProps} />);
-    await user.click(screen.getByText(/complete/i));
-    await waitFor(() => {
-      expect(mockOnComplete).toHaveBeenCalled();
-    });
-  });
-
-  it('does not render buttons when locked', () => {
-    const lockedProps = {
-      ...defaultProps,
-      locked: true,
-    };
-
-    render(<StockOperationSubmission {...lockedProps} />);
-    expect(screen.queryByRole('button', { name: /save/i })).not.toBeInTheDocument();
-    expect(screen.queryByRole('button', { name: /complete/i })).not.toBeInTheDocument();
-  });
-});

package/src/stock-operations/add-stock-operation/types.ts

@@ -1,55 +0,0 @@
-import { StockOperationDTO } from '../../core/api/types/stockOperation/StockOperationDTO';
-import { StockOperationItemDTO } from '../../core/api/types/stockOperation/StockOperationItemDTO';
-import { Party } from '../../core/api/types/Party';
-import { StockOperationType } from '../../core/api/types/stockOperation/StockOperationType';
-import { SaveStockOperation } from '../../stock-items/types';
-import { StockBatchDTO } from '../../core/api/types/stockItem/StockBatchDTO';
-import { StockItemPackagingUOMDTO } from '../../core/api/types/stockItem/StockItemPackagingUOM';
-import { StockItemInventory } from '../../core/api/types/stockItem/StockItemInventory';
-
-export interface InitializeResult {
-  dto?: StockOperationDTO;
-  requisition?: string;
-  stockItems?: StockOperationItemDTO[];
-  showQuantityRequested?: boolean;
-  isNegativeQuantityAllowed: boolean;
-  requiresBatchUuid: boolean;
-  requiresActualBatchInfo: boolean;
-  isQuantityOptional: boolean;
-  canCaptureQuantityPrice: boolean;
-  requiresStockAdjustmentReason: boolean;
-  requiresDispatchAcknowledgement: boolean;
-  allowExpiredBatchNumbers: boolean;
-  canEditModel: boolean;
-  canViewModel: boolean;
-  canApproveModel: boolean;
-  canIssueStock: boolean;
-  canReceiveItems: boolean;
-  canDisplayReceivedItems: boolean;
-  canUpdateItemsBatchInformation: boolean;
-  canPrint: boolean;
-  sourceTags: string[];
-  destinationTags: string[];
-  shouldLockSource: boolean;
-  shouldLockDestination: boolean;
-  sourcePartyListFilter?: (p: Party) => boolean;
-  destinationPartyListFilter?: (p: Party) => boolean;
-  location?: string;
-  sourcePartyList?: Party[];
-  destinationPartyList?: Party[];
-  stockOperationTypes: StockOperationType[];
-  hasQtyRequested: boolean;
-  batchNos?: { [key: string]: StockBatchDTO[] };
-  itemUoM?: { [key: string]: StockItemPackagingUOMDTO[] };
-  batchBalance?: { [key: string]: StockItemInventory };
-}
-
-export interface AddStockOperationProps {
-  isEditing?: boolean;
-  model?: StockOperationDTO;
-  onSave?: SaveStockOperation;
-  operation: StockOperationType;
-  operations?: StockOperationType[];
-  canPrint?: boolean;
-  canEdit?: boolean;
-}

package/src/stock-operations/add-stock-operation/validationSchema.ts

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-
-export const baseStockOperationSchema = {
-  stockItemUuid: z.string().min(1, { message: 'Required' }),
-  stockItemName: z.string().min(1).nullish(),
-  stockItemPackagingUOMUuid: z.string().min(1, { message: 'Required' }),
-  stockItemPackagingUOMName: z.string().min(1).nullish(),
-  batchNo: z.string().min(1, { message: 'Required' }),
-  stockBatchUuid: z.string().optional(),
-  expiration: z.coerce.date({ required_error: 'Required' }),
-  quantity: z.coerce.number().min(1, { message: 'Required' }),
-  purchasePrice: z.coerce.number().nullish(),
-  hasExpiration: z.boolean().nullish(),
-};
-
-export const stockItemTableSchema = z.object(baseStockOperationSchema);
-
-export const stockItemTableSchemaWithNoExpiration = stockItemTableSchema.omit({
-  expiration: true,
-});
-
-export const stockOperationItemsSchema = z.object({
-  stockItems: z.array(stockItemTableSchema),
-});
-
-export type StockOperationItemsFormData = z.infer<typeof stockOperationItemsSchema>;
-
-export type StockOperationItemFormData = z.infer<typeof stockOperationItemsSchema>['stockItems'][number];
-
-export function useValidationSchema(operationType?: string) {
-  if (operationType === 'requisition') {
-    const customSchema = stockItemTableSchema.omit({
-      batchNo: true,
-      expiration: true,
-    });
-    return z.object({
-      stockItems: z.array(customSchema),
-    });
-  }
-  if (operationType === 'adjustment') {
-    const customSchema = stockItemTableSchema.extend({
-      quantity: z.coerce
-        .number()
-        .refine((value) => value !== 0, {
-          message: 'Quantity cannot be zero.',
-        })
-        .or(z.literal(0, { invalid_type_error: 'Invalid quantity format' })),
-    });
-    return z.object({
-      stockItems: z.array(customSchema),
-    });
-  }
-  return stockOperationItemsSchema;
-}

package/src/stock-operations/batch-no-selector/batch-no-selector.component.tsx

@@ -1,114 +0,0 @@
-import React, { ReactNode, useEffect, useMemo, useState } from 'react';
-import { Control, Controller, FieldValues } from 'react-hook-form';
-import { ComboBox, InlineLoading } from '@carbon/react';
-import { useStockItemBatchNos } from './batch-no-selector.resource';
-import { StockBatchDTO } from '../../core/api/types/stockItem/StockBatchDTO';
-import { useStockItemBatchInformationHook } from '../../stock-items/add-stock-item/batch-information/batch-information.resource';
-import { useTranslation } from 'react-i18next';
-import { formatForDatePicker } from '../../constants';
-
-interface BatchNoSelectorProps<T> {
-  placeholder?: string;
-  stockItemUuid: string;
-  batchUuid?: string;
-  onBatchNoChanged?: (item: StockBatchDTO) => void;
-  title?: string;
-  invalid?: boolean;
-  invalidText?: ReactNode;
-  selectedItem?: string;
-
-  // Control
-  controllerName: string;
-  name: string;
-  control: Control<FieldValues, T>;
-}
-
-const BatchNoSelector = <T,>(props: BatchNoSelectorProps<T>) => {
-  const { isLoading, stockItemBatchNos } = useStockItemBatchNos(props.stockItemUuid);
-  const [validationMessage, setValidationMessage] = useState<string | null>(null);
-  const [selectedItem, setSelectedItem] = useState<StockBatchDTO | null>(null);
-  const { t } = useTranslation();
-
-  const initialSelectedItem = useMemo(
-    () => stockItemBatchNos?.find((stockItem) => stockItem.uuid === props.batchUuid) ?? '',
-    [stockItemBatchNos, props.batchUuid],
-  );
-
-  const { items, setStockItemUuid } = useStockItemBatchInformationHook();
-
-  useEffect(() => {
-    setStockItemUuid(props.stockItemUuid);
-  }, [props.stockItemUuid, setStockItemUuid]);
-
-  const stockItemBatchesInfo = stockItemBatchNos?.map((item) => {
-    const matchingBatch = items?.find((batch) => batch.batchNumber === item.batchNo);
-    if (matchingBatch) {
-      return {
-        ...item,
-        quantity: matchingBatch.quantity ?? '',
-      };
-    }
-    return item;
-  });
-
-  const filteredBatches = stockItemBatchesInfo?.filter((s) => s.quantity !== undefined && s.quantity !== 0);
-
-  useEffect(() => {
-    if (
-      !isLoading &&
-      stockItemBatchNos &&
-      props.selectedItem &&
-      (stockItemBatchNos.length === 0 || filteredBatches.length === 0)
-    ) {
-      setValidationMessage('No stock batch numbers defined. Do a initial/receipt stock operation first.');
-    } else {
-      setValidationMessage(null);
-    }
-  }, [isLoading, stockItemBatchNos, props.selectedItem, filteredBatches]);
-
-  if (isLoading) return <InlineLoading status="active" data-testid="loading" />;
-
-  return (
-    <div style={{ display: 'flex', flexDirection: 'column' }}>
-      <Controller
-        name={props.controllerName}
-        control={props.control}
-        render={({ field: { onChange, ref } }) => (
-          <ComboBox
-            style={{ flexGrow: '1' }}
-            titleText={props.title}
-            name={props.name}
-            control={props.control}
-            controllerName={props.controllerName}
-            id={props.name}
-            size={'sm'}
-            items={filteredBatches || []}
-            onChange={(data: { selectedItem?: StockBatchDTO }) => {
-              setSelectedItem(data.selectedItem || null);
-              props.onBatchNoChanged?.(data.selectedItem);
-              onChange(data.selectedItem?.uuid);
-            }}
-            initialSelectedItem={initialSelectedItem}
-            itemToString={(s: StockBatchDTO) =>
-              s?.batchNo
-                ? `${s?.batchNo} | Qty: ${s?.quantity ?? 'Unknown'} | Expiry: ${formatForDatePicker(s.expiration)}`
-                : ''
-            }
-            placeholder={props.placeholder}
-            invalid={props.invalid}
-            invalidText={props.invalidText}
-            ref={ref}
-          />
-        )}
-      />
-      {isLoading && <InlineLoading status="active" />}
-      {validationMessage && (
-        <div data-testid="validation-message" style={{ color: 'red', marginTop: '8px' }}>
-          {t(validationMessage)}
-        </div>
-      )}
-    </div>
-  );
-};
-
-export default BatchNoSelector;

package/src/stock-operations/batch-no-selector/batch-no-selector.test.tsx

@@ -1,101 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import { useForm, FormProvider } from 'react-hook-form';
-import { useStockItemBatchNos } from './batch-no-selector.resource';
-import { useStockItemBatchInformationHook } from '../../stock-items/add-stock-item/batch-information/batch-information.resource';
-import BatchNoSelector from './batch-no-selector.component';
-import { StockBatchDTO } from '../../core/api/types/stockItem/StockBatchDTO';
-import userEvent from '@testing-library/user-event';
-import { waitFor } from '@testing-library/react';
-
-// Mock hooks
-jest.mock('./batch-no-selector.resource');
-jest.mock('../../stock-items/add-stock-item/batch-information/batch-information.resource');
-jest.mock('react-i18next', () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-const mockUseStockItemBatchNos = useStockItemBatchNos as jest.Mock;
-const mockUseStockItemBatchInformationHook = useStockItemBatchInformationHook as jest.Mock;
-
-describe('BatchNoSelector Component', () => {
-  const stockItemUuid = 'test-uuid';
-  const batchUuid = 'batch-uuid';
-  const mockStockItemBatchNos: StockBatchDTO[] = [
-    { uuid: '1', batchNo: 'batch1', quantity: '10', expiration: new Date(), stockItemUuid: '', voided: false },
-    { uuid: '2', batchNo: 'batch2', quantity: '20', expiration: new Date(), stockItemUuid: '', voided: false },
-  ];
-  const mockBatchInformation = [
-    { batchNumber: 'batch1', quantity: '10' },
-    { batchNumber: 'batch2', quantity: '20' },
-  ];
-
-  beforeEach(() => {
-    mockUseStockItemBatchNos.mockReturnValue({
-      isLoading: false,
-      stockItemBatchNos: mockStockItemBatchNos,
-    });
-    mockUseStockItemBatchInformationHook.mockReturnValue({
-      items: mockBatchInformation,
-      setStockItemUuid: jest.fn(),
-    });
-  });
-
-  const renderComponent = () => {
-    const Wrapper = () => {
-      const methods = useForm();
-      return (
-        <FormProvider {...methods}>
-          <BatchNoSelector
-            stockItemUuid={stockItemUuid}
-            batchUuid={batchUuid}
-            controllerName="batchNo"
-            name="batchNo"
-            control={methods.control}
-          />
-        </FormProvider>
-      );
-    };
-    render(<Wrapper />);
-  };
-
-  test('should render without crashing', () => {
-    renderComponent();
-    expect(screen.getByRole('combobox')).toBeInTheDocument();
-  });
-
-  test('should display loading state when isLoading is true', () => {
-    mockUseStockItemBatchNos.mockReturnValueOnce({
-      isLoading: true,
-      stockItemBatchNos: [],
-    });
-    renderComponent();
-    expect(screen.getByTestId('loading')).toBeInTheDocument();
-  });
-
-  test('should call onBatchNoChanged when a batch is selected', async () => {
-    const onBatchNoChanged = jest.fn();
-    const Wrapper = () => {
-      const methods = useForm();
-      return (
-        <FormProvider {...methods}>
-          <BatchNoSelector
-            stockItemUuid={stockItemUuid}
-            batchUuid={batchUuid}
-            controllerName="batchNo"
-            name="batchNo"
-            control={methods.control}
-            onBatchNoChanged={onBatchNoChanged}
-          />
-        </FormProvider>
-      );
-    };
-    render(<Wrapper />);
-
-    const combobox = screen.getByRole('combobox');
-    await userEvent.click(combobox);
-    await userEvent.click(screen.getByText((content) => content.includes('batch1')));
-
-    expect(onBatchNoChanged).toHaveBeenCalledWith(mockStockItemBatchNos[0]);
-  });
-});