@khester/create-dynamics-app 2.1.0 → 2.3.0

package/templates/react-custom-page/src/pcf/MultiEntityControlWrapper.tsx

@@ -1,205 +0,0 @@
-import React, { useState, useCallback, useEffect } from 'react';
-import { Pivot, DynamicsPivotItemProps } from '@khester/dynamics-ui-components';
-import { ContactManagement } from '../components/ContactManagement';
-import { AccountManagement } from '../components/AccountManagement';
-import { DynamicsProvider } from '../providers/DynamicsProvider';
-import { ServiceFactory } from '../services/ServiceFactory';
-import { Logger } from '../components/Logging/logger';
-
-interface PCFContextType {
-  // Define PCF context properties based on your needs
-  webAPI: any;
-  utils: any;
-  parameters: any;
-}
-
-interface MultiEntityControlWrapperProps {
-  context: PCFContextType;
-  defaultEntity?: 'contact' | 'account';
-  showTabs?: boolean;
-}
-
-/**
- * Multi-entity wrapper component for integrating both ContactManagement and AccountManagement
- * with PCF (PowerApps Component Framework). This allows switching between entity management
- * within a single custom control in Dynamics 365.
- */
-export const MultiEntityControlWrapper: React.FC<
-  MultiEntityControlWrapperProps
-> = ({ context, defaultEntity = 'contact', showTabs = true }) => {
-  const [selectedEntity, setSelectedEntity] = useState<'contact' | 'account'>(
-    defaultEntity
-  );
-
-  // Extract configuration from PCF context
-  const baseUrl = context.parameters?.baseUrl?.raw || '';
-
-  useEffect(() => {
-    Logger.userAction(
-      'MultiEntityControlWrapper initialized',
-      { defaultEntity, showTabs, selectedEntity },
-      'MultiEntityControlWrapper'
-    );
-  }, [defaultEntity, showTabs, selectedEntity]);
-
-  // Create API service using ServiceFactory for environment detection
-  const createPCFApiService = () => {
-    try {
-      // Check if we're in PCF context with webAPI available
-      if (context.webAPI) {
-        Logger.log(
-          'PCF WebAPI available, creating custom PCF API service',
-          'MultiEntityControlWrapper'
-        );
-
-        // Create a custom API service that uses PCF's webAPI
-        return {
-          createRecord: async (entityName: string, data: any) => {
-            Logger.debug(
-              `Creating ${entityName} record`,
-              'MultiEntityControlWrapper.createRecord',
-              data
-            );
-            return await context.webAPI.createRecord(entityName, data);
-          },
-          retrieveRecord: async (
-            entityName: string,
-            id: string,
-            select?: string
-          ) => {
-            Logger.debug(
-              `Retrieving ${entityName} record: ${id}`,
-              'MultiEntityControlWrapper.retrieveRecord'
-            );
-            return await context.webAPI.retrieveRecord(entityName, id, select);
-          },
-          updateRecord: async (entityName: string, id: string, data: any) => {
-            Logger.debug(
-              `Updating ${entityName} record: ${id}`,
-              'MultiEntityControlWrapper.updateRecord',
-              data
-            );
-            return await context.webAPI.updateRecord(entityName, id, data);
-          },
-          deleteRecord: async (entityName: string, id: string) => {
-            Logger.debug(
-              `Deleting ${entityName} record: ${id}`,
-              'MultiEntityControlWrapper.deleteRecord'
-            );
-            return await context.webAPI.deleteRecord(entityName, id);
-          },
-          retrieveMultipleRecords: async (
-            entityName: string,
-            fetchXml: string
-          ) => {
-            Logger.debug(
-              `Retrieving multiple ${entityName} records`,
-              'MultiEntityControlWrapper.retrieveMultipleRecords'
-            );
-            return await context.webAPI.retrieveMultipleRecords(
-              entityName,
-              `?fetchXml=${encodeURIComponent(fetchXml)}`
-            );
-          },
-          executeRequest: async (requestName: string, _requestData: any) => {
-            Logger.log(
-              `Executing request: ${requestName}`,
-              'MultiEntityControlWrapper.executeRequest'
-            );
-            throw new Error('Custom requests not supported in PCF WebAPI');
-          },
-          uploadFile: async (_file: File) => {
-            Logger.log(
-              'File upload requested',
-              'MultiEntityControlWrapper.uploadFile'
-            );
-            throw new Error('File upload not supported in PCF WebAPI');
-          },
-        };
-      }
-
-      // Fallback to ServiceFactory for environment detection
-      const xrmGlobal = ServiceFactory.isDynamics365Context()
-        ? (window as any).Xrm
-        : undefined;
-      return ServiceFactory.createApiService(xrmGlobal);
-    } catch (error) {
-      Logger.error(
-        'Failed to create API service in PCF context',
-        'MultiEntityControlWrapper',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const handleEntityChange = useCallback(
-    (item: DynamicsPivotItemProps) => {
-      const newEntity = item.itemKey as 'contact' | 'account';
-      Logger.userAction(
-        'Entity tab changed',
-        { from: selectedEntity, to: newEntity },
-        'MultiEntityControlWrapper.handleEntityChange'
-      );
-      setSelectedEntity(newEntity);
-    },
-    [selectedEntity]
-  );
-
-  const renderEntityManagement = () => {
-    switch (selectedEntity) {
-      case 'contact':
-        return <ContactManagement />;
-      case 'account':
-        return <AccountManagement />;
-      default:
-        return <ContactManagement />;
-    }
-  };
-
-  const containerStyle: React.CSSProperties = {
-    width: '100%',
-    height: '100%',
-    display: 'flex',
-    flexDirection: 'column',
-  };
-
-  const contentStyle: React.CSSProperties = {
-    flex: 1,
-    overflow: 'auto',
-  };
-
-  return (
-    <DynamicsProvider customApiService={createPCFApiService()}>
-      <div style={containerStyle}>
-        {showTabs ? (
-          <>
-            <Pivot
-              items={[
-                {
-                  headerText: 'Contacts',
-                  itemKey: 'contact',
-                  itemIcon: 'Contact',
-                },
-                {
-                  headerText: 'Accounts',
-                  itemKey: 'account',
-                  itemIcon: 'Building',
-                },
-              ]}
-              selectedKey={selectedEntity}
-              onItemClick={handleEntityChange}
-              linkFormat="tabs"
-            />
-            <div style={contentStyle}>{renderEntityManagement()}</div>
-          </>
-        ) : (
-          <div style={contentStyle}>{renderEntityManagement()}</div>
-        )}
-      </div>
-    </DynamicsProvider>
-  );
-};
-
-// Export for PCF integration
-export default MultiEntityControlWrapper;

package/templates/react-custom-page/src/providers/DynamicsProvider.tsx

@@ -1,353 +0,0 @@
-import React, { createContext, useContext, useState, useEffect } from 'react';
-import { IApiService } from '@khester/dynamics-ui-api-client';
-import { ServiceFactory } from '../services/ServiceFactory';
-import { Logger } from '../components/Logging/logger';
-
-interface DynamicsContextType {
-  apiService: IApiService | null;
-  createRecord: (entityName: string, data: any) => Promise<any>;
-  retrieveRecord: (
-    entityName: string,
-    id: string,
-    select?: string
-  ) => Promise<any>;
-  updateRecord: (entityName: string, id: string, data: any) => Promise<any>;
-  deleteRecord: (entityName: string, id: string) => Promise<void>;
-  retrieveMultiple: (entityName: string, query?: string) => Promise<any>;
-  isEnvironmentMock: boolean;
-  environmentType: 'mock' | 'production';
-}
-
-const DynamicsContext = createContext<DynamicsContextType | undefined>(
-  undefined
-);
-
-interface DynamicsProviderProps {
-  children: React.ReactNode;
-  /** Optional Xrm object for Dynamics 365 environment (will be auto-detected if not provided) */
-  xrm?: any;
-  /** Optional custom API service for PCF or other integrations */
-  customApiService?: IApiService;
-}
-
-export const DynamicsProvider: React.FC<DynamicsProviderProps> = ({
-  children,
-  xrm,
-  customApiService,
-}) => {
-  const [apiService, setApiService] = useState<IApiService | null>(null);
-  const [environmentType, setEnvironmentType] = useState<'mock' | 'production'>(
-    'mock'
-  );
-
-  useEffect(() => {
-    try {
-      Logger.log(
-        'DynamicsProvider: Initializing API service',
-        'DynamicsProvider'
-      );
-
-      // Use custom API service if provided (for PCF integration)
-      if (customApiService) {
-        Logger.log(
-          'Using custom API service provided via props',
-          'DynamicsProvider'
-        );
-        setApiService(customApiService);
-        setEnvironmentType('production'); // Assume production for custom services
-        return;
-      }
-
-      // Detect Xrm object if not provided
-      const xrmObject =
-        xrm || (typeof window !== 'undefined' && (window as any).Xrm);
-
-      // Use ServiceFactory to create the appropriate service
-      const service = ServiceFactory.createApiService(xrmObject);
-      const envType = ServiceFactory.getEnvironmentType();
-
-      setApiService(service);
-      setEnvironmentType(envType);
-
-      Logger.log(
-        `DynamicsProvider: Initialized with ${envType} environment`,
-        'DynamicsProvider'
-      );
-
-      if (envType === 'production' && !ServiceFactory.isDynamics365Context()) {
-        Logger.warn(
-          'Running in production mode but Xrm object may not be available',
-          'DynamicsProvider'
-        );
-      }
-    } catch (error) {
-      Logger.error(
-        'Failed to initialize API service',
-        'DynamicsProvider',
-        error
-      );
-
-      // Fallback to mock service for development
-      try {
-        const mockService = ServiceFactory.createApiService();
-        setApiService(mockService);
-        setEnvironmentType('mock');
-        Logger.warn(
-          'Falling back to mock service due to initialization error',
-          'DynamicsProvider'
-        );
-      } catch (fallbackError) {
-        Logger.error(
-          'Failed to initialize fallback mock service',
-          'DynamicsProvider',
-          fallbackError
-        );
-      }
-    }
-  }, [xrm, customApiService]);
-
-  const createRecord = async (entityName: string, data: any) => {
-    if (!apiService) {
-      const error = 'API service not initialized';
-      Logger.error(error, 'DynamicsProvider.createRecord');
-      throw new Error(error);
-    }
-
-    try {
-      Logger.apiOperation(
-        'CREATE',
-        entityName,
-        data,
-        'DynamicsProvider.createRecord'
-      );
-      const result = await apiService.createRecord(entityName, data);
-      Logger.log(
-        `Successfully created ${entityName} record`,
-        'DynamicsProvider.createRecord'
-      );
-      return result;
-    } catch (error) {
-      Logger.error(
-        `Failed to create ${entityName} record`,
-        'DynamicsProvider.createRecord',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const retrieveRecord = async (
-    entityName: string,
-    id: string,
-    select?: string
-  ) => {
-    if (!apiService) {
-      const error = 'API service not initialized';
-      Logger.error(error, 'DynamicsProvider.retrieveRecord');
-      throw new Error(error);
-    }
-
-    try {
-      Logger.apiOperation(
-        'READ',
-        entityName,
-        { id, select },
-        'DynamicsProvider.retrieveRecord'
-      );
-
-      // Use retrieveMultipleRecords with FetchXML to get a single record
-      const selectAttributes = select
-        ? select.split(',').map((attr) => attr.trim())
-        : ['*'];
-      const attributes = selectAttributes
-        .map((attr) => (attr === '*' ? '' : `<attribute name="${attr}" />`))
-        .join('');
-      const fetchXml = `
-        <fetch top="1">
-          <entity name="${entityName}">
-            ${attributes}
-            <filter>
-              <condition attribute="${entityName}id" operator="eq" value="${id}" />
-            </filter>
-          </entity>
-        </fetch>
-      `;
-
-      Logger.fetchXml(fetchXml, 'DynamicsProvider.retrieveRecord');
-      const result = await apiService.retrieveMultipleRecords(
-        entityName,
-        fetchXml
-      );
-      const record = result.entities.length > 0 ? result.entities[0] : null;
-
-      Logger.log(
-        `Retrieved ${entityName} record: ${record ? 'found' : 'not found'}`,
-        'DynamicsProvider.retrieveRecord'
-      );
-
-      return record;
-    } catch (error) {
-      Logger.error(
-        `Failed to retrieve ${entityName} record`,
-        'DynamicsProvider.retrieveRecord',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const updateRecord = async (entityName: string, id: string, data: any) => {
-    if (!apiService) {
-      const error = 'API service not initialized';
-      Logger.error(error, 'DynamicsProvider.updateRecord');
-      throw new Error(error);
-    }
-
-    try {
-      Logger.apiOperation(
-        'UPDATE',
-        entityName,
-        { id, data },
-        'DynamicsProvider.updateRecord'
-      );
-      const result = await apiService.updateRecord(entityName, id, data);
-      Logger.log(
-        `Successfully updated ${entityName} record`,
-        'DynamicsProvider.updateRecord'
-      );
-      return result;
-    } catch (error) {
-      Logger.error(
-        `Failed to update ${entityName} record`,
-        'DynamicsProvider.updateRecord',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const deleteRecord = async (entityName: string, id: string) => {
-    if (!apiService) {
-      const error = 'API service not initialized';
-      Logger.error(error, 'DynamicsProvider.deleteRecord');
-      throw new Error(error);
-    }
-
-    try {
-      Logger.apiOperation(
-        'DELETE',
-        entityName,
-        { id },
-        'DynamicsProvider.deleteRecord'
-      );
-      await apiService.deleteRecord(entityName, id);
-      Logger.log(
-        `Successfully deleted ${entityName} record`,
-        'DynamicsProvider.deleteRecord'
-      );
-    } catch (error) {
-      Logger.error(
-        `Failed to delete ${entityName} record`,
-        'DynamicsProvider.deleteRecord',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const retrieveMultiple = async (entityName: string, query?: string) => {
-    if (!apiService) {
-      const error = 'API service not initialized';
-      Logger.error(error, 'DynamicsProvider.retrieveMultiple');
-      throw new Error(error);
-    }
-
-    try {
-      Logger.apiOperation(
-        'QUERY',
-        entityName,
-        query,
-        'DynamicsProvider.retrieveMultiple'
-      );
-
-      // Convert OData-style query to FetchXML
-      let fetchXml = `<fetch>`;
-
-      if (query) {
-        // Parse basic OData query parameters
-        const selectMatch = query.match(/\$select=([^&]*)/i);
-        const orderByMatch = query.match(/\$orderby=([^&]*)/i);
-        const topMatch = query.match(/\$top=(\d+)/i);
-
-        if (topMatch) {
-          fetchXml = `<fetch top="${topMatch[1]}">`;
-        }
-
-        fetchXml += `<entity name="${entityName}">`;
-
-        if (selectMatch) {
-          const attributes = selectMatch[1]
-            .split(',')
-            .map((attr) => attr.trim());
-          attributes.forEach((attr) => {
-            fetchXml += `<attribute name="${attr}" />`;
-          });
-        }
-
-        if (orderByMatch) {
-          const [field, direction] = orderByMatch[1].split(' ');
-          fetchXml += `<order attribute="${field.trim()}" descending="${direction?.toLowerCase() === 'desc'}" />`;
-        }
-
-        fetchXml += `</entity></fetch>`;
-      } else {
-        fetchXml = `<fetch><entity name="${entityName}"></entity></fetch>`;
-      }
-
-      Logger.fetchXml(fetchXml, 'DynamicsProvider.retrieveMultiple');
-      const result = await apiService.retrieveMultipleRecords(
-        entityName,
-        fetchXml
-      );
-
-      Logger.log(
-        `Retrieved ${result.entities.length} ${entityName} records`,
-        'DynamicsProvider.retrieveMultiple'
-      );
-
-      return result;
-    } catch (error) {
-      Logger.error(
-        `Failed to retrieve ${entityName} records`,
-        'DynamicsProvider.retrieveMultiple',
-        error
-      );
-      throw error;
-    }
-  };
-
-  const value: DynamicsContextType = {
-    apiService,
-    createRecord,
-    retrieveRecord,
-    updateRecord,
-    deleteRecord,
-    retrieveMultiple,
-    isEnvironmentMock: environmentType === 'mock',
-    environmentType,
-  };
-
-  return (
-    <DynamicsContext.Provider value={value}>
-      {children}
-    </DynamicsContext.Provider>
-  );
-};
-
-export const useDynamicsApi = (): DynamicsContextType => {
-  const context = useContext(DynamicsContext);
-  if (context === undefined) {
-    throw new Error('useDynamicsApi must be used within a DynamicsProvider');
-  }
-  return context;
-};