@kiminix/tp-client 1.35.0 → 1.37.0

package/dist/reservations/admin/admin-apis.js

@@ -35,10 +35,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import axios from "axios";
-import { format } from "date-fns";
-import { Left, Right } from "purify-ts";
 import { base } from "../../constants";
-import { ErrorWithMetadata } from "../../types";
 import { RequestUtils } from "../../utils/request-utils";
 import { parseReservationDeal } from "../shared/reservation-deal";
 var ReservationsAdminAPIs = /** @class */ (function () {
@@ -161,11 +158,17 @@ var ReservationsAdminAPIs = /** @class */ (function () {
             });
         });
     };
+    /**
+     *
+     * @param props
+     * @throws invalid_total, unauthorized_action, not_found, unauthorized, internal_error
+     * @returns
+     */
     ReservationsAdminAPIs.patchStatus = function (props) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, axios.patch(base + "/reservations/admin", {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.patch(base + "/reservations/admin", {
                             id: props.id,
                             status: props.status,
                             cancellation: props.cancellation
@@ -174,63 +177,103 @@ var ReservationsAdminAPIs = /** @class */ (function () {
                                 'Authorization': "".concat(props.token)
                             }
                         })
-                            .then(function (response) { return Right(response.data); })
-                            .catch(function (error) {
-                            // handle error
-                            if (error.response.status == 401)
-                                return Left(Error("unauthorized"));
-                            else if (error.response.status == 404)
-                                return Left(Error("not_found"));
-                            else if (error.response.status == 400) {
-                                var response = error.response.data;
-                                return Left(Error(response.code));
+                            .then(function (_) { return undefined; });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws unauthorized_action, not_found, unauthorized, internal_error
+     * @returns
+     */
+    ReservationsAdminAPIs.patchTotal = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.patch(base + "/reservations/admin/total", {
+                            id: props.id,
+                            total: props.total
+                        }, {
+                            headers: {
+                                'Authorization': "".concat(props.token)
                             }
-                            else
-                                return Left(Error('internal_error'));
-                        })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
+                        })
+                            .then(function (_) { return undefined; });
+                    })];
             });
         });
     };
-    ReservationsAdminAPIs.reserve = function (props) {
+    /**
+     *
+     * @param props
+     * @throws unauthorized, internal_error
+     * @returns
+     */
+    ReservationsAdminAPIs.updateClosingDays = function (props) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, axios.post(base + "/reservations/admin", {
-                            user: props.user,
-                            datetime: format(props.datetime, "yyyy-MM-dd'T'HH:mm"),
-                            notes: props.notes,
-                            commands: props.commands
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.patch(base + "/reservations/admin/closing-days", {
+                            date: props.date,
+                            time: props.time,
+                            isOpen: props.isOpen
                         }, {
                             headers: {
-                                'Authorization': "".concat(props.token),
-                                'Content-Type': 'application/json'
+                                'Authorization': "".concat(props.token)
                             }
                         })
-                            .then(function (_) { return Right(undefined); })
-                            .catch(function (error) {
-                            // handle error
-                            if (error.response.status == 401)
-                                return Left(Error("unauthorized"));
-                            else if (error.response.status == 400) {
-                                //   unavailable_day
-                                //   inactive_manual_booking
-                                //   expired_preview
-                                //   invalid_guest_number
-                                //   min_booking_amount
-                                var response = error.response.data;
-                                return Left(new ErrorWithMetadata(response.code, response.metadata));
+                            .then(function (_) { return undefined; });
+                    })];
+            });
+        });
+    };
+    /**
+    *
+    * @param props
+    * @throws unauthorized, internal_error
+    * @returns
+    */
+    ReservationsAdminAPIs.getClosingDays = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/admin/closing-days", {
+                            headers: {
+                                'Authorization': "".concat(props.token)
                             }
