@oneuptime/common 1.0.0

package/Types/Billing/SubscriptionPlan.ts

@@ -0,0 +1,241 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject } from '../JSON';
+
+export enum PlanSelect {
+    Free = 'Free',
+    Growth = 'Growth',
+    Enterprise = 'Enterprise',
+    Scale = 'Scale',
+}
+
+export default class SubscriptionPlan {
+    private monthlyPlanId: string = '';
+    private yearlyPlanId: string = '';
+    private name: string = '';
+    private monthlySubscriptionAmountInUSD: number = 0;
+    private yearlySubscriptionAmountInUSD: number = 0;
+    private order: number = -1;
+    private trialPeriodInDays: number = 0;
+
+    public constructor(
+        monthlyPlanId: string,
+        yearlyPlanId: string,
+        name: string,
+        monthlySubscriptionAmountInUSD: number,
+        yearlySubscriptionAmountInUSD: number,
+        order: number,
+        trialPeriodInDays: number
+    ) {
+        this.monthlyPlanId = monthlyPlanId;
+        this.yearlyPlanId = yearlyPlanId;
+        this.name = name;
+        this.monthlySubscriptionAmountInUSD = monthlySubscriptionAmountInUSD;
+        this.yearlySubscriptionAmountInUSD = yearlySubscriptionAmountInUSD;
+        this.order = order;
+        this.trialPeriodInDays = trialPeriodInDays;
+    }
+
+    public getMonthlyPlanId(): string {
+        return this.monthlyPlanId;
+    }
+
+    public getYearlyPlanId(): string {
+        return this.yearlyPlanId;
+    }
+
+    public getPlanOrder(): number {
+        return this.order;
+    }
+
+    public getTrialPeriod(): number {
+        return this.trialPeriodInDays;
+    }
+
+    public getName(): string {
+        return this.name;
+    }
+
+    public static isFreePlan(planId: string, env: JSONObject): boolean {
+        const plan: SubscriptionPlan | undefined = this.getSubscriptionPlanById(
+            planId,
+            env
+        );
+        if (plan) {
+            if (
+                plan.getMonthlyPlanId() === planId &&
+                plan.getMonthlySubscriptionAmountInUSD() === 0
+            ) {
+                return true;
+            }
+
+            if (
+                plan.getYearlyPlanId() === planId &&
+                plan.getYearlySubscriptionAmountInUSD() === 0
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static isCustomPricingPlan(
+        planId: string,
+        env: JSONObject
+    ): boolean {
+        const plan: SubscriptionPlan | undefined = this.getSubscriptionPlanById(
+            planId,
+            env
+        );
+        if (plan) {
+            if (plan.getMonthlyPlanId() === planId && plan.isCustomPricing()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public getYearlySubscriptionAmountInUSD(): number {
+        return this.yearlySubscriptionAmountInUSD;
+    }
+
+    public getMonthlySubscriptionAmountInUSD(): number {
+        return this.monthlySubscriptionAmountInUSD;
+    }
+
+    public isCustomPricing(): boolean {
+        return this.monthlySubscriptionAmountInUSD === -1;
+    }
+
+    public static getSubscriptionPlans(
+        env?: JSONObject | undefined
+    ): Array<SubscriptionPlan> {
+        const plans: Array<SubscriptionPlan> = [];
+
+        for (const key in env || process.env) {
+            if (key.startsWith('SUBSCRIPTION_PLAN_')) {
+                const content: string =
+                    ((env || process.env)[key] as string) || '';
+                const values: Array<string> = content.split(',');
+
+                if (values.length > 0) {
+                    plans.push(
+                        new SubscriptionPlan(
+                            values[1] as string,
+                            values[2] as string,
+                            values[0] as string,
+                            parseInt(values[3] as string),
+                            parseInt(values[4] as string),
+                            parseInt(values[5] as string),
+                            parseInt(values[6] as string)
+                        )
+                    );
+                }
+            }
+        }
+
+        plans.sort((a: SubscriptionPlan, b: SubscriptionPlan) => {
+            return a.order - b.order;
+        });
+
+        return plans;
+    }
+
+    public static getSubscriptionPlanById(
+        planId: string,
+        env?: JSONObject | undefined
+    ): SubscriptionPlan | undefined {
+        const plans: Array<SubscriptionPlan> = this.getSubscriptionPlans(env);
+        return plans.find((plan: SubscriptionPlan) => {
+            return (
+                plan.getMonthlyPlanId() === planId ||
+                plan.getYearlyPlanId() === planId
+            );
+        });
+    }
+
+    public static isValidPlanId(
+        planId: string,
+        env?: JSONObject | undefined
+    ): boolean {
+        return Boolean(this.getSubscriptionPlanById(planId, env));
+    }
+
+    public static getPlanSelect(
+        planId: string,
+        env?: JSONObject | undefined
+    ): PlanSelect {
+        const plan: SubscriptionPlan | undefined = this.getSubscriptionPlanById(
+            planId,
+            env
+        );
+        if (!plan) {
+            throw new BadDataException('Plan ID is invalid');
+        }
+
+        return plan.getName() as PlanSelect;
+    }
+
+    public static getSubscriptionPlanFromPlanSelect(
+        planSelect: PlanSelect,
+        env?: JSONObject | undefined
+    ): SubscriptionPlan {
+        const plan: SubscriptionPlan | undefined = this.getSubscriptionPlans(
+            env
+        ).find((plan: SubscriptionPlan) => {
+            return plan.getName() === planSelect;
+        });
+
+        if (!plan) {
+            throw new BadDataException('Invalid Plan');
+        }
+
+        return plan;
+    }
+
+    public static isFeatureAccessibleOnCurrentPlan(
+        featurePlan: PlanSelect,
+        currentPlan: PlanSelect,
+        env?: JSONObject | undefined
+    ): boolean {
+        const featureSubscriptionPlan: SubscriptionPlan | undefined =
+            this.getSubscriptionPlanFromPlanSelect(featurePlan, env);
+        const currentSubscriptionPlan: SubscriptionPlan | undefined =
+            this.getSubscriptionPlanFromPlanSelect(currentPlan, env);
+
+        if (
+            featureSubscriptionPlan.getPlanOrder() >
+            currentSubscriptionPlan.getPlanOrder()
+        ) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static isYearlyPlan(
+        planId: string,
+        env?: JSONObject | undefined
+    ): boolean {
+        const plan: SubscriptionPlan | undefined = this.getSubscriptionPlanById(
+            planId,
+            env
+        );
+        return plan?.getYearlyPlanId() === planId;
+    }
+
+    public static isUnpaid(subscriptionStatus: string): boolean {
+        if (
+            subscriptionStatus === 'incomplete' ||
+            subscriptionStatus === 'incomplete_expired' ||
+            subscriptionStatus === 'past_due' ||
+            subscriptionStatus === 'canceled' ||
+            subscriptionStatus === 'unpaid'
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+}

package/Types/Billing/SubscriptionStatus.ts

@@ -0,0 +1,32 @@
+enum SubscriptionStatus {
+    Incomplete = 'incomplete',
+    IncompleteExpired = 'incomplete_expired',
+    Trialing = 'trialing',
+    Active = 'active',
+    PastDue = 'past_due',
+    Canceled = 'canceled',
+    Unpaid = 'unpaid',
+}
+
+export class SubscriptionStatusUtil {
+    public static isSubscriptionActive(
+        status?: SubscriptionStatus | undefined
+    ): boolean {
+        if (!status) {
+            return true;
+        }
+
+        return (
+            status === SubscriptionStatus.Active ||
+            status === SubscriptionStatus.Trialing
+        );
+    }
+
+    public static isSubscriptionInactive(
+        status?: SubscriptionStatus | undefined
+    ): boolean {
+        return !SubscriptionStatusUtil.isSubscriptionActive(status);
+    }
+}
+
+export default SubscriptionStatus;

package/Types/BrandColors.ts

@@ -0,0 +1,35 @@
+import Color from './Color';
+
+export const Black: Color = Color.fromString('#000000');
+export const White: Color = Color.fromString('#ffffff');
+export const slate: Color = Color.fromString('#564ab1');
+export const Purple: Color = Color.fromString('#6f42c1');
+export const Pink: Color = Color.fromString('#e83e8c');
+export const Red: Color = Color.fromString('#fd625e');
+export const Orange: Color = Color.fromString('#f1734f');
+export const Yellow: Color = Color.fromString('#ffbf53');
+export const Green: Color = Color.fromString('#2ab57d');
+export const Teal: Color = Color.fromString('#050505');
+export const Cyan: Color = Color.fromString('#4ba6ef');
+export const VeryLightGrey: Color = Color.fromString('#c2c2c2');
+export const Grey: Color = Color.fromString('#575757');
+export const LightGrey: Color = Color.fromString('#908B8B');
+export const Moroon: Color = Color.fromString('#b70400');
+export const Blue: Color = Color.fromString('#3686be');
+
+export const EventColorList: Color[] = [
+    Color.fromString('#d50000'),
+    Color.fromString('#e67c73'),
+    Color.fromString('#f4511e'),
+    Color.fromString('#f6bf26'),
+    Color.fromString('#33b679'),
+    Color.fromString('#0b8043'),
+
+    Color.fromString('#039be5'),
+    Color.fromString('#3f51b5'),
+
+    Color.fromString('#65a30d'),
+    Color.fromString('#8e24aa'),
+
+    Color.fromString('#616161'),
+];

package/Types/Calendar/CalendarEvent.ts

@@ -0,0 +1,12 @@
+import { JSONObject } from '../JSON';
+
+export default interface CalendarEvent extends JSONObject {
+    id: number;
+    title: string;
+    start: Date;
+    end: Date;
+    allDay?: boolean | undefined;
+    desc?: string | undefined;
+    color?: string | undefined;
+    textColor?: string | undefined;
+}

package/Types/Call/CallRequest.ts

@@ -0,0 +1,43 @@
+import URL from '../API/URL';
+import Phone from '../Phone';
+
+export interface Say {
+    sayMessage: string;
+}
+
+export interface OnCallInputRequest {
+    [x: string]: Say; // input.
+    default: Say; // what if there is no input or invalid input.
+}
+
+export interface GatherInput {
+    introMessage: string;
+    numDigits: number;
+    timeoutInSeconds: number;
+    noInputMessage: string;
+    onInputCallRequest: OnCallInputRequest;
+    responseUrl: URL;
+}
+
+export enum CallAction {}
+
+export interface CallRequestMessage {
+    data: Array<Say | CallAction | GatherInput>;
+}
+
+export default interface CallRequest extends CallRequestMessage {
+    to: Phone;
+}
+
+type IsHighRiskPhoneNumberFunction = (phoneNumber: Phone) => boolean;
+
+export const isHighRiskPhoneNumber: IsHighRiskPhoneNumberFunction = (
+    phoneNumber: Phone
+): boolean => {
+    // Pakistan
+    if (phoneNumber.toString().startsWith('+92')) {
+        return true;
+    }
+
+    return false;
+};

package/Types/Call/CallStatus.ts

@@ -0,0 +1,9 @@
+enum CallStatus {
+    Success = 'Success',
+    Error = 'Error',
+    LowBalance = 'Low Balance',
+    MissedCall = 'Missed Call',
+    Busy = 'Busy',
+}
+
+export default CallStatus;

package/Types/CallAndSMS/TwilioConfig.ts

@@ -0,0 +1,7 @@
+import Phone from '../Phone';
+
+export default interface TwilioConfig {
+    accountSid: string;
+    authToken: string;
+    phoneNumber: Phone;
+}

package/Types/Char.ts

@@ -0,0 +1,65 @@
+type Char =
+    | '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';
+
+export default Char;

package/Types/Code/CodeType.ts

@@ -0,0 +1,11 @@
+enum CodeType {
+    JavaScript = 'javascript',
+    CSS = 'css',
+    HTML = 'html',
+    JSON = 'json',
+    Markdown = 'markdown',
+    SQL = 'sql',
+    // TODO add more mime types.
+}
+
+export default CodeType;

package/Types/Color.ts

@@ -0,0 +1,108 @@
+import { FindOperator } from 'typeorm';
+import DatabaseProperty from './Database/DatabaseProperty';
+import BadDataException from './Exception/BadDataException';
+import { JSONObject, ObjectType } from './JSON';
+
+export interface RGB {
+    red: number;
+    green: number;
+    blue: number;
+}
+
+export default class Color extends DatabaseProperty {
+    private _color!: string;
+    public get color(): string {
+        return this._color;
+    }
+    public set color(v: string) {
+        this._color = v;
+    }
+
+    public constructor(color: string) {
+        super();
+        this.color = color;
+    }
+
+    public override toString(): string {
+        return this.color;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Color,
+            value: (this as Color).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Color {
+        if (json['_type'] === ObjectType.Color) {
+            return new Color((json['value'] as string) || '');
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public static override toDatabase(
+        value: Color | FindOperator<Color>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new Color(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public static override fromDatabase(_value: string): Color | null {
+        if (_value) {
+            return new Color(_value);
+        }
+
+        return null;
+    }
+
+    public static colorToRgb(color: Color): RGB {
+        const re: RegExp = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
+        const result: RegExpExecArray | null = re.exec(color.toString());
+
+        if (!result) {
+            throw new BadDataException('Invalid color: ' + color.toString());
+        }
+
+        return {
+            red: parseInt(result[1] ? result[1] : '0', 16),
+            green: parseInt(result[2] ? result[2] : '0', 16),
+            blue: parseInt(result[3] ? result[3] : '0', 16),
+        };
+    }
+
+    private static _componentToHex(c: number): string {
+        const hex: string = c.toString(16);
+        return hex.length === 1 ? '0' + hex : hex;
+    }
+
+    public static rgbToColor(rgb: RGB): Color {
+        return new Color(
+            '#' +
+                this._componentToHex(rgb.red) +
+                this._componentToHex(rgb.green) +
+                this._componentToHex(rgb.blue)
+        );
+    }
+
+    public static fromString(color: string): Color {
+        return new Color(color);
+    }
+
+    public static shouldUseDarkText(color: Color): boolean {
+        const rgb: RGB = Color.colorToRgb(color);
+
+        if (rgb.red * 0.299 + rgb.green * 0.587 + rgb.blue * 0.114 > 186) {
+            return true;
+        }
+        return false;
+    }
+}

package/Types/Company/CompanySize.ts

@@ -0,0 +1,9 @@
+enum CompanySize {
+    OneToTen = '1 to 10',
+    ElevenToFifty = '11 to 50',
+    FiftyToTwoHundred = '51 to 200',
+    TwoHundredToFiveHundred = '201 to 500',
+    FiveHundredAndMore = '500+',
+}
+
+export default CompanySize;

package/Types/Company/JobRole.ts

@@ -0,0 +1,10 @@
+enum JobRole {
+    CEO = 'CEO',
+    CTO = 'CTO',
+    CIO = 'CIO',
+    Executive = 'Executive',
+    Developer = 'Developer',
+    EngineeringManager = 'Engineering Manager',
+}
+
+export default JobRole;