shareneus 1.7.4 → 1.7.6

package/src/inventory/items/item-price-for-pricelist.ts

@@ -0,0 +1,368 @@
+import { CalcDiscPrice, GetMarginValue } from "../../shared/math-operations";
+import { IsNotNull, IsNull } from "../../shared/util";
+
+export function GetItemPriceForPriceList(
+  item: any,
+  priceList: any,
+  includeMargin: boolean = false,
+  quantity: number = 1,
+  pricingContext: any = {}
+): any {
+  if (!priceList) {
+    return item;
+  }
+
+  const resolvedQty = Math.max(1, Number(quantity) || 1);
+  const calcDisc: any = priceList.CalcDisc ?? {};
+  const markUp: boolean = calcDisc.Mark ?? false;
+  const priceListId = priceList?._id?.toString?.();
+
+  let salePricesByPriceListId: any[] = [];
+
+  if (priceListId && IsNotNull(item.SalePrices) && item.SalePrices.length > 0) {
+    salePricesByPriceListId = item.SalePrices.filter(
+      (price: any) => price?.PrListId && price.PrListId.toString() === priceListId
+    );
+  }
+
+  item.PriceTiers = priceList?.QtyTiers ?? undefined;
+  item.AppliedPriceTier = undefined;
+
+  if (salePricesByPriceListId.length > 0) {
+    item.SalePrices = salePricesByPriceListId;
+    const activeSalePrice = salePricesByPriceListId[0];
+    const activeTierList = activeSalePrice?.QtyTiers ?? priceList?.QtyTiers;
+    if (activeTierList) {
+      item.PriceTiers = activeTierList;
+    }
+
+    if (item.Track === "TR" || item.Track === "SN") {
+      item.Sale["MRP"] = item.Sale.Price;
+      const tier = ResolveTier(resolvedQty, activeSalePrice?.QtyTiers);
+
+      if (tier) {
+        const baseForTier = IsNotNull(activeSalePrice.Price) ? activeSalePrice.Price : item.Sale.Price;
+        item.Sale.Price = ApplyTierAdjustment(baseForTier, tier, priceList, false);
+        item.AppliedPriceTier = BuildAppliedTierMeta("ITEM", tier);
+      } else if (IsNotNull(activeSalePrice.Price) && IsNotNull(activeSalePrice.Disc)) {
+        item.Sale.Price = CalcItemFinalSalePrice(activeSalePrice.Price, activeSalePrice.Disc, priceList, markUp);
+      } else if (IsNotNull(activeSalePrice.Price) && IsNull(activeSalePrice.Disc)) {
+        item.Sale.Price = ApplyRounding(activeSalePrice.Price, priceList);
+      } else if (IsNull(activeSalePrice.Price) && IsNotNull(activeSalePrice.Disc)) {
+        item.Sale.Price = CalcItemFinalSalePrice(item.Sale.Price, activeSalePrice.Disc, priceList, markUp);
+      }
+
+      if (includeMargin && IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+        item.Margin = GetMarginValue(item.Sale.Price, item.Pur.Cost);
+      }
+    } else if (item.Track === "BN" && Array.isArray(item.Batches)) {
+      for (const element of item.Batches) {
+        const batchSalePrice = item.SalePrices.filter(
+          (batch: any) =>
+            priceListId === batch?.PrListId?.toString() &&
+            (element.BN === batch.BN || batch.BN == null)
+        );
+
+        const activeBatchSale = batchSalePrice.length > 0 ? batchSalePrice[0] : undefined;
+        const tierList =
+          activeBatchSale?.QtyTiers ?? activeSalePrice?.QtyTiers ?? priceList?.QtyTiers;
+        if (tierList) {
+          element.PriceTiers = tierList;
+        }
+
+        element.MRP = element.Price;
+
+        const tier = ResolveTier(resolvedQty, activeBatchSale?.QtyTiers ?? activeSalePrice?.QtyTiers);
+
+        if (tier) {
+          const baseForTier = IsNotNull(activeBatchSale?.Price) ? activeBatchSale.Price : element.Price;
+          element.Price = ApplyTierAdjustment(baseForTier, tier, priceList, false);
+          element.AppliedPriceTier = BuildAppliedTierMeta("ITEM", tier);
+        } else if (activeBatchSale) {
+          if (IsNotNull(activeBatchSale.Price) && IsNotNull(activeBatchSale.Disc)) {
+            element.Price = CalcItemFinalSalePrice(activeBatchSale.Price, activeBatchSale.Disc, priceList, markUp);
+          } else if (IsNotNull(activeBatchSale.Price) && IsNull(activeBatchSale.Disc)) {
+            element.Price = ApplyRounding(activeBatchSale.Price, priceList);
+          } else if (IsNull(activeBatchSale.Price) && IsNotNull(activeBatchSale.Disc)) {
+            element.Price = CalcItemFinalSalePrice(element.Price, activeBatchSale.Disc, priceList, markUp);
+          }
+        }
+
+        if (includeMargin && IsNotNull(element.Cost)) {
+          element.Margin = GetMarginValue(element.Price, element.Cost);
+        }
+      }
+    }
+
+    return item;
+  }
+
+  return CalculatePriceBasedOnPriceList(item, priceList, includeMargin, resolvedQty);
+}
+
+/**
+ * Calculates the final sale price of an item after applying a discount and optional markup.
+ * Optionally includes margin calculation based on cost.
+ *
+ * @param price - The original price of the item.
+ * @param disc - The discount percentage to apply.
+ * @param priceList - The price list object containing rounding and other configurations.
+ * @param markup - Whether to apply markup instead of discount (default is false).
+ * @param includeMargin - Whether to include margin calculation in the result (default is false).
+ * @param cost - The cost of the item, used for margin calculation (default is 0).
+ * @returns The final price or an object containing margin and final price if includeMargin is true.
+ */
+export function CalcItemFinalSalePrice(
+  price: number,
+  disc: number,
+  priceList: any,
+  markup: boolean = false,
+  includeMargin: boolean = false,
+  cost: number = 0
+): any {
+  const calculatedPrice = CalcDiscPrice(price, disc, markup);
+  const finalPrice = ApplyRounding(calculatedPrice, priceList);
+
+  if (includeMargin) {
+    const margin = GetMarginValue(finalPrice, cost);
+    return { margin: margin, finalPrice: finalPrice };
+  }
+
+  return finalPrice;
+}
+
+function CalculatePriceBasedOnPriceList(
+  item: any,
+  priceList: any,
+  includeMargin: boolean,
+  quantity: number
+): any {
+  if (!priceList) {
+    return item;
+  }
+
+  const calcDisc: any = priceList.CalcDisc ?? {};
+  const markUp: boolean = calcDisc.Mark ?? false;
+  const resolvedQty = Math.max(1, Number(quantity) || 1);
+  const tier = ResolveTier(resolvedQty, priceList.QtyTiers);
+
+  if (tier) {
+    item.PriceTiers = priceList.QtyTiers ?? undefined;
+
+    if (item.Track === "TR" || item.Track === "SN") {
+      item.Sale["MRP"] = item.Sale.Price;
+      const basePrice = DetermineBasePriceForTier(item, priceList);
+      item.Sale.Price = ApplyTierAdjustment(basePrice, tier, priceList, markUp);
+      item.AppliedPriceTier = BuildAppliedTierMeta("PRICELIST", tier);
+
+      if (includeMargin && IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+        item.Margin = GetMarginValue(item.Sale.Price, item.Pur.Cost);
+      }
+    } else if (item.Track === "BN" && Array.isArray(item.Batches)) {
+      for (const batch of item.Batches) {
+        batch.MRP = batch.Price;
+        const basePrice = DetermineBatchBasePriceForTier(batch, item, priceList);
+        batch.Price = ApplyTierAdjustment(basePrice, tier, priceList, markUp);
+        batch.AppliedPriceTier = BuildAppliedTierMeta("PRICELIST", tier);
+
+        if (includeMargin && IsNotNull(batch.Cost)) {
+          batch.Margin = GetMarginValue(batch.Price, batch.Cost);
+        }
+      }
+    }
+
+    return item;
+  }
+
+  if (priceList.PrCalc === "FIXED") {
+    if (priceList.Fixed && IsNotNull(priceList.Fixed.Price)) {
+      const fixedPrice = priceList.Fixed.Price;
+      const fixedDisc = priceList.Fixed.Disc || 0;
+
+      if (item.Track === "TR" || item.Track === "SN") {
+        item.Sale["MRP"] = item.Sale.Price;
+        if (IsNotNull(fixedDisc) && fixedDisc > 0) {
+          item.Sale.Price = CalcItemFinalSalePrice(fixedPrice, fixedDisc, priceList);
+        } else {
+          item.Sale.Price = ApplyRounding(fixedPrice, priceList);
+        }
+
+        if (includeMargin && IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+          item.Margin = GetMarginValue(item.Sale.Price, item.Pur.Cost);
+        }
+      } else if (item.Track === "BN" && Array.isArray(item.Batches)) {
+        for (const batch of item.Batches) {
+          batch.MRP = batch.Price;
+          if (IsNotNull(fixedDisc) && fixedDisc > 0) {
+            batch.Price = CalcItemFinalSalePrice(fixedPrice, fixedDisc, priceList);
+          } else {
+            batch.Price = ApplyRounding(fixedPrice, priceList);
+          }
+          if (includeMargin && IsNotNull(batch.Cost)) {
+            batch.Margin = GetMarginValue(batch.Price, batch.Cost);
+          }
+        }
+      }
+    }
+  } else if (priceList.PrCalc === "DISC") {
+    const discPerc: number = calcDisc.Perc || 0;
+
+    if (priceList.BasedOn === "SP") {
+      if (item.Track === "TR" || item.Track === "SN") {
+        item.Sale["MRP"] = item.Sale.Price;
+        item.Sale.Price = CalcItemFinalSalePrice(item.Sale.Price, discPerc, priceList, markUp);
+
+        if (includeMargin && IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+          item.Margin = GetMarginValue(item.Sale.Price, item.Pur.Cost);
+        }
+      } else if (item.Track === "BN" && Array.isArray(item.Batches)) {
+        for (const batch of item.Batches) {
+          batch.MRP = batch.Price;
+          batch.Price = CalcItemFinalSalePrice(batch.Price, discPerc, priceList, markUp);
+
+          if (includeMargin && IsNotNull(batch.Cost)) {
+            batch.Margin = GetMarginValue(batch.Price, batch.Cost);
+          }
+        }
+      }
+    } else if (priceList.BasedOn === "PC") {
+      if (item.Track === "TR" || item.Track === "SN") {
+        item.Sale["MRP"] = item.Sale.Price;
+        if (IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+          item.Sale.Price = CalcItemFinalSalePrice(item.Pur.Cost, discPerc, priceList, markUp);
+
+          if (includeMargin) {
+            item.Margin = GetMarginValue(item.Sale.Price, item.Pur.Cost);
+          }
+        }
+      } else if (item.Track === "BN" && Array.isArray(item.Batches)) {
+        for (const batch of item.Batches) {
+          batch.MRP = batch.Price;
+          if (IsNotNull(batch.Cost)) {
+            batch.Price = CalcItemFinalSalePrice(batch.Cost, discPerc, priceList, markUp);
+
+            if (includeMargin) {
+              batch.Margin = GetMarginValue(batch.Price, batch.Cost);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return item;
+}
+
+function ApplyRounding(price: number, priceList: any): number {
+  if (!priceList || !priceList.Round) return price;
+
+  switch (priceList.Round) {
+    case "-1":
+      return price;
+    case "0":
+      return Math.round(price);
+    case "0.99":
+      return Math.floor(price) + 0.99;
+    case "0.50":
+      return Math.round(price * 2) / 2;
+    case "0.49":
+      return Math.floor(price) + 0.49;
+    case "Dec":
+      if (IsNotNull(priceList.Deci)) {
+        const factor = Math.pow(10, priceList.Deci);
+        return Math.round(price * factor) / factor;
+      }
+      return price;
+    default:
+      return price;
+  }
+}
+
+function ResolveTier(quantity: number, tiers: any[] | undefined): any | null {
+  if (!Array.isArray(tiers) || tiers.length === 0) {
+    return null;
+  }
+
+  const sorted = [...tiers]
+    .filter((tier: any) => IsNotNull(tier) && IsNotNull(tier.MinQty))
+    .sort((a: any, b: any) => a.MinQty - b.MinQty);
+
+  let selected: any | null = null;
+
+  for (const tier of sorted) {
+    if (quantity >= tier.MinQty) {
+      selected = tier;
+    } else {
+      break;
+    }
+  }
+
+  return selected;
+}
+
+function ApplyTierAdjustment(
+  basePrice: number,
+  tier: any,
+  priceList: any,
+  markUp: boolean
+): number {
+  if (IsNotNull(tier?.Price)) {
+    return ApplyRounding(tier.Price, priceList);
+  }
+
+  if (IsNotNull(tier?.Disc)) {
+    const targetBase = IsNotNull(basePrice) ? basePrice : 0;
+    return CalcItemFinalSalePrice(targetBase, tier.Disc, priceList, markUp);
+  }
+
+  return ApplyRounding(basePrice, priceList);
+}
+
+function BuildAppliedTierMeta(source: "ITEM" | "PRICELIST", tier: any) {
+  if (!tier) {
+    return undefined;
+  }
+
+  return {
+    Source: source,
+    MinQty: IsNotNull(tier.MinQty) ? tier.MinQty : null,
+    Price: IsNotNull(tier.Price) ? tier.Price : null,
+    Disc: IsNotNull(tier.Disc) ? tier.Disc : null,
+  };
+}
+
+function DetermineBasePriceForTier(item: any, priceList: any): number {
+  if (priceList.PrCalc === "FIXED") {
+    if (IsNotNull(priceList.Fixed?.Price)) {
+      return priceList.Fixed.Price;
+    }
+    return item.Sale.Price;
+  }
+
+  if (priceList.PrCalc === "DISC") {
+    if (priceList.BasedOn === "PC" && IsNotNull(item.Pur) && IsNotNull(item.Pur.Cost)) {
+      return item.Pur.Cost;
+    }
+    return item.Sale.Price;
+  }
+
+  return item.Sale.Price;
+}
+
+function DetermineBatchBasePriceForTier(batch: any, item: any, priceList: any): number {
+  if (priceList.PrCalc === "FIXED") {
+    if (IsNotNull(priceList.Fixed?.Price)) {
+      return priceList.Fixed.Price;
+    }
+    return batch.Price;
+  }
+
+  if (priceList.PrCalc === "DISC") {
+    if (priceList.BasedOn === "PC" && IsNotNull(batch.Cost)) {
+      return batch.Cost;
+    }
+    return batch.Price;
+  }
+
+  return batch.Price;
+}

package/src/inventory/items/reports/excel/expiring-drugs-excel.service.ts

@@ -0,0 +1,290 @@
+import * as XLSX from 'xlsx';
+import { MyDate } from '../../../../utils/my-date';
+import { TrUtils } from '../../../../utils/tr-utils';
+import { Multiply } from '../../../../shared/math-operations';
+
+export class ExpiringDrugsXlsxFileService {
+  static wb: any = {};
+  static Row: any = 2;
+  static MergeArray: any[] = [];
+  static range = { s: { c: 0, r: 0 }, e: { c: 0, r: 0 } };
+  static ws: any = {};
+
+  static GetExpiringDrugsExcelData(MainData: any, isSale: boolean, searchValue: any, HeaderName: any, EntitySettings: any) {
+    this.wb = {};
+    this.ws = {};
+    this.Row = 0;
+    this.range = { s: { c: 0, r: 0 }, e: { c: 0, r: 0 } };
+    this.MergeArray = [];
+    let ws_name = HeaderName;
+    this.wb.Sheets = {};
+    this.wb.Props = {};
+    this.wb.SSF = {};
+    this.wb.SheetNames = [];
+
+    // MainData = this.GetTotals(MainData);
+    let showSearch: any = [];
+    for (const key in searchValue) {
+      if (!TrUtils.IsNull(searchValue[key]) && key !== 'Date' && key !== 'CustCntrlId') {
+        showSearch.push([{
+          text: (key === 'StDate') ? 'Start Date' : (key === 'EnDate') ? 'End Date' : (key === 'CustCntrl') ? isSale ? 'Customer' : 'Vendor' : key,
+          ColRange: 1,
+          bold: true,
+          ChildHeadings: [
+            // { text: 'Central Tax', ColRange: 1 },
+            // { text: 'State Tax', ColRange: 1 },
+            // { text: 'IGST Tax', ColRange: 1 },
+          ],
+        }, {
+          text: (key === 'StDate') ? MyDate.ConvertUTCDateToReadable(searchValue[key]) : (key === 'EnDate') ? MyDate.ConvertUTCDateToReadable(searchValue[key]) : searchValue[key],
+          ColRange: 7,
+          bold: true,
+          ChildHeadings: [
+            // { text: 'Central Tax', ColRange: 1 },
+            // { text: 'State Tax', ColRange: 1 },
+            // { text: 'IGST Tax', ColRange: 1 },
+          ],
+        }]);
+      }
+
+      // console.log(`${key}: ${searchValue[key]}`);
+    }
+
+    this.setHeadingInCell(HeaderName, showSearch);
+
+    this.setInvoiceDetailsInCell(MainData, isSale, EntitySettings.DecimalsNumber);
+
+    this.ws['!ref'] = XLSX.utils.encode_range(this.range);
+
+    this.ws['!merges'] = this.MergeArray;
+    this.ws["!cols"] = [{ wch: 50 }, { wch: 10 }, { wch: 15 }, { wch: 15 }, { wch: 15 }, { wch: 15 }, { wch: 15 }, { wch: 15 }];
+
+    this.wb.SheetNames.push(ws_name);
+
+    this.wb.Sheets[ws_name] = this.ws;
+
+    return this.wb;
+  }
+
+  static setHeadingInCell(HeaderName: any, showSearch: any) {
+
+    let MainHeadings: any[] = [
+      // {
+      //     text: 'SNo',
+      //     ColRange: 1,
+      //     bold: true,
+      //     ChildHeadings: []
+      // },
+      {
+        text: 'Name',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [],
+      },
+      //   {
+      //     text: 'Location',
+      //     ColRange: 1,
+      //     bold: true,
+      //     ChildHeadings: [
+      //       // { text: 'No', ColRange: 1 },
+      //       // { text: 'Date', ColRange: 1 },
+      //       // { text: 'Invoice Total', ColRange: 1 }
+      //     ],
+      //   },
+
+      {
+        text: 'Batch No',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [
+          // { text: 'Central Tax', ColRange: 1 },
+          // { text: 'State Tax', ColRange: 1 },
+          // { text: 'IGST Tax', ColRange: 1 },
+        ],
+      },
+      {
+        text: 'Exp Date',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [
+          // { text: 'Central Tax', ColRange: 1 },
+          // { text: 'State Tax', ColRange: 1 },
+          // { text: 'IGST Tax', ColRange: 1 },
+        ],
+      },
+      {
+        text: 'Qty',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [
+          // { text: 'Central Tax', ColRange: 1 },
+          // { text: 'State Tax', ColRange: 1 },
+          // { text: 'IGST Tax', ColRange: 1 },
+        ],
+      },
+      {
+        text: 'Rate',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [
+          // { text: 'Central Tax', ColRange: 1 },
+          // { text: 'State Tax', ColRange: 1 },
+          // { text: 'IGST Tax', ColRange: 1 },
+        ],
+      },
+      {
+        text: 'Value',
+        ColRange: 1,
+        bold: true,
+        ChildHeadings: [
+          // { text: 'Central Tax', ColRange: 1 },
+          // { text: 'State Tax', ColRange: 1 },
+          // { text: 'IGST Tax', ColRange: 1 },
+        ],
+      },
+
+
+    ];
+
+    this.SetDataInCell(HeaderName, 0, this.Row);
+    this.MergeArray.push({
+      s: { r: this.Row, c: 0 },
+      e: { r: this.Row, c: 0 + 8 - 1 },
+    });
+    this.Row += 2;
+    // console.log('showSearch', showSearch);
+    showSearch.forEach((search: any) => {
+      let ColStart: any = 0;
+      // console.log('search', search, ColStart);
+      search.forEach((item: any) => {
+        // console.log('text', oyo.text, ColStart);
+        this.SetDataInCell(item.text, ColStart, this.Row);
+        this.MergeArray.push({
+          s: { r: this.Row, c: ColStart },
+          e: { r: this.Row, c: ColStart + item.ColRange - 1 },
+        });
+        ColStart += item.ColRange;
+      });
+      this.Row += 1;
+    });
+    this.Row += 1;
+    let MainColStart: any = 0;
+    MainHeadings.forEach((MainHeader: any) => {
+      this.SetDataInCell(MainHeader.text, MainColStart, this.Row);
+      this.MergeArray.push({
+        s: { r: this.Row, c: MainColStart },
+        e: { r: this.Row, c: MainColStart + MainHeader.ColRange - 1 },
+      });
+      MainColStart += MainHeader.ColRange;
+    });
+
+    this.Row += 2;
+  }
+
+  static setInvoiceDetailsInCell(MainData: any, isSale: boolean, DecimalsNumber: number) {
+    MainData.forEach((InvoiceList: any) => {
+      this.SetInvoiceDataInExcel(InvoiceList, isSale, DecimalsNumber);
+    });
+  }
+
+  static SetInvoiceDataInExcel(InvoiceInfo: any, isSale: boolean, DecimalsNumber: number) {
+    InvoiceInfo.CrDate = this.ConvertDateToReadableFormat(InvoiceInfo.CrDate);
+
+    let InvoiceData: any = [
+      { text: InvoiceInfo.Name, ColRange: 1, IsString: true },
+      { text: InvoiceInfo.Batch.BN, ColRange: 1, IsString: true },
+      { text: MyDate.ConvertUTCDateToReadableExDateTxt(InvoiceInfo.Batch.ExDt), ColRange: 1, IsString: true },
+      { text: InvoiceInfo.Batch.Qty, ColRange: 1, IsString: true },
+      { text: TrUtils.FixPriceValue(InvoiceInfo.Batch.Cost, DecimalsNumber), ColRange: 1, IsString: true },
+      { text: TrUtils.FixPriceValue(Multiply(InvoiceInfo.Batch.Qty, InvoiceInfo.Batch.Cost), DecimalsNumber), ColRange: 1, IsString: true },
+      //   { text: InvoiceInfo.Round, ColRange: 1, IsString: true },
+      //   { text: InvoiceInfo.Total, ColRange: 1, IsString: false }
+    ];
+    let ColStart: any = 0;
+    InvoiceData.forEach((InvData: any) => {
+      InvData.text = this.ConvertToString(InvData.text, InvData.IsString, DecimalsNumber);
+      this.SetDataInCell(InvData.text, ColStart, this.Row);
+      this.MergeArray.push({
+        s: { r: this.Row, c: ColStart },
+        e: { r: this.Row, c: ColStart + InvData.ColRange - 1 },
+      });
+      ColStart += InvData.ColRange;
+    });
+
+    this.Row += 1;
+  }
+
+  static ConvertToString(Text: any, IsString: any, DecimalsNumber: number) {
+    if (IsString) {
+      if (Text == null) {
+        Text = '';
+      }
+    } else {
+      if (Text == null) {
+        Text = 0;
+      }
+    }
+    if (typeof Text === 'number') {
+      return Number(TrUtils.FixedTo(Text, DecimalsNumber));
+    } else {
+      return Text;
+    }
+  }
+
+  static SetDataInCell(Data: any, ColRange: number, RowNum: any) {
+    // console.log(ColRange, RowNum);
+    var cell = { v: Data, bold: true };
+    var cell_ref = XLSX.utils.encode_cell({ c: ColRange, r: RowNum });
+    if (this.range.e.c < ColRange) {
+      this.range.e.c = ColRange;
+    }
+    if (this.range.e.r < RowNum) {
+      this.range.e.r = RowNum;
+    }
+    cell = this.getcelltype(cell);
+    this.ws[cell_ref] = cell;
+  }
+
+  static getcelltype(cell: any) {
+    if (typeof cell.v === 'number') cell.t = 'n';
+    else if (typeof cell.v === 'boolean') cell.t = 'b';
+    else cell.t = 's';
+    return cell;
+  }
+
+  static ConvertDateToReadableFormat(DateObject: any) {
+    if (!TrUtils.IsEmpty(DateObject)) {
+      let date: any = new Date(DateObject);
+      let Month: any;
+      let Day: any;
+
+      let MonthName = new Array();
+      MonthName[0] = 'Jan';
+      MonthName[1] = 'Feb';
+      MonthName[2] = 'Mar';
+      MonthName[3] = 'Apr';
+      MonthName[4] = 'May';
+      MonthName[5] = 'Jun';
+      MonthName[6] = 'Jul';
+      MonthName[7] = 'Aug';
+      MonthName[8] = 'Sept';
+      MonthName[9] = 'Oct';
+      MonthName[10] = 'Nov';
+      MonthName[11] = 'Dec';
+
+      Month = MonthName[date.getMonth()];
+
+      if (date.getDate() < 10) {
+        Day = '0' + date.getDate();
+      } else {
+        Day = date.getDate();
+      }
+
+      date = Day + '-' + Month + '-' + date.getFullYear();
+      return date;
+    } else {
+      return null;
+    }
+  }
+
+}