-                            else
-                                return Left(Error('internal_error'));
-                        })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
+                        })
+                            .then(function (response) { return response.data; });
+                    })];
+            });
+        });
+    };
+    /**
+    *
+    * @param props
+    * @throws closed_business, unauthorized, internal_error
+    * @returns
+    */
+    ReservationsAdminAPIs.getTimeSlots = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/admin/date/".concat(props.date, "/time-slots"), {
+                            headers: {
+                                'Authorization': "".concat(props.token)
+                            }
+                        })
+                            .then(function (response) { return response.data; });
+                    })];
             });
         });
     };
-    // API for private admins
+    /**
+     *
+     * API for private admins
+     *
+     * */
     ReservationsAdminAPIs.getByIdPrivate = function (props) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {

package/dist/reservations/admin/types.d.ts

@@ -0,0 +1,19 @@
+import { LocalDate, LocalTime } from "../../types";
+export interface GetTransitionsRequest {
+    token?: string;
+    reservationId: string;
+}
+export interface GetByIdAdminRequest {
+    token?: string;
+    id: string;
+}
+export interface TimeSlot {
+    hour: LocalTime;
+    isClosed: boolean;
+}
+export interface ClosingDays {
+    from: LocalDate;
+    to: LocalDate;
+    fullyClosedDays: LocalDate[];
+    partiallyClosedDays: LocalDate[];
+}

package/dist/reservations/index.d.ts

@@ -1,12 +1,10 @@
-export * from "./user/types/resp-reservation-settings";
+export * from "./user/types/response-api";
 export * from './user/types/resp-reservation-preview';
-export * from "./user/types/resp-save-reservation";
 export * from "./user/types/req-get-by-id";
 export * from "./user/types/req-get-page-reservation";
 export { ReservationsUserAPIs } from './user/user-apis';
-export { ReservationsGuestAPIs } from './user/user-apis';
-export * from "./admin/types/get-available-transitions";
-export * from "./admin/types/get-id";
+export { ReservationsGuestAPIs } from './user/guest-apis';
+export * from "./admin/types";
 export { ReservationsAdminAPIs } from './admin/admin-apis';
 export * from './shared/reservation';
 export * from './shared/reservation-deal';

package/dist/reservations/index.js

@@ -1,15 +1,13 @@
 // user module
-export * from "./user/types/resp-reservation-settings";
+export * from "./user/types/response-api";
 export * from './user/types/resp-reservation-preview';
-export * from "./user/types/resp-save-reservation";
 export * from "./user/types/req-get-by-id";
 export * from "./user/types/req-get-page-reservation";
 export { ReservationsUserAPIs } from './user/user-apis';
 // guest module
-export { ReservationsGuestAPIs } from './user/user-apis';
+export { ReservationsGuestAPIs } from './user/guest-apis';
 // admin module
-export * from "./admin/types/get-available-transitions";
-export * from "./admin/types/get-id";
+export * from "./admin/types";
 export { ReservationsAdminAPIs } from './admin/admin-apis';
 // shared module
 export * from './shared/reservation';

package/dist/reservations/shared/reservation-deal.d.ts

@@ -1,20 +1,21 @@
 import { CashbackStatus, Level, ReservationDealKind } from "../../enum";
 export interface Discount {
     type: ReservationDealKind.Discount;
-    value: number;
-    specialCode: string | undefined;
+    rate: number;
 }
 export interface CashbackEarn {
     type: ReservationDealKind.CashbackEarn;
-    value: number;
-    level: Level;
     rate: number;
+    level: Level;
+    value: number | undefined;
     status: CashbackStatus;
 }
 export interface CashbackApply {
     type: ReservationDealKind.CashBackApply;
-    value: number;
+    rate: number;
     status: CashbackStatus;
+    wanted: number;
+    applied: number | undefined;
 }
 export type ReservationDeal = Discount | CashbackEarn | CashbackApply;
 export declare function parseReservationDeal(json: any): ReservationDeal;

package/dist/reservations/shared/reservation.d.ts

@@ -6,6 +6,8 @@ export interface BusinessOfReservation {
     name: string;
     phones: string[];
     address: string;
+    googleMapUrl: string;
+    maxCashbackApply: number | undefined;
 }
 export interface User {
     id: string | undefined;
@@ -15,18 +17,6 @@ export interface User {
     email: string | undefined;
     verifiedPhone: boolean;
 }
-export interface GuestDetails {
-    number: number;
-    price: number;
-    priceBeforeDeal?: number;
-}
-export interface OnMenuCommand {
-    id: string;
-    presetMenuId: string;
-    title: string;
-    adults: GuestDetails;
-    children?: GuestDetails;
-}
 export interface ReservationEvent {
     kind: ReservationEventKind;
     at: string;
@@ -37,18 +27,16 @@ export interface Cancellation {
 }
 export interface Reservation {
     id: string;
-    isSetByAdmin: boolean;
     createdAt: string;
     business: BusinessOfReservation;
     user: User;
     datetime: string;
-    status: ReservationStatus;
-    total: number;
-    totalBeforeDeal?: number;
-    deposit?: number;
+    persons: number;
+    total: number | undefined;
     deal: ReservationDeal | undefined;
-    onMenuCommands: OnMenuCommand[];
+    status: ReservationStatus;
+    notesAdmin: string | undefined;
+    notesUser: string | undefined;
     events?: ReservationEvent[];
-    notes?: string;
     cancellation?: Cancellation;
 }

package/dist/reservations/user/guest-apis.d.ts

@@ -0,0 +1,84 @@
+import { ReservationDealKind, TimelineDirection } from "../../enum";
+import { LocalDate, LocalTime } from "../../types";
+import { AvailableDeals, DaysInfo, HourInfo, ReservationResponse } from "../index";
+import { Reservation } from "../shared/reservation";
+export declare class ReservationsGuestAPIs {
+    /**
+     *
+     * @throws unauthorized, internal_error
+     * @returns
+     */
+    static getPage(props: {
+        deviceId: string;
+        page: number;
+        size: number;
+        direction: TimelineDirection;
+    }): Promise<Reservation[]>;
+    /**
+     *
+     * @param props
+     * @throws   invalid_guest_number, unavailable_day, closed_hour, discount_not_allowed
+     * @returns
+     */
+    static reserve(props: {
+        guest: {
+            deviceId: string;
+            firstName: string;
+            lastName: string;
+            phone: string;
+            email: string | undefined;
+        };
+        businessId: string;
+        datetime: Date;
+        persons: number;
+        deal: ReservationDealKind | undefined;
+        notes: string | undefined;
+    }): Promise<ReservationResponse>;
+    /**
+     *
+     * @param props
+     * @throws closed_business
+     * @returns get closed days and discounts by business
+     */
+    static getDays(props: {
+        businessId: string;
+    }): Promise<DaysInfo>;
+    /**
+     *
+     * @param props
+     * @throws closed_business, invalid_day, unavailable_slots
+     * @returns
+     */
+    static getHours(props: {
+        businessId: string;
+        day: LocalDate;
+    }): Promise<HourInfo[]>;
+    /**
+     *
+     * @param props
+     * @throws reservation_not_found, internal_error
+     * @returns
+     */
+    static get(props: {
+        id: string;
+    }): Promise<Reservation>;
+    /**
+     *
+     * @param props
+     * @throws invalid_datetime
+     * @returns
+     */
+    static getAvailableDeals(props: {
+        businessId: string;
+        date: LocalDate;
+        time: LocalTime;
+    }): Promise<AvailableDeals>;
+    /**
+     *
+     * @param id
+     * @param token
+     * @throws not_found, internal_error, unauthorized_action
+     * @returns
+     */
+    static cancel(id: string, device_id: string): Promise<any>;
+}

package/dist/reservations/user/guest-apis.js

@@ -0,0 +1,199 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import axios from "axios";
+import { format } from "date-fns";
+import { base } from "../../constants";
+import { RequestUtils } from "../../utils/request-utils";
+import { parseReservationDeal } from "../shared/reservation-deal";
+// GUEST APIS
+var ReservationsGuestAPIs = /** @class */ (function () {
+    function ReservationsGuestAPIs() {
+    }
+    /**
+     *
+     * @throws unauthorized, internal_error
+     * @returns
+     */
+    ReservationsGuestAPIs.getPage = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/guest?device_id=".concat(props.deviceId, "&page=").concat(props.page, "&size=").concat(props.size, "&direction=").concat(props.direction), {
+                            headers: {}
+                        })
+                            .then(function (response) {
+                            var result = response.data;
+                            for (var i = 0; i < result.length; i++) {
+                                result[i].deal = result[i].deal ? parseReservationDeal(result[i].deal) : undefined;
+                            }
+                            return result;
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws   invalid_guest_number, unavailable_day, closed_hour, discount_not_allowed
+     * @returns
+     */
+    ReservationsGuestAPIs.reserve = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.post(base + "/reservations/guest", {
+                            guest: {
+                                deviceId: props.guest.deviceId,
+                                firstName: props.guest.firstName,
+                                lastName: props.guest.lastName,
+                                phone: props.guest.phone,
+                                email: props.guest.email,
+                            },
+                            businessId: props.businessId,
+                            datetime: format(props.datetime, "yyyy-MM-dd'T'HH:mm"),
+                            persons: props.persons,
+                            deal: props.deal,
+                            notes: props.notes
+                        }, {
+                            headers: {
+                                'Content-Type': 'application/json'
+                            }
+                        })
+                            .then(function (response) { return response.data; });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws closed_business
+     * @returns get closed days and discounts by business
+     */
+    ReservationsGuestAPIs.getDays = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/guest/days?business=".concat(props.businessId), { headers: {} })
+                            .then(function (response) {
+                            return response.data;
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws closed_business, invalid_day, unavailable_slots
+     * @returns
+     */
+    ReservationsGuestAPIs.getHours = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/guest/hours?business=".concat(props.businessId, "&day=").concat(props.day), { headers: {} })
+                            .then(function (response) {
+                            return response.data;
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws reservation_not_found, internal_error
+     * @returns
+     */
+    ReservationsGuestAPIs.get = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/guest/".concat(props.id), {
+                            headers: {
+                                'Content-Type': 'application/json'
+                            }
+                        })
+                            .then(function (response) {
+                            var result = response.data;
+                            result.deal = result.deal ? parseReservationDeal(result.deal) : undefined;
+                            return result;
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param props
+     * @throws invalid_datetime
+     * @returns
+     */
+    ReservationsGuestAPIs.getAvailableDeals = function (props) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.get(base + "/reservations/guest/deals/available?business=".concat(props.businessId, "&date=").concat(props.date, "&time=").concat(props.time), { headers: {} })
+                            .then(function (response) {
+                            return response.data;
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     *
+     * @param id
+     * @param token
+     * @throws not_found, internal_error, unauthorized_action
+     * @returns
+     */
+    ReservationsGuestAPIs.cancel = function (id, device_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, RequestUtils.send(function () {
+                        return axios.patch(base + "/reservations/guest/".concat(id, "/cancel?device_id=").concat(device_id), {}, {})
+                            .then(function (response) { return response.data; });
+                    })];
+            });
+        });
+    };
+    return ReservationsGuestAPIs;
+}());
+export { ReservationsGuestAPIs };

package/dist/reservations/user/types/response-api.d.ts

@@ -0,0 +1,32 @@
+import { Level } from "../../../enum";
+import { LocalDate, LocalTime } from "../../../types";
+export interface ReservationResponse {
+    id: string;
+}
+export interface DaysInfo {
+    from: LocalDate;
+    to: LocalDate;
+    closed: LocalDate[];
+    discounts: Record<LocalDate, number>;
+}
+export interface HourInfo {
+    time: LocalTime;
+    discount: number | undefined;
+}
+export interface AvailableDeals {
+    discount: AvailableDiscount | undefined;
+    cashbackApply: AvailableCashbackApply | undefined;
+    cashbackEarn: AvailableCashbackEarn | undefined;
+}
+export interface AvailableDiscount {
+    rate: number;
+    terms: string[];
+}
+export interface AvailableCashbackApply {
+    max: number;
+    value: number;
+}
+export interface AvailableCashbackEarn {
+    rate: number;
+    level: Level;
+}