@go-avro/avro-js 0.0.4-beta.9 → 0.0.5

package/dist/client/hooks/waivers.js

@@ -0,0 +1,123 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useCreateWaiver = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ waiverData }) => {
+            return this.post(`/company/${this.companyId}/waiver`, JSON.stringify(waiverData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+            queryClient.invalidateQueries({ queryKey: ['waivers'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useGetWaivers = function (body, total, onProgress) {
+    return useQuery({
+        queryKey: ['waivers', this.companyId, body.amt ?? 50, body.known_ids ?? [], body.unknown_ids ?? [], body.offset ?? 0, body.query ?? "", total ?? "all"],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchWaivers({ ...body, offset: 0 });
+            }
+            onProgress?.(0);
+            const pageCount = body.amt ? Math.ceil(total / body.amt) + 1 : 1;
+            let completed = 0;
+            const promises = Array.from({ length: pageCount }, (_, i) => this.fetchWaivers({
+                ...body,
+                offset: i * (body.amt ?? 1),
+            }));
+            const trackedPromises = promises.map((promise) => promise.then((result) => {
+                completed++;
+                const fraction = completed / pageCount;
+                onProgress?.(fraction);
+                return result;
+            }));
+            const pages = await Promise.all(trackedPromises);
+            const waivers = pages.flat();
+            return waivers;
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateWaiver = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ waiverId, updates }) => {
+            return this.put(`/waiver/${waiverId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ waiverId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['waivers'] });
+            await queryClient.cancelQueries({ queryKey: ['waiver', waiverId] });
+            const previousWaivers = queryClient.getQueryData(['waivers']);
+            const previousWaiver = queryClient.getQueryData(['waiver', waiverId]);
+            queryClient.setQueryData(['waiver', waiverId], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                return { ...oldData, ...updates };
+            });
+            queryClient.setQueriesData({ queryKey: ['waivers'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((waiver) => waiver.id === waiverId ? { ...waiver, ...updates } : waiver));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((waiver) => waiver.id === waiverId ? { ...waiver, ...updates } : waiver);
+                }
+                return oldData;
+            });
+            return { previousWaivers, previousWaiver };
+        },
+        onError: (_err, variables, context) => {
+            const { waiverId } = variables;
+            if (context?.previousWaivers) {
+                queryClient.setQueryData(['waivers'], context.previousWaivers);
+            }
+            if (context?.previousWaiver) {
+                queryClient.setQueryData(['waiver', waiverId], context.previousWaiver);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { waiverId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['waivers'] });
+            queryClient.invalidateQueries({ queryKey: ['waiver', waiverId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteWaiver = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ waiverId }) => {
+            return this.delete(`/waiver/${waiverId}`);
+        },
+        onMutate: async ({ waiverId }) => {
+            await queryClient.cancelQueries({ queryKey: ['waivers'] });
+            const previousWaivers = queryClient.getQueryData(['waivers']);
+            queryClient.setQueriesData({ queryKey: ['waivers'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((waiver) => waiver.id !== waiverId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((waiver) => waiver.id !== waiverId);
+                }
+                return oldData;
+            });
+            return { previousWaivers };
+        },
+        onError: (_err, variables, context) => {
+            if (context?.previousWaivers) {
+                queryClient.setQueryData(['waivers'], context.previousWaivers);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['waivers'] });
+        },
+    });
+};

package/dist/index.d.ts

@@ -26,6 +26,7 @@ import './client/hooks/labels';
 import './client/hooks/groups';
 import './client/hooks/skills';
 import './client/hooks/proposal';
+import './client/hooks/waivers';
 export * from './types/api';
 export * from './types/auth';
 export * from './types/cache';

package/dist/index.js

@@ -26,6 +26,7 @@ import './client/hooks/labels';
 import './client/hooks/groups';
 import './client/hooks/skills';
 import './client/hooks/proposal';
+import './client/hooks/waivers';
 export * from './types/api';
 export * from './types/auth';
 export * from './types/cache';

package/dist/types/api/Job.d.ts

@@ -2,28 +2,35 @@ import { Task } from "../../types/api/Task";
 import { _Event } from "../../types/api/_Event";
 import { RouteJob } from "../../types/api/RouteJob";
 import { Subscription } from "../../types/api/Subscription";
-export interface Job {
-    address: string;
-    company: string;
-    description: string;
-    id: string;
-    is_one_time: boolean;
-    autostart_radius: number;
-    latitude: number;
-    longitude: number;
-    name: string;
-    internal_notes: string;
-    external_notes: string;
-    priority: number;
-    tasks: Partial<Task>[];
-    time_created: number;
-    time_updated: number | null;
-    routes: RouteJob[];
-    subscribers: Subscription[];
-    manual_emails: string[][];
-    overdue_time: number;
-    last_completed_event: _Event | null;
-    current_event: _Event | null;
-    labels: string[];
-    owner: string;
+declare module '../../types/api/Job' {
+    interface Job {
+        address: string;
+        company: string;
+        description: string;
+        id: string;
+        is_one_time: boolean;
+        autostart_radius: number;
+        latitude: number;
+        longitude: number;
+        name: string;
+        internal_notes: string;
+        external_notes: string;
+        priority: number;
+        tasks: Partial<Task>[];
+        time_created: number;
+        time_updated: number | null;
+        routes: RouteJob[];
+        subscribers: Subscription[];
+        manual_emails: string[][];
+        overdue_time: number;
+        last_completed_event: _Event | null;
+        current_event: _Event | null;
+        labels: string[];
+        owner: string;
+    }
+}
+export declare class Job {
+    constructor(init?: Partial<Job>);
+    portionDone: (fallback?: Date | null, routeJob?: RouteJob) => number;
+    isDone: (fallback?: Date | null, routeJob?: RouteJob) => boolean;
 }

package/dist/types/api/Job.js

@@ -1 +1,23 @@
-export {};
+import { Task } from "../../types/api/Task";
+import { RouteJob } from "../../types/api/RouteJob";
+export class Job {
+    constructor(init) {
+        this.portionDone = (fallback, routeJob) => {
+            if (!this.tasks || this.tasks.length === 0) {
+                return 0;
+            }
+            const contextTasks = routeJob ? this.tasks.filter(t => !t.id || routeJob.tasks.includes(t.id)) : this.tasks;
+            return contextTasks.filter(t => t.isDone?.(fallback)).length / contextTasks.length;
+        };
+        this.isDone = (fallback, routeJob) => {
+            return this.portionDone(fallback, routeJob) === 1;
+        };
+        Object.assign(this, init);
+        if (init?.tasks) {
+            this.tasks = init.tasks.map(t => new Task(t));
+        }
+        if (init?.routes) {
+            this.routes = init.routes.map(r => new RouteJob(r));
+        }
+    }
+}

package/dist/types/api/LineItem.d.ts

@@ -34,6 +34,7 @@ declare module '../../types/api/LineItem' {
     }
 }
 export declare class LineItem {
+    constructor(init?: Partial<LineItem>);
     isPaid: () => boolean;
     isBilled: () => boolean;
     isUnbilled: () => boolean;

package/dist/types/api/LineItem.js

@@ -15,7 +15,7 @@ export const LineItemType = {
     PREPAYMENT: "PREPAYMENT",
 };
 export class LineItem {
-    constructor() {
+    constructor(init) {
         this.isPaid = () => {
             return this.status === LineItemStatus.PAID || this.status === LineItemStatus.PREPAID || this.status === LineItemStatus.EXTERNALLY_PAID;
         };
@@ -25,5 +25,6 @@ export class LineItem {
         this.isUnbilled = () => {
             return !this.isBilled() && !this.isPaid();
         };
+        Object.assign(this, init);
     }
 }

package/dist/types/api/Prepayment.d.ts

@@ -1,10 +1,15 @@
 import { LineItem } from "../../types/api/LineItem";
-export interface Prepayment extends LineItem {
-    id: string;
-    task_id: string | null;
-    line_item_type: "PREPAYMENT";
-    type: "SERVICE" | "MONTH";
-    time_updated: number | null;
-    num_events: number;
-    num_service_months: number;
+declare module '../../types/api/Prepayment' {
+    interface Prepayment extends LineItem {
+        id: string;
+        task_id: string | null;
+        line_item_type: "PREPAYMENT";
+        type: "SERVICE" | "MONTH";
+        time_updated: number | null;
+        num_events: number;
+        num_service_months: number;
+    }
+}
+export declare class Prepayment extends LineItem {
+    constructor(init?: Partial<Prepayment>);
 }

package/dist/types/api/Prepayment.js

@@ -1 +1,7 @@
-export {};
+import { LineItem } from "../../types/api/LineItem";
+export class Prepayment extends LineItem {
+    constructor(init) {
+        super(init);
+        Object.assign(this, init);
+    }
+}

package/dist/types/api/Route.d.ts

@@ -1,19 +1,37 @@
 import { RouteJob } from "../../types/api/RouteJob";
-export interface Route {
-    company: string;
-    id: string;
-    is_internal: boolean;
-    jobs: RouteJob[];
-    name: string;
-    time_created: number;
-    time_updated: number | null;
-    teams: string[];
-    polyline: string;
-    is_optimized: boolean;
-    start_time: number;
-    end_time: number;
-    start_latitude: number;
-    start_longitude: number;
-    end_latitude: number;
-    end_longitude: number;
+export declare const FrequencyType: {
+    readonly ONCE: "ONCE";
+    readonly DAILY: "DAILY";
+    readonly WEEKLY: "WEEKLY";
+    readonly BIWEEKLY: "BIWEEKLY";
+    readonly MONTHLY: "MONTHLY";
+    readonly YEARLY: "YEARLY";
+};
+export type FrequencyType = typeof FrequencyType[keyof typeof FrequencyType];
+declare module '../../types/api/Route' {
+    interface Route {
+        company: string;
+        id: string;
+        is_internal: boolean;
+        jobs: RouteJob[];
+        name: string;
+        time_created: number;
+        time_updated: number | null;
+        teams: string[];
+        polyline: string;
+        is_optimized: boolean;
+        start_time: number;
+        end_time: number;
+        start_latitude: number;
+        start_longitude: number;
+        end_latitude: number;
+        end_longitude: number;
+        frequency: typeof FrequencyType[keyof typeof FrequencyType];
+    }
+}
+export declare class Route {
+    constructor(init?: Partial<Route>);
+    getNextOccurrences: (count?: number) => (Date | null)[];
+    getNextOccurrence: (after?: Date) => Date | null;
+    getIndicatorExpiration: () => Date;
 }

package/dist/types/api/Route.js

@@ -1 +1,82 @@
-export {};
+import { RouteJob } from "../../types/api/RouteJob";
+export const FrequencyType = {
+    ONCE: "ONCE",
+    DAILY: "DAILY",
+    WEEKLY: "WEEKLY",
+    BIWEEKLY: "BIWEEKLY",
+    MONTHLY: "MONTHLY",
+    YEARLY: "YEARLY",
+};
+export class Route {
+    constructor(init) {
+        this.getNextOccurrences = (count = 1) => {
+            let next_occurrences = [];
+            for (let i = 0; i < count; i++) {
+                next_occurrences.push(this.getNextOccurrence(next_occurrences.length > 0 ? next_occurrences[next_occurrences.length - 1] ?? new Date() : new Date()));
+            }
+            return next_occurrences;
+        };
+        this.getNextOccurrence = (after = new Date()) => {
+            let next_occurrence = new Date(this.start_time * 1000);
+            while (next_occurrence <= after) {
+                switch (this.frequency) {
+                    case FrequencyType.ONCE:
+                        return null;
+                    case FrequencyType.DAILY:
+                        next_occurrence.setDate(next_occurrence.getDate() + 1);
+                        break;
+                    case FrequencyType.WEEKLY:
+                        next_occurrence.setDate(next_occurrence.getDate() + 7);
+                        break;
+                    case FrequencyType.BIWEEKLY:
+                        next_occurrence.setDate(next_occurrence.getDate() + 14);
+                        break;
+                    case FrequencyType.MONTHLY:
+                        next_occurrence.setMonth(next_occurrence.getMonth() + 1);
+                        break;
+                    case FrequencyType.YEARLY:
+                        next_occurrence.setFullYear(next_occurrence.getFullYear() + 1);
+                        break;
+                }
+            }
+            return next_occurrence;
+        };
+        this.getIndicatorExpiration = () => {
+            const start_time = new Date(this.start_time * 1000);
+            if (this.frequency === FrequencyType.ONCE) {
+                return start_time;
+            }
+            // if the route is currently active, return the start time as the indicator expiration
+            if (Date.now() > start_time.getTime()) {
+                return start_time;
+            }
+            // else compute the previous occurrence and return that as the indicator expiration
+            const prev = new Date(start_time);
+            switch (this.frequency) {
+                case FrequencyType.DAILY:
+                    prev.setHours(prev.getHours() - 4);
+                    prev.setDate(prev.getDate() - 1);
+                    break;
+                case FrequencyType.WEEKLY:
+                    prev.setDate(prev.getDate() - 8);
+                    break;
+                case FrequencyType.BIWEEKLY:
+                    prev.setDate(prev.getDate() - 15);
+                    break;
+                case FrequencyType.MONTHLY:
+                    prev.setDate(prev.getDate() - 1);
+                    prev.setMonth(prev.getMonth() - 1);
+                    break;
+                case FrequencyType.YEARLY:
+                    prev.setDate(prev.getDate() - 1);
+                    prev.setFullYear(prev.getFullYear() - 1);
+                    break;
+            }
+            return prev;
+        };
+        Object.assign(this, init);
+        if (init?.jobs) {
+            this.jobs = init.jobs.map(j => new RouteJob(j));
+        }
+    }
+}

package/dist/types/api/RouteJob.d.ts

@@ -1,10 +1,15 @@
-export interface RouteJob {
-    time_created: number;
-    route_id: string;
-    job_id: string;
-    id: string;
-    order: number;
-    estimated_arrival_time: number;
-    scheduled_arrival_time: number;
-    tasks: string[];
+declare module '../../types/api/RouteJob' {
+    interface RouteJob {
+        time_created: number;
+        route_id: string;
+        job_id: string;
+        id: string;
+        order: number;
+        estimated_arrival_time: number;
+        scheduled_arrival_time: number;
+        tasks: string[];
+    }
+}
+export declare class RouteJob {
+    constructor(init?: Partial<RouteJob>);
 }

package/dist/types/api/RouteJob.js

@@ -1 +1,5 @@
-export {};
+export class RouteJob {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+}

package/dist/types/api/ServiceMonth.d.ts

@@ -3,5 +3,6 @@ export interface ServiceMonth extends LineItem {
     line_item_type: "SERVICE_MONTH";
     bill_id: string | null;
     tasks: string[];
+    task_names: string[];
     time_updated: number | null;
 }

package/dist/types/api/Task.d.ts

@@ -1,5 +1,6 @@
 import { UserCompanyAssociation } from "../../types/api/UserCompanyAssociation";
 import { Prepayment } from "../../types/api/Prepayment";
+import { PaymentOption } from "../../types/api/PaymentOption";
 import { _Event } from "../../types/api/_Event";
 export declare const TaskStatus: {
     readonly PENDING_CUSTOMER: "PENDING_CUSTOMER";
@@ -15,6 +16,7 @@ declare module '../../types/api/Task' {
     interface Task {
         enforce_proof_amount: boolean;
         events: _Event[];
+        payment_options: PaymentOption[];
         frequency: number;
         id: string;
         job_id: string;
@@ -35,6 +37,7 @@ declare module '../../types/api/Task' {
         skills: string[];
         service: number;
         bill_mode: "MONTH" | "SERVICE" | "NONE";
+        autobill: boolean;
         price: number;
         services_remaining: number;
         activate_on: number | null;
@@ -47,5 +50,9 @@ declare module '../../types/api/Task' {
     }
 }
 export declare class Task {
+    constructor(init?: Partial<Task>);
     computeNextTaskState: (isCustomer: boolean, action: "accept" | "modify" | "reject") => TaskStatus;
+    getPrepaidEventsRemaining: () => number;
+    getPrepaidMonthsRemaining: () => number;
+    isDone: (fallback?: Date | null) => boolean | 1;
 }

package/dist/types/api/Task.js

@@ -1,3 +1,4 @@
+import { Prepayment } from "../../types/api/Prepayment";
 export const TaskStatus = {
     PENDING_CUSTOMER: "PENDING_CUSTOMER",
     PENDING_COMPANY: "PENDING_COMPANY",
@@ -8,7 +9,7 @@ export const TaskStatus = {
     PENDING_ACTIVATION: "PENDING_ACTIVATION"
 };
 export class Task {
-    constructor() {
+    constructor(init) {
         this.computeNextTaskState = (isCustomer, action) => {
             if (action === "accept") {
                 if (this.status === TaskStatus.PENDING_CUSTOMER || this.status === TaskStatus.PENDING_COMPANY) {
@@ -34,5 +35,40 @@ export class Task {
             }
             return this.status;
         };
+        this.getPrepaidEventsRemaining = () => {
+            return this.prepayments.reduce((acc, prepayment) => {
+                if (prepayment.isPaid()) {
+                    return acc + prepayment.amount - prepayment.num_events;
+                }
+                return acc;
+            }, 0);
+        };
+        this.getPrepaidMonthsRemaining = () => {
+            return this.prepayments.reduce((acc, prepayment) => {
+                if (prepayment.isPaid()) {
+                    return acc + prepayment.amount - prepayment.num_service_months;
+                }
+                return acc;
+            }, 0);
+        };
+        this.isDone = (fallback) => {
+            if (!this.status || this.status !== TaskStatus.ACTIVE) {
+                return 1;
+            }
+            if (this.frequency > 0) {
+                return this.overdue_time <= 0;
+            }
+            else if (fallback) {
+                // If frequency is 0, use fallback
+                return new Date((this.last_completed_event?.time_ended ?? 0) * 1000) > (fallback);
+            }
+            else {
+                return this.last_completed_event?.time_ended ? true : false;
+            }
+        };
+        Object.assign(this, init);
+        if (init?.prepayments) {
+            this.prepayments = init.prepayments.map(p => new Prepayment(p));
+        }
     }
 }

package/dist/types/api/User.d.ts

@@ -7,6 +7,7 @@ export interface User {
     username: string;
     first_name: string;
     last_name: string;
+    email_verified: boolean;
     verified: boolean;
     email: string | null;
     phone_number: string | null;

package/dist/types/api/UserCompanyAssociation.d.ts

@@ -1,4 +1,5 @@
 import { User } from "../../types/api/User";
+import { Location } from "../../types/api";
 export declare const Permission: {
     readonly CAN_WRITE_COMPANY: "can_write_company";
     readonly CAN_READ_GROUPS: "can_read_groups";

package/dist/types/api/Waiver.d.ts

@@ -0,0 +1,9 @@
+export interface Waiver {
+    id: string;
+    name: string;
+    contents: string;
+    signed_users: string[];
+    company_id: string;
+    time_created: number | null;
+    time_updated: number | null;
+}

package/dist/types/api/Waiver.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/_Event.d.ts

@@ -1,19 +1,26 @@
 import { LineItem } from "../../types/api/LineItem";
 import { AdditionalCharge } from "../../types/api/AdditionalCharge";
 import { UserEvent } from "../../types/api/UserEvent";
-export interface _Event extends LineItem {
-    breaks: string[];
-    line_item_type: "EVENT";
-    internal_notes: string;
-    external_notes: string;
-    proofs: string[];
-    tasks: string[];
-    time_ended: number | null;
-    time_started: number;
-    time_updated: number | null;
-    bill_id: string;
-    billed_amount: number;
-    additional_charges: AdditionalCharge[];
-    users: UserEvent[];
-    autostart: boolean;
+declare module '../../types/api/_Event' {
+    interface _Event extends LineItem {
+        breaks: string[];
+        line_item_type: "EVENT";
+        internal_notes: string;
+        external_notes: string;
+        proofs: string[];
+        tasks: string[];
+        task_names: string[];
+        time_ended: number | null;
+        time_started: number;
+        time_updated: number | null;
+        bill_id: string;
+        billed_amount: number;
+        additional_charges: AdditionalCharge[];
+        users: UserEvent[];
+        autostart: boolean;
+    }
+}
+export declare class _Event extends LineItem {
+    constructor(init?: Partial<_Event>);
+    getCost: () => number;
 }

package/dist/types/api/_Event.js

@@ -1 +1,18 @@
-export {};
+import { LineItem } from "../../types/api/LineItem";
+export class _Event extends LineItem {
+    constructor(init) {
+        super(init);
+        this.getCost = () => {
+            const additionalChargesCost = this.additional_charges.reduce((acc, charge) => acc + (charge.cost ?? 0) * (charge.amount ?? 0), 0);
+            return (this.cost * this.amount) + additionalChargesCost;
+        };
+        Object.assign(this, init);
+        this.breaks = init?.breaks ?? [];
+        this.proofs = init?.proofs ?? [];
+        this.tasks = init?.tasks ?? [];
+        this.task_names = init?.task_names ?? [];
+        this.additional_charges = init?.additional_charges ?? [];
+        this.users = init?.users ?? [];
+        this.autostart = init?.autostart ?? false;
+    }
+}