@churchapps/helpers 1.0.0

package/src/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/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/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/EventHelper.ts

@@ -0,0 +1,49 @@
+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);
+    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());
+        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] : "";
+    return result;
+  }
+
+  static cleanRule = (options:ParsedOptions) => {
+    options.byhour = undefined;
+    options.byminute = undefined;
+    options.bysecond = undefined;
+  }
+
+}

package/src/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/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;
+  }
+}

package/src/UniqueIdHelper.ts

@@ -0,0 +1,36 @@
+export class UniqueIdHelper {
+
+  static chars = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+    "-", "_"];
+
+  static alphanumericChars = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"];
+
+  public static isMissing(obj: any) {
+    if (obj === undefined || obj === null) return true;
+    else if (obj.toString() === "") return true;
+    else return false;
+  }
+
+  public static shortId() {
+    return this.generate(UniqueIdHelper.chars, 11);
+  }
+
+  public static generateAlphanumeric() {
+    return this.generate(UniqueIdHelper.alphanumericChars, 11);
+  }
+
+  public static generate(charList: string[], length: number) {
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      const idx = Math.floor(Math.random() * charList.length);
+      const c = charList[idx];
+      result += c;
+    }
+    return result;
+  }
+
+}

package/src/UserHelper.ts

@@ -0,0 +1,59 @@
+import { ApiHelper } from "./ApiHelper"
+import { UserInterface, UserContextInterface, IPermission, PersonInterface, LoginUserChurchInterface } from "./interfaces";
+
+export class UserHelper {
+  static currentUserChurch: LoginUserChurchInterface;
+  static userChurches: LoginUserChurchInterface[];
+  static user: UserInterface;
+  static churchChanged: boolean = false;
+  static person: PersonInterface;
+
+  static selectChurch = async (context?: UserContextInterface, churchId?: string, keyName?: string) => {
+    let userChurch = null;
+
+    if (churchId) {
+      UserHelper.userChurches.forEach(uc => {
+        if (uc.church.id === churchId) userChurch = uc;
+      });
+    }
+    else if (keyName) UserHelper.userChurches.forEach(uc => { if (uc.church.subDomain === keyName) userChurch = uc; });
+    else userChurch = UserHelper.userChurches[0];
+    if (!userChurch) return;
+    else {
+      UserHelper.currentUserChurch = userChurch;
+      UserHelper.setupApiHelper(UserHelper.currentUserChurch);
+      // TODO - remove context code from here and perform the logic in the component itself.
+      if (context) {
+        if (context.userChurch !== null) UserHelper.churchChanged = true;
+        context.setUserChurch(UserHelper.currentUserChurch);
+      }
+    }
+  }
+
+  static setupApiHelper(userChurch: LoginUserChurchInterface) {
+    ApiHelper.setDefaultPermissions(userChurch.jwt);
+    userChurch.apis.forEach(api => { ApiHelper.setPermissions(api.keyName, api.jwt, api.permissions); });
+  }
+
+  static setupApiHelperNoChurch(user: LoginUserChurchInterface) {
+    ApiHelper.setDefaultPermissions(user.jwt);
+  }
+
+  static checkAccess({ api, contentType, action }: IPermission): boolean {
+    const permissions = ApiHelper.getConfig(api).permisssions;
+
+    let result = false;
+    if (permissions !== undefined) {
+      permissions.forEach(element => {
+        if (element.contentType === contentType && element.action === action) result = true;
+      });
+    }
+    return result;
+  }
+
+  static createAppUrl(appUrl: string, returnUrl: string) {
+    const jwt = ApiHelper.getConfig("MembershipApi").jwt;
+
+    return `${appUrl}/login/?jwt=${jwt}&returnUrl=${returnUrl}`;
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+
+export { ApiHelper } from "./ApiHelper";
+export { AppearanceHelper } from "./AppearanceHelper";
+export { ArrayHelper } from "./ArrayHelper";
+export { CurrencyHelper } from "./CurrencyHelper"
+export { DateHelper } from "./DateHelper";
+export { FileHelper } from "./FileHelper";
+export { PersonHelper } from "./PersonHelper"
+export { UserHelper } from "./UserHelper";
+export { UniqueIdHelper } from "./UniqueIdHelper";
+export { DonationHelper } from "./DonationHelper";

package/src/interfaces/Access.ts

@@ -0,0 +1,24 @@
+import { PersonInterface } from "./Membership";
+
+export interface ApiInterface { name: string, keyName?: string, permissions: RolePermissionInterface[], jwt: string }
+export interface ChurchInterface { id?: string, name?: string, registrationDate?: Date, address1?: string, address2?: string, city?: string, state?: string, zip?: string, country?: string, subDomain?: string, settings?: GenericSettingInterface[], archivedDate?: Date }
+export interface DomainInterface { id?: string, domainName?: string }
+export interface RegisterChurchRequestInterface extends ChurchInterface { appName?: string }
+export interface LoadCreateUserRequestInterface { userEmail: string, fromEmail?: string, subject?: string, body?: string, firstName: string, lastName: string }
+export interface LoginResponseInterface { user: UserInterface, userChurches: LoginUserChurchInterface[], errors: string[] }
+export interface LoginUserChurchInterface { person: PersonInterface, church: ChurchInterface, apis: ApiInterface[], jwt: string, groups: { id: string, name: string, leader:boolean }[] }
+
+export interface PermissionInterface { apiName?: string, section?: string, action?: string, displaySection?: string, displayAction?: string }
+export interface RegisterUserInterface { firstName?: string, lastName: string, email?: string, appName: string, appUrl: string }
+export interface RoleInterface { id?: string, churchId?: string, name?: string }
+export interface RolePermissionInterface { id?: string, churchId?: string, roleId?: string, apiName?: string, contentType?: string, contentId?: string, action?: string }
+export interface RoleMemberInterface { id?: string, churchId?: string, roleId?: string, userId?: string, user?: UserInterface, personId?: string }
+export interface ResetPasswordRequestInterface { userEmail: string }
+export interface ResetPasswordResponseInterface { emailed: boolean }
+export interface UserInterface { id?: string, email?: string, authGuid?: string, firstName?: string, lastName?: string, registrationDate?: Date, lastLogin?: Date, password?: string, jwt?: string }
+export interface GenericSettingInterface { id?: string, churchId?: string, keyName?: string, value?: string, public?: number }
+export interface UserChurchInterface { id?: string, userId?: string, churchId?: string, personId?: string }
+
+export interface ApiConfig { keyName: string, url: string, jwt: string, permisssions: RolePermissionInterface[] }
+export type ApiListType = "MembershipApi" | "AttendanceApi" | "GivingApi" | "DoingApi" | "MessagingApi" | "LessonsApi" | "ReportingApi" | "ContentApi";
+export interface IPermission { api: string, contentType: string, action: string }

package/src/interfaces/Attendance.ts

@@ -0,0 +1,8 @@
+import { CampusInterface, ServiceInterface, ServiceTimeInterface, PersonInterface } from "."
+
+export interface AttendanceInterface { campus: CampusInterface, service: ServiceInterface, serviceTime: ServiceTimeInterface, groupId: string }
+export interface AttendanceRecordInterface { serviceTime: ServiceTimeInterface, service: ServiceInterface, campus: CampusInterface, week: number, count: number, visitDate: Date, groupId: string }
+export interface VisitInterface { id?: string, personId?: string, serviceId?: string, groupId?: string, visitDate?: Date, visitSessions?: VisitSessionInterface[], person?: PersonInterface }
+export interface VisitSessionInterface { id?: string, visitId?: string, sessionId?: string, visit?: VisitInterface, session?: SessionInterface }
+export interface SessionInterface { id?: string, groupId: string, serviceTimeId: string, sessionDate?: Date, displayName: string }
+export interface SettingInterface { id?: string, keyName?: string, value?: string }

package/src/interfaces/Content.ts

@@ -0,0 +1,10 @@
+export interface LinkInterface { id?: string; churchId?: string; url?: string; text?: string; sort?: number; linkType: string; linkData: string; icon: string; category: string; parentId?: string; children?: any }
+export interface SermonInterface { id?: string, churchId?: string, playlistId?: string, videoType?: string, videoData?: string, videoUrl?: string, title?: string, description?: string, publishDate?: Date, thumbnail?: string, duration?: number, permanentUrl?: boolean }
+export interface PlaylistInterface { id?: string, churchId?: string, title?: string, description?: string, publishDate?: Date, thumbnail?: string }
+export interface StreamingServiceInterface { id?: string, churchId?: string, serviceTime?: Date, earlyStart?: number, duration: number, chatBefore: number, chatAfter: number, provider: string, providerKey: string, videoUrl: string, timezoneOffset: number, recurring: boolean, label: string, sermonId?: string }
+export interface EventInterface { id?: string; churchId?: string; groupId?: string; start?: Date; end?:Date, title?: string; description?: string; allDay?: boolean; visibility?:string; recurrenceRule?:string; exceptionDates?:Date[] }
+export interface EventExceptionInterface { id?: string; churchId?: string; eventId?: string; exceptionDate?: Date; }
+export interface CuratedCalendarInterface { id?: string, churchId?: string, name?:string }
+export interface CuratedEventInterface { id?: string, churchId?: string, curratedCalendarId?: string, groupId?: string, eventId?: string }
+export interface CuratedEventWithEventInterface extends EventInterface, CuratedEventInterface {}
+export type VisibilityOptions = "public" | "private" | "hidden";

package/src/interfaces/Doing.ts

@@ -0,0 +1,24 @@
+export interface ActionInterface { id?: string, automationId?: string, actionType?: string, actionData?: string }
+export interface AutomationInterface { id?: string, title: string, recurs: string, active: boolean }
+export interface ConditionInterface { id?: string, conjunctionId?: string, field?: string, fieldData?: string, operator?: string, value?: string, label?: string }
+export interface ConjunctionInterface { id?: string, automationId?: string, parentId?: string, groupType?: string, conjunctions?: ConjunctionInterface[], conditions?: ConditionInterface[] }
+export interface TaskInterface {
+  id?: string,
+  taskNumber?: number,
+  taskType?: string,
+  dateCreated?: Date,
+  dateClosed?: Date,
+  associatedWithType?: string,
+  associatedWithId?: string,
+  associatedWithLabel?: string,
+  createdByType?: string,
+  createdById?: string,
+  createdByLabel?: string,
+  assignedToType?: string,
+  assignedToId?: string,
+  assignedToLabel?: string,
+  title?: string,
+  status?: string,
+  automationId?: string,
+  conversationId?: string
+}

package/src/interfaces/Donation.ts

@@ -0,0 +1,45 @@
+import { PersonInterface } from "."
+
+export interface DonationBatchInterface { id?: string, name?: string, batchDate?: Date, donationCount?: number, totalAmount?: number }
+export interface DonationInterface { id?: string, batchId?: string, personId?: string, donationDate?: Date, amount?: number, method?: string, methodDetails?: string, notes?: string, person?: PersonInterface, fund?: FundInterface }
+export interface DonationSummaryInterface { week: number, donations?: DonationSummaryDonation[] }
+export interface DonationSummaryDonation { totalAmount: number, fund?: FundInterface }
+export interface FundInterface { id: string, name: string, amount?: number }
+export interface FundDonationInterface { id?: string, donationId?: string, fundId?: string, amount?: number, donation?: DonationInterface }
+export interface PaymentMethodInterface { id?: string, churchId?: string, personId?: string, customerId?: string, email?: string, name?: string }
+export interface StripeCardUpdateInterface { paymentMethodId: string, cardData: StripeCardDataInterface, personId?: string }
+export interface StripeCardDataInterface { card: StripeCardExpirationInterface }
+export interface StripeCardExpirationInterface { exp_month: string, exp_year: string }
+export interface StripeBankAccountInterface { account_holder_name: any, account_holder_type: any, country: string, currency: string, account_number: any, routing_number: any }
+export interface StripeBankAccountUpdateInterface { paymentMethodId: string, customerId: string, personId?: string, bankData: StripeBankAccountHolderDataInterface }
+export interface StripeBankAccountHolderDataInterface { account_holder_name: string, account_holder_type: string }
+export interface StripeBankAccountVerifyInterface { customerId: string, paymentMethodId: string, amountData: { amounts: string[] } }
+export interface StripePersonDonationInterface { id: string, email: string, name: string };
+export interface StripeFundDonationInterface { id: string, amount: number, name?: string };
+export interface StripeDonationInterface { id?: string, type?: string, amount?: number, customerId?: string, billing_cycle_anchor?: number, proration_behavior?: string, interval?: StripeDonationIntervalInterface, person?: StripePersonDonationInterface, funds?: StripeFundDonationInterface[], notes?: string, churchId?: string };
+export interface StripeDonationIntervalInterface { interval: string, interval_count: number };
+export interface SubscriptionInterface { id: string, funds: [], billing_cycle_anchor: number, default_payment_method: string, default_source: string, plan: { amount: number, interval: string, interval_count: number }, customer: string };
+
+export class StripePaymentMethod {
+  id: string;
+  type: string;
+  name: string;
+  last4: string;
+  exp_month?: string;
+  exp_year?: string;
+  status?: string;
+  account_holder_name?: string;
+  account_holder_type?: string;
+
+  constructor(obj?: any) {
+    this.id = obj?.id || null;
+    this.type = obj?.type || (obj?.object && obj.object === "bank_account" ? "bank" : null);
+    this.name = obj?.card?.brand || obj?.bank_name || null;
+    this.last4 = obj?.last4 || obj?.card?.last4 || null;
+    this.exp_month = obj?.exp_month || obj?.card?.exp_month || null;
+    this.exp_year = obj?.exp_year || obj?.card?.exp_year || null;
+    this.status = obj?.status || null;
+    this.account_holder_name = obj?.account_holder_name || "";
+    this.account_holder_type = obj?.account_holder_type || "individual";
+  }
+}

package/src/interfaces/Error.ts

@@ -0,0 +1,17 @@
+export interface ErrorLogInterface {
+  application?: string,
+  errorTime?: Date,
+  userId?: string,
+  churchId?: string,
+  originUrl?: string,
+  errorType?: string,
+  message?: string,
+  details?: string,
+ };
+
+export interface ErrrorAppDataInterface {
+  churchId: string,
+  userId: string,
+  originUrl: string,
+  application: string
+ }

package/src/interfaces/Membership.ts

@@ -0,0 +1,51 @@
+export interface AnswerInterface { id?: string, value?: string, questionId?: string, formSubmissionId?: string, required?: boolean }
+export interface CampusInterface { id?: string, name?: string }
+export interface ContactInfoInterface { address1?: string, address2?: string, city?: string, state?: string, zip?: string, homePhone?: string, mobilePhone?: string, workPhone?: string, email?: string, pager?: string, fax?: string, skype?: string, workEmail?: string }
+export interface FormInterface { id?: string, name?: string, contentType?: string, restricted?: boolean, accessStartTime?: Date, accessEndTime?: Date, archived: boolean, action?: string }
+export interface FormSubmissionInterface { id?: string, formId?: string, contentType?: string, contentId?: string, form?: FormInterface, answers?: AnswerInterface[], questions?: QuestionInterface[] }
+export interface GroupInterface { id?: string, name?: string, categoryName?: string, memberCount?: number, trackAttendance?: boolean, parentPickup?: boolean, about?: string, photoUrl?: string }
+export interface GroupMemberInterface { id?: string, personId: string, person?: PersonInterface, groupId: string, group?: GroupInterface, leader?: boolean }
+export interface GroupServiceTimeInterface { id?: string, groupId?: string, serviceTimeId?: string, serviceTime?: ServiceTimeInterface }
+export interface HouseholdInterface { id?: string, name?: string }
+export interface HouseholdMemberInterface { id?: string, householdId?: string, household?: HouseholdInterface, personId?: string, person?: PersonInterface, role?: string }
+export interface NameInterface { first?: string, middle?: string, last?: string, nick?: string, display?: string, title?: string, suffix?: string }
+export interface SearchCondition { field: string, operator: string, value: string }
+
+export interface PersonInterface {
+  id?: string,
+  name: NameInterface,
+  contactInfo: ContactInfoInterface,
+  membershipStatus?: string,
+  gender?: string,
+  birthDate?: Date,
+  maritalStatus?: string,
+  anniversary?: Date,
+  photo?: string,
+  photoUpdated?: Date,
+  householdId?: string,
+  householdRole?: string,
+  userId?: string,
+  school?: string,
+  grade?: string,
+  graduationDate?: string,
+  employer?: string,
+  formSubmissions?: [FormSubmissionInterface]
+  child?: boolean,
+  inactiveReason?: string,
+  inactiveDate?: Date,
+  servicesUser?: boolean,
+  calendarUser?: boolean,
+  checkInsUser?: boolean,
+  registrationsUser?: boolean,
+  givingUser?: boolean,
+  groupsUser?: boolean,
+  conversationId?: string,
+  optedOut?: boolean,
+  nametagNotes?: string
+}
+export interface QuestionInterface { id?: string, formId?: string, title?: string, fieldType?: string, placeholder?: string, description?: string, required?: boolean, choices?: [{ value?: string, text?: string }] }
+export interface ServiceInterface { id?: string, campusId?: string, name?: string, campus?: CampusInterface }
+export interface ServiceTimeInterface { id?: string, name?: string, longName?: string, serviceId?: string, groups?: GroupInterface[] }
+export interface MemberPermissionInterface { id?: string, churchId?: string, memberId?: string, contentType?: string, contentId?: string, action?: string, personName: string, formName?: string, emailNotification?: boolean }
+export interface FormMemberInterface { person?: PersonInterface, access?: string }
+export interface FormMemberListInterface { members?: FormMemberInterface[] }

package/src/interfaces/Messaging.ts

@@ -0,0 +1,20 @@
+import { PersonInterface } from "./Membership";
+
+export interface ConnectionInterface { id?: string, churchId?: string, conversationId?: string, userId?: string, displayName?: string, timeJoined?: Date, socketId?: string }
+export interface ConversationInterface {
+  id?: string, churchId?: string, contentType?: string, contentId?: string, title?: string, dateCreated?: Date, groupId?: string, visibility?: string, firstPostId?: string, lastPostId?: string, postCount?: number, allowAnonymousPosts?: boolean;
+  messages?: MessageInterface[],
+}
+export interface MessageInterface {
+  id?: string, churchId?: string, conversationId?: string, userId?: string, personId?: string, displayName?: string, timeSent?: Date, timeUpdated?: Date, messageType?: string, content?: string,
+  person?: PersonInterface
+}
+export interface PrivateMessageInterface {
+  id?: string, churchId?: string, fromPersonId?: string, toPersonId?: string, conversationId?: string, notifyPersonId?: string
+  conversation?: ConversationInterface;
+  person?: PersonInterface;
+}
+
+export interface SocketActionHandlerInterface { action:string, id:string, handleMessage:(data:any) => void }
+export type SocketPayloadAction = "message" | "deleteMessage" | "callout" | "attendance" | "prayerRequest" | "socketId" | "privateMessage" | "privateRoomAdded" | "videoChatInvite" | "reconnect";
+export interface SocketPayloadInterface {  action: SocketPayloadAction, data: any }