TechGears Ltd. - Complete Salesforce Implementation

The Problem I Solved:

If Sales Rep A sells 50 units, and Sales Rep B sells 60 units five minutes later, you've sold 110 units when you only have 100. This leads to backorders, shipping delays, and angry customers. My trigger prevents this by checking stock in real-time and blocking orders that would exceed inventory.

Trigger Code:

trigger ProductStockUpdate on TechGear_Orders__c (after insert) {

   // Set to store the IDs of products that need updating
   Set<Id> productIds = new Set<Id>();

   // 1. Collect all Product IDs from the incoming orders
   for (TechGear_Orders__c order : Trigger.new) {
       if (order.TechGear_Product__c != null) {
           productIds.add(order.TechGear_Product__c);
       }
   }

   // 2. Query the Product records
   Map<Id, TechGear_Products__c> productsMap = new Map<Id, TechGear_Products__c>(
       [SELECT Id, Stock_Quantity__c, Name
        FROM TechGear_Products__c
        WHERE Id IN :productIds]
   );

   // List to hold products that need to be updated
   List<TechGear_Products__c> productsToUpdate = new List<TechGear_Products__c>();

   // 3. Loop through the orders to calculate new stock levels
   for (TechGear_Orders__c order : Trigger.new) {
       if (order.TechGear_Product__c != null &&
           productsMap.containsKey(order.TechGear_Product__c)) {

           TechGear_Products__c product = productsMap.get(order.TechGear_Product__c);

           // Check if we have enough stock BEFORE deducting
           if (product.Stock_Quantity__c >= order.Quantity__c) {
               product.Stock_Quantity__c -= order.Quantity__c;
               productsToUpdate.add(product);
           } else {
               // Add error if stock is insufficient
               order.addError('Insufficient stock for product: ' + product.Name +
                              '. Available: ' + product.Stock_Quantity__c +
                              ', Requested: ' + order.Quantity__c);
           }
       }
   }

   // 4. Update the products in Salesforce
   if (!productsToUpdate.isEmpty()) {
       update productsToUpdate;
   }
}

Handler Class Code:

public class OpportunityTriggerHandler {

   // Method to handle stage changes
   public static void handleStageChange(List<Opportunity> newOpps,
                                       Map<Id, Opportunity> oldOppsMap) {

       // List to hold the new tasks we want to create
       List<Task> tasksToCreate = new List<Task>();

       // Loop through the opportunities that triggered the update
       for (Opportunity opp : newOpps) {

           // Retrieve the old version of the Opportunity using the ID
           Opportunity oldOpp = oldOppsMap.get(opp.Id);

           // Condition: Check if the StageName has changed
           if (opp.StageName != oldOpp.StageName) {

               // Create a new Task record in memory
               Task newTask = new Task();
               newTask.Subject = 'Follow up on stage change to ' + opp.StageName;
               newTask.Description = 'Contact customer if necessary.';
               newTask.WhatId = opp.Id; // Link task to the Opportunity
               newTask.OwnerId = opp.OwnerId; // Assign to Opportunity Owner
               newTask.ActivityDate = System.today().addDays(1); // Due tomorrow
               newTask.Status = 'Not Started';
               newTask.Priority = 'Normal';

               // Add to our list
               tasksToCreate.add(newTask);
           }
       }

       // DML Statement: Insert the tasks only if list is not empty
       if (!tasksToCreate.isEmpty()) {
           try {
               insert tasksToCreate;
           } catch (DmlException e) {
               System.debug('Error creating tasks: ' + e.getMessage());
           }
       }
   }
}

Apex Class Code:

public class ServiceReportGenerator {

   @InvocableMethod(label='Generate Service Report'
                    description='Creates a service report file for closed cases')
   public static void generateReports(List<Id> caseIds) {
       List<ContentVersion> reportsToCreate = new List<ContentVersion>();

       // Query Case details based on TechGears requirements
       List<Case> cases = [SELECT CaseNumber, Subject, Description, Status,
                                  Resolution_Date__c, Support_Agent__c,
                                  TechGear_Product__r.Name, Account.Name
                           FROM Case
                           WHERE Id IN :caseIds];

       for (Case c : cases) {
           String reportContent = createReportTemplate(c);

           // Prepare the File (ContentVersion)
           ContentVersion cv = new ContentVersion();
           cv.Title = 'Service_Report_' + c.CaseNumber;
           cv.PathOnClient = 'Service_Report_' + c.CaseNumber + '.txt';
           cv.VersionData = Blob.valueOf(reportContent);
           cv.FirstPublishLocationId = c.Id; // Automatically links to Case
           reportsToCreate.add(cv);
       }

       if (!reportsToCreate.isEmpty()) {
           insert reportsToCreate;
       }
   }

