@goweekdays/layer-common 0.0.6 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @goweekdays/layer-common
 
+## 0.0.7
+
+### Patch Changes
+
+- 3b7164b: add promo code
+
 ## 0.0.6
 
 ### Patch Changes

package/components/Input/NewDate.vue

@@ -0,0 +1,123 @@
+<script setup lang="ts">
+import { defineModel, defineProps, computed, ref } from "vue";
+
+const props = defineProps<{
+  rules?: ((value: string) => boolean | string)[]; // Accepts external validation rules
+}>();
+
+const dateValue = defineModel<string>({ default: "" });
+const inputRef = ref<HTMLInputElement | null>(null);
+
+const formatDate = (event: Event) => {
+  const input = event.target as HTMLInputElement;
+  let value = input.value.replace(/\D/g, ""); // Remove non-numeric characters
+
+  // Format as MM/DD/YYYY
+  let formattedValue = value
+    .slice(0, 8)
+    .replace(/(\d{2})(\d{0,2})?(\d{0,4})?/, (_, m, d, y) =>
+      [m, d, y].filter(Boolean).join("/")
+    );
+
+  // Preserve cursor position
+  const cursorPosition = input.selectionStart ?? 0;
+  const slashCountBefore = (dateValue.value.match(/\//g) || []).length;
+  const slashCountAfter = (formattedValue.match(/\//g) || []).length;
+  const cursorOffset = slashCountAfter - slashCountBefore;
+
+  // Only update if value changed to prevent unnecessary reactivity updates
+  if (dateValue.value !== formattedValue) {
+    dateValue.value = formattedValue;
+    setTimeout(() => {
+      input.setSelectionRange(
+        cursorPosition + cursorOffset,
+        cursorPosition + cursorOffset
+      );
+    });
+  }
+};
+
+// Compute combined validation rules
+const computedRules = computed(() => {
+  return props.rules ? [...props.rules] : [];
+});
+
+// Handle arrow key increments with cursor preservation
+const handleArrowKeys = (event: KeyboardEvent) => {
+  if (!dateValue.value) return;
+
+  const input = event.target as HTMLInputElement;
+  const cursorPosition = input.selectionStart ?? 0; // Store cursor position
+  dateValue.value.split("/").map(Number);
+
+  let updatedDate = dateValue.value;
+
+  // Determine which part to modify
+  if (cursorPosition <= 2) {
+    updatedDate = modifyDatePart(
+      dateValue.value,
+      "month",
+      event.key === "ArrowUp" ? 1 : -1
+    );
+  } else if (cursorPosition <= 5) {
+    updatedDate = modifyDatePart(
+      dateValue.value,
+      "day",
+      event.key === "ArrowUp" ? 1 : -1
+    );
+  } else {
+    updatedDate = modifyDatePart(
+      dateValue.value,
+      "year",
+      event.key === "ArrowUp" ? 1 : -1
+    );
+  }
+
+  if (dateValue.value !== updatedDate) {
+    dateValue.value = updatedDate;
+    setTimeout(() => {
+      input.setSelectionRange(cursorPosition, cursorPosition);
+    });
+  }
+
+  event.preventDefault();
+};
+
+const modifyDatePart = (
+  date: string,
+  part: "month" | "day" | "year",
+  change: number
+) => {
+  let [month, day, year] = date.split("/").map(Number);
+
+  if (part === "month") {
+    month = Math.max(1, Math.min(12, month + change));
+    const maxDays = new Date(year, month, 0).getDate();
+    day = Math.min(day, maxDays); // Adjust day to fit new month's max days
+  } else if (part === "day") {
+    const maxDays = new Date(year, month, 0).getDate();
+    day = Math.max(1, Math.min(maxDays, day + change));
+  } else if (part === "year") {
+    year += change;
+    const maxDays = new Date(year, month, 0).getDate();
+    day = Math.min(day, maxDays); // Adjust day to fit new year's month
+  }
+
+  return `${String(month).padStart(2, "0")}/${String(day).padStart(
+    2,
+    "0"
+  )}/${year}`;
+};
+</script>
+
+<template>
+  <v-text-field
+    ref="inputRef"
+    v-model="dateValue"
+    placeholder="MM/DD/YYYY"
+    @input="formatDate"
+    @keydown.up="handleArrowKeys"
+    @keydown.down="handleArrowKeys"
+    :rules="computedRules"
+  ></v-text-field>
+</template>

package/components/Input/Number.vue

@@ -1,18 +1,29 @@
 <script setup lang="ts">
 import { ref, computed, nextTick, useAttrs } from "vue";
 
+const props = defineProps({
+  infinityEnabled: { type: Boolean, default: false }, // Enable ∞ display for 0
+});
+
 const modelValue = defineModel<number>(); // Store actual number
-const inputRef = ref<HTMLInputElement | null>(null); // Reference input field
-const attrs = useAttrs(); // Get all passed attributes (rules, required, etc.)
+const inputRef = ref<HTMLInputElement | null>(null);
+const attrs = useAttrs();
 
-let cursorPosition = 0; // Track cursor position
-let forceCursorToEnd = false; // Track if cursor should be forced to end
+let cursorPosition = 0;
+let forceCursorToEnd = false;
 
-// Computed property to format value with commas
+// Computed property to format value with commas or infinity sign
 const formattedValue = computed({
-  get: () =>
-    modelValue.value !== undefined ? modelValue.value.toLocaleString() : "",
+  get: () => {
+    if (props.infinityEnabled && modelValue.value === 0) return "∞"; // Show ∞ if enabled
+    return modelValue.value?.toLocaleString() ?? "";
+  },
   set: (val: string) => {
+    if (props.infinityEnabled && val === "∞") {
+      modelValue.value = 0; // Convert back to 0 internally
+      return;
+    }
+
     const rawValue = val.replace(/\D/g, ""); // Remove non-numeric characters
     const numericValue = rawValue ? Number(rawValue) : 0;
 
@@ -30,7 +41,6 @@ const handleKeyDown = (event: KeyboardEvent) => {
   const { selectionStart, selectionEnd, value } = inputRef.value;
   const isAllSelected = selectionStart === 0 && selectionEnd === value.length;
 
-  // Allow only numbers (prevent non-numeric input)
   if (
     !/^\d$/.test(event.key) &&
     ![
@@ -46,7 +56,6 @@ const handleKeyDown = (event: KeyboardEvent) => {
     return;
   }
 
-  // If all text is selected and a number is pressed, replace entire value
   if (isAllSelected && /^\d$/.test(event.key)) {
     event.preventDefault();
     modelValue.value = Number(event.key);
@@ -55,13 +64,11 @@ const handleKeyDown = (event: KeyboardEvent) => {
     return;
   }
 
-  // Allow cursor movement with ArrowLeft & ArrowRight
   if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
     forceCursorToEnd = false;
     return;
   }
 
-  // Force cursor to end when incrementing/decrementing
   if (event.key === "ArrowUp") {
     event.preventDefault();
     modelValue.value += 1;
@@ -71,21 +78,21 @@ const handleKeyDown = (event: KeyboardEvent) => {
     modelValue.value = Math.max(0, modelValue.value - 1);
     forceCursorToEnd = true;
   } else {
-    cursorPosition = selectionStart || 0; // Store cursor position before input
+    cursorPosition = selectionStart || 0;
   }
 
   nextTick(() => restoreCursor());
 };
 
-// Restore cursor position correctly
+// Restore cursor position
 const restoreCursor = () => {
   if (!inputRef.value) return;
   const length = formattedValue.value.length;
 
   if (forceCursorToEnd) {
-    inputRef.value.setSelectionRange(length, length); // Keep cursor at end
+    inputRef.value.setSelectionRange(length, length);
   } else {
-    inputRef.value.setSelectionRange(cursorPosition, cursorPosition); // Keep normal position
+    inputRef.value.setSelectionRange(cursorPosition, cursorPosition);
   }
 };
 </script>
@@ -96,7 +103,22 @@ const restoreCursor = () => {
     v-model="formattedValue"
     v-bind="attrs"
     type="text"
-    placeholder="Enter a number"
     @keydown="handleKeyDown"
-  ></v-text-field>
+  >
+    <template v-if="$slots.prepend" v-slot:prepend>
+      <slot name="prepend"></slot>
+    </template>
+
+    <template v-if="$slots.append" v-slot:append>
+      <slot name="append"></slot>
+    </template>
+
+    <template v-if="$slots['append-inner']" v-slot:append-inner>
+      <slot name="append-inner"></slot>
+    </template>
+
+    <template v-if="$slots['prepend-inner']" v-slot:prepend-inner>
+      <slot name="prepend-inner"></slot>
+    </template>
+  </v-text-field>
 </template>

package/composables/useOrder.ts

@@ -0,0 +1,22 @@
+export default function useOrder() {
+  function getOrders({
+    search = "",
+    id = "",
+    page = 1,
+    status = "succeeded",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/orders", {
+      method: "GET",
+      query: {
+        search,
+        id,
+        page,
+        status,
+      },
+    });
+  }
+
+  return {
+    getOrders,
+  };
+}

package/composables/usePromoCode.ts

@@ -0,0 +1,34 @@
+export default function usePromoCode() {
+  function add(value: TPromoCode) {
+    return useNuxtApp().$api<Record<string, any>>("/api/promo-codes", {
+      method: "POST",
+      body: value,
+    });
+  }
+
+  function getPromoCodes({ search = "", page = 1, status = "active" } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/promo-codes", {
+      method: "GET",
+      query: {
+        search,
+        page,
+        status,
+      },
+    });
+  }
+
+  function getByCode(code: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/promo-codes/code/${code}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  return {
+    add,
+    getPromoCodes,
+    getByCode,
+  };
+}

package/composables/useSubscription.ts

@@ -13,6 +13,12 @@ export default function useSubscription() {
     return useNuxtApp().$api<TSubscription>(`/api/subscriptions/id/${id}`);
   }
 
+  function getByAffiliateId(id: string) {
+    return useNuxtApp().$api<TSubscription>(
+      `/api/subscriptions/affiliate/${id}`
+    );
+  }
+
   function getByOrgId(id: string) {
     return useNuxtApp().$api<Record<string, any>>(
       `/api/subscriptions/org/${id}`
@@ -40,37 +46,35 @@ export default function useSubscription() {
     () => "inactive"
   );
 
-  async function checkSubscription() {
+  async function affSubscriptionStatus() {
     const { currentUser } = useLocalAuth();
 
     if (currentUser.value && currentUser.value._id) {
       try {
-        const result = await getSubscriptionStatusById(currentUser.value._id);
-        affiliateSubscription.value = result.status;
+        const result = await getByAffiliateId(currentUser.value._id);
+        affiliateSubscription.value = result.status as string;
       } catch (error) {
         console.error("failed to get the subscription", error);
       }
     }
   }
 
-  function initAffiliateSubscription(
-    customer_id: string,
-    amount: number,
-    payment_method_id: string,
-    currency?: string
-  ) {
-    return useNuxtApp().$api("/api/subscriptions/affiliate", {
-      method: "POST",
-      body: {
-        customer_id,
-        amount,
-        payment_method_id,
-        currency,
-      },
-    });
+  const orgSubscription = useState("orgSubscription", () => "inactive");
+
+  async function orgSubscriptionStatus() {
+    const { currentOrg } = useOrg();
+
+    if (currentOrg.value) {
+      try {
+        const result = await getByOrgId(currentOrg.value);
+        orgSubscription.value = result.status as string;
+      } catch (error) {
+        console.error("failed to get the subscription", error);
+      }
+    }
   }
 
-  type TOrgSubscription = {
+  type TSub = {
     customer_id: string;
     amount: number;
     payment_method_id: string;
@@ -82,12 +86,12 @@ export default function useSubscription() {
     payment_method_cvv?: string;
     payment_method_cardholder_name?: string;
     currency?: string;
-    seats: number;
-    organization: TOrg;
+    seats?: number;
+    organization?: TOrg;
     billingAddress: TAddress;
   };
 
-  function initOrgSubscription(value: TOrgSubscription) {
+  function initOrgSubscription(value: TSub) {
     return useNuxtApp().$api<Record<string, any>>(
       "/api/subscriptions/organization",
       {
@@ -97,16 +101,29 @@ export default function useSubscription() {
     );
   }
 
+  function initAffiliateSubscription(value: TSub) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/subscriptions/affiliate",
+      {
+        method: "POST",
+        body: value,
+      }
+    );
+  }
+
   return {
     add,
     getById,
     getByOrgId,
     getSubscriptions,
+    affSubscriptionStatus,
     affiliateSubscription,
-    checkSubscription,
+    orgSubscriptionStatus,
+    orgSubscription,
     getSubscriptionStatusById,
     cancelSubscription,
     initAffiliateSubscription,
     initOrgSubscription,
+    getByAffiliateId,
   };
 }

package/composables/useUtils.ts

@@ -6,6 +6,31 @@ export default function useUtils() {
     return regex.test(v) || "Please enter a valid email address";
   };
 
+  const validateDate = (value: string): boolean | string => {
+    const dateRegex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+
+    if (!dateRegex.test(value)) return "Invalid date format (MM/DD/YYYY)";
+
+    return true;
+  };
+
+  const minOneMonthAdvance = (value: string): boolean | string => {
+    if (!/^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/.test(value)) {
+      return "Invalid date format (MM/DD/YYYY)";
+    }
+
+    const [month, day, year] = value.split("/").map(Number);
+    const selectedDate = new Date(year, month - 1, day);
+
+    const currentDate = new Date();
+    const minDate = new Date();
+    minDate.setMonth(currentDate.getMonth() + 1); // 1 month in advance
+
+    return (
+      selectedDate >= minDate || "Date must be at least 1 month in advance"
+    );
+  };
+
   const passwordRule = (v: string) =>
     v.length >= 8 || "Password must be at least 8 characters long";
 
@@ -180,5 +205,7 @@ export default function useUtils() {
     getCountries,
     formatter,
     formatNumber,
+    validateDate,
+    minOneMonthAdvance,
   };
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@goweekdays/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "main": "./nuxt.config.ts",
   "publishConfig": {
     "access": "public"

package/pages/index.vue

@@ -0,0 +1,3 @@
+<template>
+  <h1>index</h1>
+</template>

package/pages/payment-method-linked.vue

@@ -0,0 +1,31 @@
+<template>
+  <v-row no-gutters class="fill-height" justify="center" align-content="center">
+    <v-card class="pa-4" elevation="4" color="success lighten-1">
+      <v-card-title class="text-white d-flex align-center">
+        <v-icon class="mr-2">mdi-check-circle</v-icon>
+        Successfully Linked Payment Method
+      </v-card-title>
+
+      <v-card-actions class="d-flex justify-center">
+        <v-btn
+          color="white"
+          variant="tonal"
+          rounded="xl"
+          size="large"
+          @click="closeWindow"
+          >Close</v-btn
+        >
+      </v-card-actions>
+    </v-card>
+  </v-row>
+</template>
+
+<script setup>
+definePageMeta({
+  layout: "plain",
+});
+
+const closeWindow = () => {
+  window.close();
+};
+</script>

package/types/promo-code.d.ts

@@ -0,0 +1,19 @@
+declare type TPromoTier = {
+  min: number;
+  max: number;
+  price: number;
+};
+
+declare type TPromoCode = {
+  _id?: ObjectId;
+  code: string;
+  description?: string;
+  type: "tiered" | "fixed";
+  tiers?: TPromoTier[];
+  fixed_rate?: number;
+  appliesTo?: string; // "subscription" | "order"
+  createdAt?: string; // Date of creation
+  expiresAt?: string; // Optional expiry
+  assignedTo?: string | ObjectId; // Store the only ape who used it
+  status?: "active" | "expired" | "disabled";
+};