@khester/create-dynamics-app 1.0.8 → 1.1.0

package/templates/dynamics-365-starter/src/providers/DynamicsProvider.tsx

@@ -1,114 +1,329 @@
 import React, { createContext, useContext, useState, useEffect } from 'react';
-import { DynamicsApiService } from '@khester/dynamics-ui-api-client';
+import { IApiService } from '@khester/dynamics-ui-api-client';
+import { ServiceFactory } from '../services/ServiceFactory';
+import { Logger } from '../components/Logging/logger';
 
 interface DynamicsContextType {
-  apiService: DynamicsApiService | null;
+  apiService: IApiService | null;
   createRecord: (entityName: string, data: any) => Promise<any>;
-  retrieveRecord: (entityName: string, id: string, select?: string) => 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);
+const DynamicsContext = createContext<DynamicsContextType | undefined>(
+  undefined
+);
 
 interface DynamicsProviderProps {
   children: React.ReactNode;
-  baseUrl?: string;
-  accessToken?: string;
+  /** 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, 
-  baseUrl,
-  accessToken 
+export const DynamicsProvider: React.FC<DynamicsProviderProps> = ({
+  children,
+  xrm,
+  customApiService,
 }) => {
-  const [apiService, setApiService] = useState<DynamicsApiService | null>(null);
+  const [apiService, setApiService] = useState<IApiService | null>(null);
+  const [environmentType, setEnvironmentType] = useState<'mock' | 'production'>(
+    'mock'
+  );
 
   useEffect(() => {
-    // Initialize the API service
-    // In a real D365 environment, you would get these from your authentication flow
-    const getAccessToken = async () => {
-      return accessToken || process.env.DYNAMICS_ACCESS_TOKEN || '';
-    };
-    
-    const service = new DynamicsApiService(
-      baseUrl || process.env.DYNAMICS_BASE_URL || 'https://org.crm.dynamics.com',
-      getAccessToken
-    );
-    
-    setApiService(service);
-  }, [baseUrl, accessToken]);
+    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) throw new Error('API service not initialized');
-    return await apiService.createRecord(entityName, data);
+    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) throw new Error('API service not initialized');
-    // 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>
-    `;
-    const result = await apiService.retrieveMultipleRecords(entityName, fetchXml);
-    return result.entities.length > 0 ? result.entities[0] : null;
+  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) throw new Error('API service not initialized');
-    return await apiService.updateRecord(entityName, id, data);
+    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) throw new Error('API service not initialized');
-    return await apiService.deleteRecord(entityName, id);
+    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) throw new Error('API service not initialized');
-    // 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'}" />`;
+    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>`;
       }
-      
-      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;
     }
-    
-    return await apiService.retrieveMultipleRecords(entityName, fetchXml);
   };
 
   const value: DynamicsContextType = {
@@ -118,6 +333,8 @@ export const DynamicsProvider: React.FC<DynamicsProviderProps> = ({
     updateRecord,
     deleteRecord,
     retrieveMultiple,
+    isEnvironmentMock: environmentType === 'mock',
+    environmentType,
   };
 
   return (
@@ -133,4 +350,4 @@ export const useDynamicsApi = (): DynamicsContextType => {
     throw new Error('useDynamicsApi must be used within a DynamicsProvider');
   }
   return context;
-};
+};

package/templates/dynamics-365-starter/src/services/MockApiService.ts

@@ -0,0 +1,260 @@
+import { IApiService } from '@khester/dynamics-ui-api-client';
+
+/**
+ * Mock implementation of IApiService for local development and testing.
+ * Provides in-memory storage and simulated API responses.
+ */
+export class MockApiService implements IApiService {
+  private storage: Map<string, Map<string, any>> = new Map();
+
+  constructor() {
+    // Initialize with some mock data
+    this.initializeMockData();
+  }
+
+  async createRecord(entityName: string, record: any): Promise<any> {
+    console.log(`MockApiService: Creating ${entityName} record`, record);
+
+    // Simulate network delay
+    await this.simulateDelay();
+
+    // Get or create entity collection
+    if (!this.storage.has(entityName)) {
+      this.storage.set(entityName, new Map());
+    }
+    const collection = this.storage.get(entityName)!;
+
+    // Generate ID based on entity type
+    const id = this.generateId(entityName);
+    const primaryKey = this.getPrimaryKey(entityName);
+
+    // Create record with ID
+    const newRecord = {
+      ...record,
+      [primaryKey]: id,
+      createdon: new Date().toISOString(),
+      modifiedon: new Date().toISOString(),
+    };
+
+    collection.set(id, newRecord);
+
+    return newRecord;
+  }
+
+  async updateRecord(
+    entityName: string,
+    id: string,
+    record: any
+  ): Promise<any> {
+    console.log(`MockApiService: Updating ${entityName} record ${id}`, record);
+
+    await this.simulateDelay();
+
+    const collection = this.storage.get(entityName);
+    if (!collection || !collection.has(id)) {
+      throw new Error(`Record not found: ${entityName} with ID ${id}`);
+    }
+
+    const existing = collection.get(id);
+    const updated = {
+      ...existing,
+      ...record,
+      modifiedon: new Date().toISOString(),
+    };
+
+    collection.set(id, updated);
+
+    return updated;
+  }
+
+  async deleteRecord(entityName: string, id: string): Promise<void> {
+    console.log(`MockApiService: Deleting ${entityName} record ${id}`);
+
+    await this.simulateDelay();
+
+    const collection = this.storage.get(entityName);
+    if (!collection || !collection.has(id)) {
+      throw new Error(`Record not found: ${entityName} with ID ${id}`);
+    }
+
+    collection.delete(id);
+  }
+
+  async retrieveMultipleRecords(
+    entityName: string,
+    fetchXml: string
+  ): Promise<{ entities: any[] }> {
+    console.log(
+      `MockApiService: Retrieving ${entityName} records with FetchXML`,
+      fetchXml
+    );
+
+    await this.simulateDelay();
+
+    const collection = this.storage.get(entityName);
+    if (!collection) {
+      return { entities: [] };
+    }
+
+    // Convert Map values to array
+    const entities = Array.from(collection.values());
+
+    // Simple filter parsing from FetchXML (basic implementation)
+    const filteredEntities = this.applyBasicFetchXmlFilter(entities, fetchXml);
+
+    return { entities: filteredEntities };
+  }
+
+  async executeRequest(requestName: string, requestData: any): Promise<any> {
+    console.log(
+      `MockApiService: Executing request ${requestName}`,
+      requestData
+    );
+
+    await this.simulateDelay();
+
+    // Mock implementation - return success response
+    return {
+      success: true,
+      requestName,
+      timestamp: new Date().toISOString(),
+      data: requestData,
+    };
+  }
+
+  async uploadFile(file: File): Promise<string> {
+    console.log(`MockApiService: Uploading file ${file.name}`);
+
+    await this.simulateDelay(1000); // Longer delay for file upload
+
+    // Return mock file URL
+    return `https://mock-storage.dynamics365.com/files/${this.generateId('file')}-${file.name}`;
+  }
+
+  /**
+   * Initialize mock data for development
+   */
+  private initializeMockData(): void {
+    // Create accounts collection
+    const accounts = new Map<string, any>();
+    accounts.set('00000000-0000-0000-0000-000000000001', {
+      accountid: '00000000-0000-0000-0000-000000000001',
+      name: 'Contoso Ltd',
+      emailaddress1: 'info@contoso.com',
+      telephone1: '555-0100',
+      address1_city: 'Seattle',
+      address1_stateorprovince: 'WA',
+      address1_country: 'USA',
+      revenue: 5000000,
+      numberofemployees: 250,
+      createdon: '2024-01-15T10:00:00Z',
+      modifiedon: '2024-01-15T10:00:00Z',
+    });
+    accounts.set('00000000-0000-0000-0000-000000000002', {
+      accountid: '00000000-0000-0000-0000-000000000002',
+      name: 'Adventure Works',
+      emailaddress1: 'contact@adventureworks.com',
+      telephone1: '555-0200',
+      address1_city: 'Redmond',
+      address1_stateorprovince: 'WA',
+      address1_country: 'USA',
+      revenue: 10000000,
+      numberofemployees: 500,
+      createdon: '2024-01-20T14:30:00Z',
+      modifiedon: '2024-01-20T14:30:00Z',
+    });
+    this.storage.set('accounts', accounts);
+
+    // Create contacts collection
+    const contacts = new Map<string, any>();
+    contacts.set('00000000-0000-0000-0000-000000000101', {
+      contactid: '00000000-0000-0000-0000-000000000101',
+      firstname: 'John',
+      lastname: 'Doe',
+      emailaddress1: 'john.doe@contoso.com',
+      telephone1: '555-0101',
+      parentcustomerid: '00000000-0000-0000-0000-000000000001',
+      parentcustomerid_account: {
+        accountid: '00000000-0000-0000-0000-000000000001',
+        name: 'Contoso Ltd',
+      },
+      createdon: '2024-01-16T09:00:00Z',
+      modifiedon: '2024-01-16T09:00:00Z',
+    });
+    contacts.set('00000000-0000-0000-0000-000000000102', {
+      contactid: '00000000-0000-0000-0000-000000000102',
+      firstname: 'Jane',
+      lastname: 'Smith',
+      emailaddress1: 'jane.smith@adventureworks.com',
+      telephone1: '555-0201',
+      parentcustomerid: '00000000-0000-0000-0000-000000000002',
+      parentcustomerid_account: {
+        accountid: '00000000-0000-0000-0000-000000000002',
+        name: 'Adventure Works',
+      },
+      createdon: '2024-01-21T11:00:00Z',
+      modifiedon: '2024-01-21T11:00:00Z',
+    });
+    this.storage.set('contacts', contacts);
+  }
+
+  /**
+   * Generate a mock ID for an entity
+   */
+  private generateId(entityName: string): string {
+    const timestamp = Date.now();
+    const random = Math.floor(Math.random() * 1000000);
+    return `${entityName}-${timestamp}-${random}`;
+  }
+
+  /**
+   * Get the primary key field name for an entity
+   */
+  private getPrimaryKey(entityName: string): string {
+    const primaryKeys: Record<string, string> = {
+      accounts: 'accountid',
+      contacts: 'contactid',
+      opportunities: 'opportunityid',
+      leads: 'leadid',
+      incidents: 'incidentid',
+      quotes: 'quoteid',
+      salesorders: 'salesorderid',
+      invoices: 'invoiceid',
+    };
+
+    return primaryKeys[entityName] || `${entityName.replace(/s$/, '')}id`;
+  }
+
+  /**
+   * Apply basic FetchXML filtering (simplified implementation)
+   */
+  private applyBasicFetchXmlFilter(entities: any[], fetchXml: string): any[] {
+    // Extract attribute names from FetchXML
+    const attributeMatches = fetchXml.match(/<attribute name="([^"]+)"/g);
+    if (!attributeMatches || attributeMatches.length === 0) {
+      return entities;
+    }
+
+    const attributes = attributeMatches.map((match) =>
+      match.replace('<attribute name="', '').replace('"', '')
+    );
+
+    // Filter entities to only include requested attributes
+    return entities.map((entity) => {
+      const filtered: any = {};
+      attributes.forEach((attr) => {
+        if (Object.prototype.hasOwnProperty.call(entity, attr)) {
+          filtered[attr] = entity[attr];
+        }
+      });
+      return filtered;
+    });
+  }
+
+  /**
+   * Simulate network delay for realistic behavior
+   */
+  private async simulateDelay(ms: number = 200): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}