@churchapps/apphelper 0.0.1

package/src/helpers/ApiHelper.ts

@@ -0,0 +1,125 @@
+import { ApiConfig, RolePermissionInterface, ApiListType } from "../interfaces";
+import { ErrorHelper } from "./ErrorHelper";
+
+export class ApiHelper {
+
+  static apiConfigs: ApiConfig[] = [];
+  static isAuthenticated = false;
+
+  static getConfig(keyName: string) {
+    let result: ApiConfig;
+    this.apiConfigs.forEach(config => { if (config.keyName === keyName) result = config });
+    //if (result === null) throw new Error("Unconfigured API: " + keyName);
+    return result;
+  }
+
+  static setDefaultPermissions(jwt: string) {
+    this.apiConfigs.forEach(config => {
+      config.jwt = jwt;
+      config.permisssions = [];
+    });
+    this.isAuthenticated = true;
+  }
+
+  static setPermissions(keyName: string, jwt: string, permissions: RolePermissionInterface[]) {
+    this.apiConfigs.forEach(config => {
+      if (config.keyName === keyName) {
+        config.jwt = jwt;
+        config.permisssions = permissions;
+      }
+    });
+    this.isAuthenticated = true;
+  }
+
+  static clearPermissions() {
+    this.apiConfigs.forEach(config => { config.jwt = ""; config.permisssions = []; });
+    this.isAuthenticated = false;
+  }
+
+  static async get(path: string, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = { method: "GET", headers: { Authorization: "Bearer " + config.jwt } };
+    return await this.fetchWithErrorHandling(config.url + path, requestOptions);
+  }
+
+  static async getAnonymous(path: string, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = { method: "GET" };
+    return await this.fetchWithErrorHandling(config.url + path, requestOptions);
+  }
+
+  static async post(path: string, data: any[] | {}, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = {
+      method: "POST",
+      headers: { Authorization: "Bearer " + config.jwt, "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    };
+    return await this.fetchWithErrorHandling(config.url + path, requestOptions);
+  }
+
+  static async patch(path: string, data: any[] | {}, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = {
+      method: "PATCH",
+      headers: { Authorization: "Bearer " + config.jwt, "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    };
+    return await this.fetchWithErrorHandling(config.url + path, requestOptions);
+  }
+
+  static async delete(path: string, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = {
+      method: "DELETE",
+      headers: { Authorization: "Bearer " + config.jwt }
+    };
+    try {
+      const response = await fetch(config.url + path, requestOptions);
+      if (!response.ok) await this.throwApiError(response);
+    } catch (e) {
+      console.log(e)
+      throw (e);
+    }
+  }
+
+  static async postAnonymous(path: string, data: any[] | {}, apiName: ApiListType) {
+    const config = this.getConfig(apiName);
+    const requestOptions = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    };
+    console.log(config.url + path, requestOptions);
+    return await this.fetchWithErrorHandling(config.url + path, requestOptions);
+  }
+
+  static async fetchWithErrorHandling(url: string, requestOptions: any) {
+    try {
+      const response = await fetch(url, requestOptions);
+      if (!response.ok) await this.throwApiError(response);
+      else {
+        if (response.status !== 204 ) {
+          return response.json();
+        }
+      }
+    } catch (e) {
+      console.log("Error loading url: " + url);
+      console.log(e)
+      throw (e);
+    }
+  }
+
+  private static async throwApiError(response: Response) {
+    console.log("THROW API ERROR");
+    let msg = response.statusText;
+    try {
+      const json = await response.json();
+      msg = json.errors[0];
+    } catch { }
+    console.log("RESPONSE", response)
+    ErrorHelper.logError(response.status.toString(), response.url, msg);
+    throw new Error(msg || "Error");
+  }
+
+}

package/src/helpers/AppearanceHelper.ts

@@ -0,0 +1,69 @@
+
+export interface AppearanceInterface { primaryColor?: string, primaryContrast?: string, secondaryColor?: string, secondaryContrast?: string, logoLight?: string, logoDark?: string, favicon_400x400?: string, favicon_16x16?: string }
+
+export class AppearanceHelper {
+
+  public static getLogoDark(appearanceSettings: AppearanceInterface, defaultLogo: string) {
+    return (appearanceSettings?.logoDark) ? appearanceSettings.logoDark : defaultLogo;
+  }
+
+  public static getLogoLight(appearanceSettings: AppearanceInterface, defaultLogo: string) {
+    return (appearanceSettings?.logoLight) ? appearanceSettings.logoLight : defaultLogo;
+  }
+
+  public static getFavicon(appearanceSettings: AppearanceInterface, size: "400" | "16") {
+    if (size === "400") {
+      return appearanceSettings?.favicon_400x400;
+    }
+
+    if (size === "16") {
+      return appearanceSettings?.favicon_16x16;
+    }
+
+    return;
+  }
+
+  public static getLogo(appearanceSettings: AppearanceInterface, defaultLogoLight: string, defaultLogoDark: string, backgroundColor: string) {
+    const isDark = (appearanceSettings.logoDark) ? this.isDark(backgroundColor) : false;
+    if (isDark) return this.getLogoDark(appearanceSettings, defaultLogoDark);
+    else return this.getLogoLight(appearanceSettings, defaultLogoLight);
+  }
+
+  private static isDark(backgroundColor: string) {
+    let valid = false;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+
+    if (backgroundColor.match(/#[0-9a-fA-F{6}]/)) {
+      r = this.getHexValue(backgroundColor.substring(1, 2));
+      g = this.getHexValue(backgroundColor.substring(3, 4));
+      b = this.getHexValue(backgroundColor.substring(5, 6));
+      valid = true;
+    } else if (backgroundColor.match(/#[0-9a-fA-F{3}]/)) {
+      r = this.getHexValue(backgroundColor.substring(1, 1));
+      g = this.getHexValue(backgroundColor.substring(2, 2));
+      b = this.getHexValue(backgroundColor.substring(3, 3));
+      valid = true;
+    }
+
+    if (!valid) return false;
+    else {
+      //HSP brightness formula.  Some colors have a bigger impact on our perceived brightness than others.
+      const rWeight = .299 * Math.pow(r, 2);
+      const gWeight = .587 * Math.pow(g, 2);
+      const bWeight = .114 * Math.pow(b, 2);
+      const brightness = Math.sqrt(rWeight + gWeight + bWeight);
+      //return brightness < 128;  //
+      return brightness < 156;
+    }
+
+  }
+
+  private static getHexValue(hex: string) {
+    let result = parseInt(hex, 16);
+    if (hex.length === 1) result = result * 16;
+    return result;
+  }
+
+}

package/src/helpers/ArrayHelper.ts

@@ -0,0 +1,81 @@
+import { UniqueIdHelper } from "./UniqueIdHelper";
+
+export class ArrayHelper {
+  static getIds(array: any[], propertyName: string) {
+    const result: string[] = [];
+    for (const item of array) {
+      const id = item[propertyName]?.toString();
+      if (!UniqueIdHelper.isMissing(id) && result.indexOf(id) === -1) result.push(id);
+    }
+    return result;
+  }
+
+  static sortBy(array: any[], propertyName: string, descending: boolean = false) {
+    array.sort((a, b) => {
+      const valA = a[propertyName];
+      const valB = b[propertyName];
+      if (valA < valB) return descending ? 1 : -1;
+      else return descending ? -1 : 1;
+      //console.log(valA, valB, valA < valB, )
+    });
+  }
+
+  static getIndex(array: any[], propertyName: string, value: any) {
+    for (let i = 0; i < array.length; i++) {
+      const item = array[i];
+      if (ArrayHelper.compare(item, propertyName, value)) return i;
+    }
+    return -1;
+  }
+
+  static getOne(array: any[], propertyName: string, value: any) {
+    for (const item of array || []) if (ArrayHelper.compare(item, propertyName, value)) return item;
+    return null
+  }
+
+  static getAll(array: any[], propertyName: string, value: any) {
+    const result: any[] = []
+    for (const item of array || []) {
+      if (ArrayHelper.compare(item, propertyName, value)) result.push(item);
+    }
+    return result;
+  }
+
+  static getAllArray(array: any[], propertyName: string, values: any[]) {
+    const result: any[] = []
+    for (const item of array || []) if (values.indexOf(item[propertyName]) > -1) result.push(item);
+    return result;
+  }
+
+  private static compare(item: any, propertyName: string, value: any) {
+    const propChain = propertyName.split(".");
+    if (propChain.length === 1) return item[propertyName] === value;
+    else {
+      let obj = item;
+      for (let i = 0; i < propChain.length - 1; i++) {
+        if (obj) obj = item[propChain[i]];
+      }
+      return obj[propChain[propChain.length - 1]] === value;
+    }
+  }
+
+  static getUniqueValues(array: any[], propertyName: string) {
+    const result: any[] = [];
+
+    for (const item of array) {
+      const val = (propertyName.indexOf(".") === -1) ? item[propertyName] : this.getDeepValue(item, propertyName)
+      if (result.indexOf(val) === -1) result.push(val);
+    }
+    return result;
+  }
+
+  static getDeepValue(item: any, propertyName: string) {
+    const propertyNames = propertyName.split(".");
+    let result: any = item;
+    propertyNames.forEach(name => {
+      result = result[name];
+    });
+    return result;
+  }
+
+}

package/src/helpers/CommonEnvironmentHelper.ts

@@ -0,0 +1,80 @@
+
+export class CommonEnvironmentHelper {
+  public static AttendanceApi = "";
+  public static DoingApi = "";
+  public static GivingApi = "";
+  public static MembershipApi = "";
+  public static ReportingApi = "";
+  public static MessagingApi = "";
+  public static MessagingApiSocket = "";
+  public static ContentApi = "";
+  public static GoogleAnalyticsTag = "";
+
+  static ContentRoot = "";
+  static B1Root = "";
+  static ChumsRoot = "";
+  static LessonsRoot = "";
+
+  static init = (stage: string) => {
+    switch (stage) {
+      case "staging": CommonEnvironmentHelper.initStaging(); break;
+      case "prod": CommonEnvironmentHelper.initProd(); break;
+      default: CommonEnvironmentHelper.initDev(); break;
+    }
+  }
+
+  static initDev = () => {
+    this.initStaging(); //Use staging values for anything not provided
+    CommonEnvironmentHelper.AttendanceApi = process.env.REACT_APP_ATTENDANCE_API || process.env.NEXT_PUBLIC_ATTENDANCE_API || CommonEnvironmentHelper.AttendanceApi;
+    CommonEnvironmentHelper.DoingApi = process.env.REACT_APP_DOING_API || process.env.NEXT_PUBLIC_DOING_API || CommonEnvironmentHelper.DoingApi;
+    CommonEnvironmentHelper.GivingApi = process.env.REACT_APP_GIVING_API || process.env.NEXT_PUBLIC_GIVING_API || CommonEnvironmentHelper.GivingApi;
+    CommonEnvironmentHelper.MembershipApi = process.env.REACT_APP_MEMBERSHIP_API || process.env.NEXT_PUBLIC_MEMBERSHIP_API || CommonEnvironmentHelper.MembershipApi;
+    CommonEnvironmentHelper.ReportingApi = process.env.REACT_APP_REPORTING_API || process.env.NEXT_PUBLIC_REPORTING_API || CommonEnvironmentHelper.ReportingApi;
+    CommonEnvironmentHelper.MessagingApi = process.env.REACT_APP_MESSAGING_API || process.env.NEXT_PUBLIC_MESSAGING_API || CommonEnvironmentHelper.MessagingApi;
+    CommonEnvironmentHelper.MessagingApiSocket = process.env.REACT_APP_MESSAGING_API_SOCKET || process.env.NEXT_PUBLIC_MESSAGING_API_SOCKET || CommonEnvironmentHelper.MessagingApiSocket;
+    CommonEnvironmentHelper.ContentApi = process.env.REACT_APP_CONTENT_API || process.env.NEXT_PUBLIC_CONTENT_API || CommonEnvironmentHelper.ContentApi;
+    CommonEnvironmentHelper.GoogleAnalyticsTag = process.env.REACT_APP_GOOGLE_ANALYTICS || process.env.NEXT_PUBLIC_GOOGLE_ANALYTICS || CommonEnvironmentHelper.GoogleAnalyticsTag;
+
+    CommonEnvironmentHelper.ContentRoot = process.env.REACT_APP_CONTENT_ROOT || process.env.NEXT_PUBLIC_CONTENT_ROOT || CommonEnvironmentHelper.ContentRoot;
+    CommonEnvironmentHelper.B1Root = process.env.REACT_APP_B1_ROOT || process.env.NEXT_PUBLIC_B1_ROOT || CommonEnvironmentHelper.B1Root;
+    CommonEnvironmentHelper.ChumsRoot = process.env.REACT_APP_CHUMS_ROOT || process.env.NEXT_PUBLIC_CHUMS_ROOT || CommonEnvironmentHelper.ChumsRoot;
+    CommonEnvironmentHelper.LessonsRoot = process.env.REACT_APP_LESSONS_ROOT || process.env.NEXT_PUBLIC_LESSONS_ROOT || CommonEnvironmentHelper.LessonsRoot;
+  }
+
+  //NOTE: None of these values are secret.
+  static initStaging = () => {
+    CommonEnvironmentHelper.AttendanceApi = "https://attendanceapi.staging.churchapps.org";
+    CommonEnvironmentHelper.DoingApi = "https://doingapi.staging.churchapps.org";
+    CommonEnvironmentHelper.GivingApi = "https://givingapi.staging.churchapps.org";
+    CommonEnvironmentHelper.MembershipApi = "https://membershipapi.staging.churchapps.org";
+    CommonEnvironmentHelper.ReportingApi = "https://reportingapi.staging.churchapps.org";
+    CommonEnvironmentHelper.MessagingApi = "https://messagingapi.staging.churchapps.org";
+    CommonEnvironmentHelper.MessagingApiSocket = "wss://socket.staging.churchapps.org";
+    CommonEnvironmentHelper.ContentApi = "https://contentapi.staging.churchapps.org";
+    CommonEnvironmentHelper.GoogleAnalyticsTag = "";
+
+    CommonEnvironmentHelper.ContentRoot = "https://content.staging.churchapps.org";
+    CommonEnvironmentHelper.B1Root = "https://{key}.staging.b1.church";
+    CommonEnvironmentHelper.ChumsRoot = "https://app.staging.chums.org";
+    CommonEnvironmentHelper.LessonsRoot = "https://staging.lessons.church";
+  }
+
+  //NOTE: None of these values are secret.
+  static initProd = () => {
+    CommonEnvironmentHelper.AttendanceApi = "https://attendanceapi.churchapps.org";
+    CommonEnvironmentHelper.DoingApi = "https://doingapi.churchapps.org";
+    CommonEnvironmentHelper.GivingApi = "https://givingapi.churchapps.org";
+    CommonEnvironmentHelper.MembershipApi = "https://membershipapi.churchapps.org";
+    CommonEnvironmentHelper.ReportingApi = "https://reportingapi.churchapps.org";
+    CommonEnvironmentHelper.MessagingApi = "https://messagingapi.churchapps.org";
+    CommonEnvironmentHelper.MessagingApiSocket = "wss://socket.churchapps.org";
+    CommonEnvironmentHelper.ContentApi = "https://contentapi.churchapps.org";
+
+    CommonEnvironmentHelper.ContentRoot = "https://content.churchapps.org";
+    CommonEnvironmentHelper.B1Root = "https://{key}.b1.church";
+    CommonEnvironmentHelper.ChumsRoot = "https://app.chums.org";
+    CommonEnvironmentHelper.LessonsRoot = "https://lessons.church";
+  }
+
+}
+

package/src/helpers/CurrencyHelper.ts

@@ -0,0 +1,10 @@
+export class CurrencyHelper {
+  static formatCurrency(amount: number) {
+    const formatter = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2
+    });
+    return formatter.format(amount);
+  }
+}

package/src/helpers/DateHelper.ts

@@ -0,0 +1,108 @@
+import { format as dateFormat } from "date-fns"
+
+export class DateHelper {
+
+  //Fixes timezone issues when you just need the date.
+  static toDate(input: any) {
+    return new Date(Date.parse(input.toString().replace("Z", "")));
+  }
+
+  static toDateTime(input: any) {
+    return new Date(Date.parse(input.toString()));
+  }
+
+  //obsolete.  Do not use
+  static convertToDate(input: any) {
+    return this.toDateTime(input);
+  }
+
+  static addDays(date: Date, days: number) {
+    date.setDate(date.getDate() + days);
+    return date;
+  }
+
+  static prettyDate(date: Date) {
+    if (date === undefined || date === null) return "";
+    return this.formatDateTime(date, "MMM d, yyyy");
+  }
+
+  static prettyDateTime(date: Date) {
+    if (date === undefined || date === null) return "";
+    return this.formatDateTime(date, "MMM d, yyyy h:mm a");
+  }
+
+  static prettyTime(date: Date) {
+    if (date === undefined || date === null) return "";
+    return this.formatDateTime(date, "h:mm a");
+  }
+
+  static getLastSunday() {
+    let result = new Date();
+    while (result.getDay() !== 0) result.setDate(result.getDate() - 1);
+    return result;
+  }
+
+  static getWeekSunday(year: number, week: number) {
+    let result = new Date(year, 0, 1);
+    while (result.getDay() !== 0) result.setDate(result.getDate() + 1);
+    result.setDate(result.getDate() + ((week - 1) * 7));
+    return result;
+  }
+
+  static formatHtml5Date(date: Date): string {
+    let result = "";
+    if (date !== undefined && date !== null) {
+      try {
+        result = new Date(date).toISOString().split("T")[0];
+      } catch { }
+    }
+    return result;
+  }
+
+  static formatHtml5Time(time: Date): string {
+    let h = time.getHours();
+    let m = time.getMinutes();
+    let s = time.getSeconds();
+    return `${h < 10 ? ("0" + h) : h}:${m < 10 ? ("0" + m) : m}:${s < 10 ? ("0" + s) : s}`;
+  }
+
+  static formatHtml5DateTime(date: Date): string {
+    if (date === undefined || date === null) return "";
+    else {
+      return this.formatDateTime(date, "yyyy-MM-dd") + "T" + this.formatDateTime(date, "HH:mm");
+    }
+  }
+
+  static getDisplayDuration(d: Date): string {
+    let seconds = Math.round((new Date().getTime() - d.getTime()) / 1000);
+    if (seconds > 86400) {
+      let days = Math.floor(seconds / 86400);
+      return (days === 1) ? "1d" : days.toString() + "d";
+    }
+    else if (seconds > 3600) {
+      let hours = Math.floor(seconds / 3600);
+      return (hours === 1) ? "1h" : hours.toString() + "h";
+    }
+    else if (seconds > 60) {
+      let minutes = Math.floor(seconds / 60);
+      return (minutes === 1) ? "1m" : minutes.toString() + "m";
+    }
+    else return (seconds === 1) ? "1s" : Math.floor(seconds).toString() + "s";
+  }
+
+  static getShortDate(d: Date): string {
+    return (d.getMonth() + 1).toString() + "/" + (d.getDate()).toString() + "/" + d.getFullYear().toString();
+  }
+
+  static convertDatePickerFormat(d: Date): Date {
+    const date = this.formatHtml5Date(d).split("-");
+    if (date.length === 3) return new Date(`${date[1]}-${date[2]}-${date[0]}`);
+    return new Date();
+  }
+
+  private static formatDateTime(date: Date, format: string) {
+    try {
+      return dateFormat(date, format);
+    } catch { return ""; }
+  }
+}

package/src/helpers/DonationHelper.ts

@@ -0,0 +1,26 @@
+export class DonationHelper {
+
+  static getInterval(intervalName:string) {
+    let intervalCount = 1;
+    let intervalType = "month";
+    let parts = intervalName.split("_");
+    if (parts.length === 2) {
+      switch (parts[0])
+      {
+        case "two": intervalCount = 2; break;
+        case "three": intervalCount = 3; break;
+      }
+      intervalType = parts[1];
+    }
+    let result = { interval_count: intervalCount, interval: intervalType };
+    return result;
+  }
+
+  static getIntervalKeyName(intervalCount: number, intervalType: string) {
+    let firstPart = "one";
+    if (intervalCount === 2) firstPart = "two";
+    else if (intervalCount === 3) firstPart = "three";
+    return firstPart + "_" + intervalType;
+  }
+
+}

package/src/helpers/ErrorHelper.ts

@@ -0,0 +1,36 @@
+import { ErrorLogInterface, ErrrorAppDataInterface } from "../interfaces/Error";
+import { ApiHelper } from "./ApiHelper";
+
+
+export class ErrorHelper {
+
+  static getAppData:() => { churchId: string, userId: string, originUrl: string, application: string};
+  static customErrorHandler:(errorLog:ErrorLogInterface) => void;
+
+  static init = (getAppData:() => ErrrorAppDataInterface, customErrorHandler:(errorLog:ErrorLogInterface) => void) => {
+    ErrorHelper.getAppData = getAppData;
+    ErrorHelper.customErrorHandler = customErrorHandler;
+  }
+
+  static logError = (errorType:string, message:string, details:string) => {
+    if (this.getAppData)
+    {
+      const data = this.getAppData();
+      const log:ErrorLogInterface = {
+        application: data.application,
+        errorTime: new Date(),
+        userId: data.userId,
+        churchId: data.churchId,
+        originUrl: data.originUrl,
+        errorType: errorType,
+        message: message,
+        details: details
+      }
+
+      if (log.errorType==="401" && log.message.indexOf("/users/login")===-1) return;
+      ApiHelper.postAnonymous("/errors", [log], "MembershipApi");
+      if (ErrorHelper.customErrorHandler) ErrorHelper.customErrorHandler(log);
+    }
+  }
+
+}

package/src/helpers/EventHelper.ts

@@ -0,0 +1,52 @@
+import { EventInterface } from "../interfaces";
+import { RRule, datetime } from "rrule";
+import { ParsedOptions } from "rrule/dist/esm/types";
+
+export class EventHelper {
+
+  static getRange = (event:EventInterface, startDate:Date, endDate:Date) => {
+    const start = new Date(event.start);
+    const rrule = EventHelper.getFullRRule(event);
+
+    const dates = rrule.between(startDate, endDate);
+
+    dates.forEach(d => {
+      d.setHours(start.getHours());
+      d.setMinutes(start.getMinutes());
+      d.setSeconds(start.getSeconds());
+    })
+    return dates;
+  }
+
+  static getFullRRule = (event:EventInterface) => {
+    let rrule = RRule.fromString(event.recurrenceRule);
+    rrule.options.dtstart = new Date(event.start);
+    console.log("START", rrule.options.dtstart, event.start, rrule)
+    return rrule;
+  }
+
+  static removeExcludeDates = (events:EventInterface[]) => {
+    for (let i=events.length-1; i>=0; i--) {
+      if (events[i].exceptionDates?.length>0)
+      {
+        const parsedDates = events[i].exceptionDates.map(d=>new Date(d).toISOString());
+        //console.log("Compare", events[i].start.toISOString(), parsedDates, parsedDates.indexOf(events[i].start.toISOString()));
+        if (parsedDates.indexOf(events[i].start.toISOString())>-1) events.splice(i,1);
+      }
+    }
+  }
+
+  static getPartialRRuleString = (options:ParsedOptions) => {
+    const parts = new RRule(options).toString().split("RRULE:");
+    const result = parts.length===2 ? parts[1] : "";
+    console.log("getPartialRRuleString", options, new RRule(options).toString(), result);
+    return result;
+  }
+
+  static cleanRule = (options:ParsedOptions) => {
+    options.byhour = undefined;
+    options.byminute = undefined;
+    options.bysecond = undefined;
+  }
+
+}

package/src/helpers/FileHelper.ts

@@ -0,0 +1,31 @@
+import axios from "axios";
+
+export class FileHelper {
+
+  static postPresignedFile = (presigned: any, uploadedFile: File, progressCallback: (percent: number) => void) => {
+    const formData = new FormData();
+    formData.append("key", presigned.key);
+    formData.append("acl", "public-read");
+    formData.append("Content-Type", uploadedFile.type);
+    for (const property in presigned.fields) formData.append(property, presigned.fields[property]);
+    formData.append("file", uploadedFile);
+
+    const axiosConfig = {
+      headers: { "Content-Type": "multipart/form-data" },
+      onUploadProgress: (data: any) => {
+        progressCallback(Math.round((100 * data.loaded) / data.total));
+      }
+    };
+
+    return axios.post(presigned.url, formData, axiosConfig);
+  };
+
+  static dataURLtoBlob(dataurl: string) {
+    let arr = dataurl.split(","), mime = arr[0].match(/:(.*?);/)[1],
+      bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new Blob([u8arr], { type: mime });
+  }
+}

package/src/helpers/PersonHelper.ts

@@ -0,0 +1,60 @@
+import { PersonInterface, ContactInfoInterface } from "../interfaces";
+import { CommonEnvironmentHelper } from "./CommonEnvironmentHelper";
+
+export class PersonHelper {
+
+  static getPhotoUrl(person: PersonInterface) {
+    if (!person?.photo) return "/images/sample-profile.png"
+    else return person?.photo?.startsWith("data:image/png;base64,") ? person.photo : CommonEnvironmentHelper.ContentRoot + person.photo;
+  }
+
+  static getAge(birthdate: Date): string {
+    if (birthdate !== undefined && birthdate !== null) {
+      let ageDifMs = Date.now() - new Date(birthdate).getTime();
+      let ageDate = new Date(ageDifMs);
+      let years = Math.abs(ageDate.getUTCFullYear() - 1970);
+      return years + " years";
+    }
+    else return "";
+  }
+
+  static getDisplayName(firstName: string, lastName: string, nickName: string): string {
+    if (nickName !== undefined && nickName !== null && nickName.length > 0) return firstName + ' "' + nickName + '" ' + lastName;
+    else return firstName + " " + lastName;
+  }
+
+  public static compareAddress(address1: ContactInfoInterface, address2: ContactInfoInterface): boolean {
+    const displayAddress1: string = this.addressToString(address1).trim();
+    const displayAddress2: string = this.addressToString(address2).trim();
+
+    if (displayAddress1 !== displayAddress2) {
+      return true
+    }
+    return false
+  }
+
+  public static addressToString(address: ContactInfoInterface): string {
+    return `${address.address1 || ""} ${address.address2 || ""} ${address.city || ""}${(address.city && address.state) ? "," : ""} ${address.state || ""} ${address.zip || ""}`
+  }
+
+  public static changeOnlyAddress(contactInfo1: ContactInfoInterface, contactInfo2: ContactInfoInterface): ContactInfoInterface {
+    const updatedAddress: ContactInfoInterface = {
+      ...contactInfo1,
+      address1: contactInfo2.address1,
+      address2: contactInfo2.address2,
+      city: contactInfo2.city,
+      state: contactInfo2.state,
+      zip: contactInfo2.zip
+    }
+
+    return updatedAddress
+  }
+
+  public static checkAddressAvailabilty(person: PersonInterface): boolean {
+    const addressString: string = this.addressToString(person.contactInfo).trim();
+    if (addressString !== "") {
+      return true;
+    }
+    return false;
+  }
+}