   private static String createReportTemplate(Case c) {
       return '--------------------------------------------------\n' +
              'TECHGEARS LTD. - SERVICE REPORT\n' +
              '--------------------------------------------------\n' +
              'Case Number: ' + c.CaseNumber + '\n' +
              'Account: ' + c.Account.Name + '\n' +
              'Subject: ' + c.Subject + '\n' +
              '--------------------------------------------------\n' +
              'SERVICE DETAILS\n' +
              'Product: ' + (c.TechGear_Product__r.Name != null ?
                            c.TechGear_Product__r.Name : 'General Inquiry') + '\n' +
              'Support Agent: ' + c.Support_Agent__c + '\n' +
              'Resolution Date: ' + c.Resolution_Date__c + '\n' +
              '--------------------------------------------------\n' +
              'ISSUE DESCRIPTION:\n' + c.Description + '\n' +
              '--------------------------------------------------\n' +
              'Internal Use Only - TechGears Ltd. Proprietary';
   }
}

JavaScript Controller Code:

import { LightningElement, wire, api } from 'lwc';
import getAvailableProducts from '@salesforce/apex/ProductController.getAvailableProducts';
import addProductToOpportunity from '@salesforce/apex/ProductController.addProductToOpportunity';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';

export default class ProductCatalog extends LightningElement {
   @api recordId; // Gets the Opportunity ID automatically
   products;
   error;

   @wire(getAvailableProducts)
   wiredProducts({ error, data }) {
       if (data) {
           this.products = data;
       } else if (error) {
           this.error = error;
       }
   }

   handleAddToOpp(event) {
       const productId = event.target.dataset.id;

       addProductToOpportunity({
           productId: productId,
           opportunityId: this.recordId
       })
           .then(() => {
               this.dispatchEvent(
                   new ShowToastEvent({
                       title: 'Success',
                       message: 'Product added to opportunity',
                       variant: 'success'
                   })
               );
           })
           .catch(error => {
               let message = 'Unknown error';
               if (Array.isArray(error.body)) {
                   message = error.body.map(e => e.message).join(', ');
               } else if (typeof error.body.message === 'string') {
                   message = error.body.message;
               }

               this.dispatchEvent(
                   new ShowToastEvent({
                       title: 'Error Creating Order',
                       message: message,
                       variant: 'error',
                       mode: 'sticky'
                   })
               );
           });
   }
}

JavaScript Controller Code:

import { LightningElement, track, wire } from 'lwc';
import getCasesByPriority from '@salesforce/apex/CaseController.getCasesByPriority';
import { updateRecord } from 'lightning/uiRecordApi';
import { refreshApex } from '@salesforce/apex';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';

// Columns including custom TechGears fields
const COLUMNS = [
   { label: 'Case Number', fieldName: 'CaseNumber', type: 'text' },
   { label: 'Subject', fieldName: 'Subject', type: 'text' },
   { label: 'Status', fieldName: 'Status', type: 'text', editable: true },
   { label: 'Priority', fieldName: 'Priority', type: 'text', editable: true },
   { label: 'Resolution Date', fieldName: 'Resolution_Date__c',
     type: 'date', editable: true }
];

export default class CaseDashboard extends LightningElement {
   @track cases;
   @track priorityValue = 'All';
   columns = COLUMNS;
   draftValues = [];
   wiredCasesResult;

   priorityOptions = [
       { label: 'All', value: 'All' },
       { label: 'High', value: 'High' },
       { label: 'Medium', value: 'Medium' },
       { label: 'Low', value: 'Low' }
   ];

   @wire(getCasesByPriority, { priority: '$priorityValue' })
   wiredCases(result) {
       this.wiredCasesResult = result;
       if (result.data) {
           this.cases = result.data;
       }
   }

   handleFilterChange(event) {
       this.priorityValue = event.detail.value;
   }

   // Handles mass updates for efficiency
   async handleSave(event) {
       const recordInputs = event.detail.draftValues.slice().map(draft => {
           const fields = Object.assign({}, draft);
           return { fields };
       });

       const promises = recordInputs.map(recordInput =>
           updateRecord(recordInput)
       );

       try {
           await Promise.all(promises);
           this.dispatchEvent(new ShowToastEvent({
               title: 'Success',
               message: 'Cases updated successfully',
               variant: 'success'
           }));
           this.draftValues = [];
           return refreshApex(this.wiredCasesResult);
       } catch (error) {
           this.dispatchEvent(new ShowToastEvent({
               title: 'Error updating cases',
               message: error.body.message,
               variant: 'error'
           }));
       }
   }
}

JavaScript Controller Code:

import { LightningElement, wire, track } from 'lwc';
import getRecentOpportunities from '@salesforce/apex/OpportunityTrackerController.getRecentOpportunities';

export default class SalesOpportunityTracker extends LightningElement {
   @track opportunities;

   // Mapping Stages to percentages for the visual tracker
   stageMapping = {
       'Prospecting': 10,
       'Qualification': 25,
       'Needs Analysis': 40,
       'Value Proposition': 55,
       'Id. Decision Makers': 70,
       'Perception Analysis': 80,
       'Proposal/Price Quote': 90,
       'Negotiation/Review': 95
   };

   @wire(getRecentOpportunities)
   wiredOpps({ error, data }) {
       if (data) {
           // Add a progressValue property to each record for the UI
           this.opportunities = data.map(opp => {
               return {
                   ...opp,
                   progressValue: this.stageMapping[opp.StageName] || 0
               };
           });
       } else if (error) {
           console.error(error);
       }
   }
}