Add OTP login page and auth guard for client cabinet

2026-04-01 19:10:18 +07:00
parent b4537c1483
commit 1c4fd847dc
9 changed files with 605 additions and 1 deletions
--- a/app/composables/graphql/generated.ts
+++ b/app/composables/graphql/generated.ts
@@ -32,6 +32,21 @@ export type AddBonusTransactionInput = {
  userId: Scalars['ID']['input'];
 };

+export type AuthCodeRequestResult = {
+  __typename?: 'AuthCodeRequestResult';
+  challengeToken: Scalars['String']['output'];
+  channel: LoginChannel;
+  destination: Scalars['String']['output'];
+  expiresAt: Scalars['DateTime']['output'];
+};
+
+export type AuthSession = {
+  __typename?: 'AuthSession';
+  accessToken: Scalars['String']['output'];
+  expiresAt: Scalars['DateTime']['output'];
+  user: User;
+};
+
 export type BlockOrderInput = {
  orderId: Scalars['ID']['input'];
  reason: Scalars['String']['input'];
@@ -87,6 +102,12 @@ export type Invitation = {
  token: Scalars['String']['output'];
 };

+export enum LoginChannel {
+  Email = 'EMAIL',
+  Max = 'MAX',
+  Telegram = 'TELEGRAM'
+}
+
 export type MessengerConnection = {
  __typename?: 'MessengerConnection';
  channelId: Scalars['String']['output'];
@@ -96,6 +117,15 @@ export type MessengerConnection = {
  userId: Scalars['ID']['output'];
 };

+export type MessengerDispatchResult = {
+  __typename?: 'MessengerDispatchResult';
+  channelId: Scalars['String']['output'];
+  detail: Scalars['String']['output'];
+  sentAt: Scalars['DateTime']['output'];
+  success: Scalars['Boolean']['output'];
+  type: MessengerType;
+};
+
 export enum MessengerType {
  Max = 'MAX',
  Telegram = 'TELEGRAM'
@@ -114,12 +144,15 @@ export type Mutation = {
  managerFinalizeOrder: Order;
  managerSetOrderOffer: Order;
  registerSelf: RegistrationRequest;
+  requestLoginCode: AuthCodeRequestResult;
  requestRewardWithdrawal: RewardWithdrawalRequest;
  reviewRegistrationRequest: RegistrationRequest;
  reviewRewardWithdrawal: RewardWithdrawalRequest;
+  sendTestMessengerMessage: MessengerDispatchResult;
  startOrderWork: Order;
  submitCalculationOrder: Order;
  submitReadyOrder: Order;
+  verifyLoginCode: AuthSession;
 };


@@ -180,6 +213,11 @@ export type MutationRegisterSelfArgs = {
 };


+export type MutationRequestLoginCodeArgs = {
+  input: RequestLoginCodeInput;
+};
+
+
 export type MutationRequestRewardWithdrawalArgs = {
  input: RequestRewardWithdrawalInput;
 };
@@ -195,6 +233,13 @@ export type MutationReviewRewardWithdrawalArgs = {
 };


+export type MutationSendTestMessengerMessageArgs = {
+  channelId?: InputMaybe<Scalars['String']['input']>;
+  message?: InputMaybe<Scalars['String']['input']>;
+  type: MessengerType;
+};
+
+
 export type MutationStartOrderWorkArgs = {
  orderId: Scalars['ID']['input'];
 };
@@ -209,6 +254,21 @@ export type MutationSubmitReadyOrderArgs = {
  input: SubmitReadyOrderInput;
 };

+
+export type MutationVerifyLoginCodeArgs = {
+  input: VerifyLoginCodeInput;
+};
+
+export type NotificationHistoryItem = {
+  __typename?: 'NotificationHistoryItem';
+  channel: MessengerType;
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['ID']['output'];
+  message: Scalars['String']['output'];
+  orderId?: Maybe<Scalars['ID']['output']>;
+  title: Scalars['String']['output'];
+};
+
 export type Order = {
  __typename?: 'Order';
  blockReason?: Maybe<Scalars['String']['output']>;
@@ -285,20 +345,36 @@ export type Query = {
  __typename?: 'Query';
  clientProducts: Array<Product>;
  healthcheck: Scalars['String']['output'];
+  managerNotificationHistory: Array<NotificationHistoryItem>;
  managerOrders: Array<Order>;
  me?: Maybe<User>;
  myCurrentOrders: Array<Order>;
+  myMessengerConnections: Array<MessengerConnection>;
+  myNotificationHistory: Array<NotificationHistoryItem>;
  myOrders: Array<Order>;
  referralStats: ReferralStats;
  registrationRequests: Array<RegistrationRequest>;
 };


+export type QueryManagerNotificationHistoryArgs = {
+  channel: MessengerType;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  userId: Scalars['ID']['input'];
+};
+
+
 export type QueryManagerOrdersArgs = {
  status?: InputMaybe<OrderStatus>;
 };


+export type QueryMyNotificationHistoryArgs = {
+  channel: MessengerType;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
 export type QueryRegistrationRequestsArgs = {
  status?: InputMaybe<RegistrationStatus>;
 };
@@ -352,6 +428,11 @@ export enum RegistrationStatus {
  Rejected = 'REJECTED'
 }

+export type RequestLoginCodeInput = {
+  channel: LoginChannel;
+  destination: Scalars['String']['input'];
+};
+
 export type RequestRewardWithdrawalInput = {
  amount: Scalars['Float']['input'];
 };
@@ -411,6 +492,11 @@ export enum UserRole {
  Manager = 'MANAGER'
 }

+export type VerifyLoginCodeInput = {
+  challengeToken: Scalars['String']['input'];
+  code: Scalars['String']['input'];
+};
+
 export type Warehouse = {
  __typename?: 'Warehouse';
  code: Scalars['String']['output'];
@@ -431,11 +517,55 @@ export type RegisterSelfMutationVariables = Exact<{

 export type RegisterSelfMutation = { __typename?: 'Mutation', registerSelf: { __typename?: 'RegistrationRequest', id: string, companyName: string, contactName: string, email: string, status: RegistrationStatus, createdAt: any } };

+export type RequestLoginCodeMutationVariables = Exact<{
+  input: RequestLoginCodeInput;
+}>;
+
+
+export type RequestLoginCodeMutation = { __typename?: 'Mutation', requestLoginCode: { __typename?: 'AuthCodeRequestResult', challengeToken: string, channel: LoginChannel, destination: string, expiresAt: any } };
+
+export type VerifyLoginCodeMutationVariables = Exact<{
+  input: VerifyLoginCodeInput;
+}>;
+
+
+export type VerifyLoginCodeMutation = { __typename?: 'Mutation', verifyLoginCode: { __typename?: 'AuthSession', accessToken: string, expiresAt: any, user: { __typename?: 'User', id: string, email: string, fullName: string, role: UserRole } } };
+
 export type ClientProductsQueryVariables = Exact<{ [key: string]: never; }>;


 export type ClientProductsQuery = { __typename?: 'Query', clientProducts: Array<{ __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, isCustomizable: boolean, availableInWarehouses: Array<{ __typename?: 'ProductWarehouseBalance', availableQty: number, warehouse: { __typename?: 'Warehouse', id: string, code: string, name: string } }> }> };

+export type MyMessengerConnectionsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type MyMessengerConnectionsQuery = { __typename?: 'Query', myMessengerConnections: Array<{ __typename?: 'MessengerConnection', id: string, type: MessengerType, channelId: string, isActive: boolean }> };
+
+export type MyNotificationHistoryQueryVariables = Exact<{
+  channel: MessengerType;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+
+
+export type MyNotificationHistoryQuery = { __typename?: 'Query', myNotificationHistory: Array<{ __typename?: 'NotificationHistoryItem', id: string, channel: MessengerType, title: string, message: string, createdAt: any, orderId?: string | null }> };
+
+export type SendTestMessengerMessageMutationVariables = Exact<{
+  type: MessengerType;
+  channelId?: InputMaybe<Scalars['String']['input']>;
+  message?: InputMaybe<Scalars['String']['input']>;
+}>;
+
+
+export type SendTestMessengerMessageMutation = { __typename?: 'Mutation', sendTestMessengerMessage: { __typename?: 'MessengerDispatchResult', type: MessengerType, channelId: string, success: boolean, detail: string, sentAt: any } };
+
+export type ClientReviewOrderMutationVariables = Exact<{
+  orderId: Scalars['ID']['input'];
+  decision: Decision;
+}>;
+
+
+export type ClientReviewOrderMutation = { __typename?: 'Mutation', clientReviewOrder: { __typename?: 'Order', id: string, status: OrderStatus, clientApproved?: boolean | null, managerApproved?: boolean | null } };
+
 export type MyCurrentOrdersQueryVariables = Exact<{ [key: string]: never; }>;


@@ -502,6 +632,74 @@ export function useRegisterSelfMutation(options: VueApolloComposable.UseMutation
  return VueApolloComposable.useMutation<RegisterSelfMutation, RegisterSelfMutationVariables>(RegisterSelfDocument, options);
 }
 export type RegisterSelfMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RegisterSelfMutation, RegisterSelfMutationVariables>;
+export const RequestLoginCodeDocument = gql`
+    mutation RequestLoginCode($input: RequestLoginCodeInput!) {
+  requestLoginCode(input: $input) {
+    challengeToken
+    channel
+    destination
+    expiresAt
+  }
+}
+    `;
+
+/**
+ * __useRequestLoginCodeMutation__
+ *
+ * To run a mutation, you first call `useRequestLoginCodeMutation` within a Vue component and pass it any options that fit your needs.
+ * When your component renders, `useRequestLoginCodeMutation` returns an object that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
+ *
+ * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
+ *
+ * @example
+ * const { mutate, loading, error, onDone } = useRequestLoginCodeMutation({
+ *   variables: {
+ *     input: // value for 'input'
+ *   },
+ * });
+ */
+export function useRequestLoginCodeMutation(options: VueApolloComposable.UseMutationOptions<RequestLoginCodeMutation, RequestLoginCodeMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>> = {}) {
+  return VueApolloComposable.useMutation<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>(RequestLoginCodeDocument, options);
+}
+export type RequestLoginCodeMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RequestLoginCodeMutation, RequestLoginCodeMutationVariables>;
+export const VerifyLoginCodeDocument = gql`
+    mutation VerifyLoginCode($input: VerifyLoginCodeInput!) {
+  verifyLoginCode(input: $input) {
+    accessToken
+    expiresAt
+    user {
+      id
+      email
+      fullName
+      role
+    }
+  }
+}
+    `;
+
+/**
+ * __useVerifyLoginCodeMutation__
+ *
+ * To run a mutation, you first call `useVerifyLoginCodeMutation` within a Vue component and pass it any options that fit your needs.
+ * When your component renders, `useVerifyLoginCodeMutation` returns an object that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
+ *
+ * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
+ *
+ * @example
+ * const { mutate, loading, error, onDone } = useVerifyLoginCodeMutation({
+ *   variables: {
+ *     input: // value for 'input'
+ *   },
+ * });
+ */
+export function useVerifyLoginCodeMutation(options: VueApolloComposable.UseMutationOptions<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>> = {}) {
+  return VueApolloComposable.useMutation<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>(VerifyLoginCodeDocument, options);
+}
+export type VerifyLoginCodeMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<VerifyLoginCodeMutation, VerifyLoginCodeMutationVariables>;
 export const ClientProductsDocument = gql`
    query ClientProducts {
  clientProducts {
@@ -541,6 +739,140 @@ export function useClientProductsLazyQuery(options: VueApolloComposable.UseQuery
  return VueApolloComposable.useLazyQuery<ClientProductsQuery, ClientProductsQueryVariables>(ClientProductsDocument, {}, options);
 }
 export type ClientProductsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<ClientProductsQuery, ClientProductsQueryVariables>;
+export const MyMessengerConnectionsDocument = gql`
+    query MyMessengerConnections {
+  myMessengerConnections {
+    id
+    type
+    channelId
+    isActive
+  }
+}
+    `;
+
+/**
+ * __useMyMessengerConnectionsQuery__
+ *
+ * To run a query within a Vue component, call `useMyMessengerConnectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyMessengerConnectionsQuery` returns an object from Apollo Client that contains result, loading and error properties
+ * you can use to render your UI.
+ *
+ * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
+ *
+ * @example
+ * const { result, loading, error } = useMyMessengerConnectionsQuery();
+ */
+export function useMyMessengerConnectionsQuery(options: VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> = {}) {
+  return VueApolloComposable.useQuery<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>(MyMessengerConnectionsDocument, {}, options);
+}
+export function useMyMessengerConnectionsLazyQuery(options: VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>> = {}) {
+  return VueApolloComposable.useLazyQuery<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>(MyMessengerConnectionsDocument, {}, options);
+}
+export type MyMessengerConnectionsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyMessengerConnectionsQuery, MyMessengerConnectionsQueryVariables>;
+export const MyNotificationHistoryDocument = gql`
+    query MyNotificationHistory($channel: MessengerType!, $limit: Int) {
+  myNotificationHistory(channel: $channel, limit: $limit) {
+    id
+    channel
+    title
+    message
+    createdAt
+    orderId
+  }
+}
+    `;
+
+/**
+ * __useMyNotificationHistoryQuery__
+ *
+ * To run a query within a Vue component, call `useMyNotificationHistoryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyNotificationHistoryQuery` returns an object from Apollo Client that contains result, loading and error properties
+ * you can use to render your UI.
+ *
+ * @param variables that will be passed into the query
+ * @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
+ *
+ * @example
+ * const { result, loading, error } = useMyNotificationHistoryQuery({
+ *   channel: // value for 'channel'
+ *   limit: // value for 'limit'
+ * });
+ */
+export function useMyNotificationHistoryQuery(variables: MyNotificationHistoryQueryVariables | VueCompositionApi.Ref<MyNotificationHistoryQueryVariables> | ReactiveFunction<MyNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> = {}) {
+  return VueApolloComposable.useQuery<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>(MyNotificationHistoryDocument, variables, options);
+}
+export function useMyNotificationHistoryLazyQuery(variables?: MyNotificationHistoryQueryVariables | VueCompositionApi.Ref<MyNotificationHistoryQueryVariables> | ReactiveFunction<MyNotificationHistoryQueryVariables>, options: VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>> = {}) {
+  return VueApolloComposable.useLazyQuery<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>(MyNotificationHistoryDocument, variables, options);
+}
+export type MyNotificationHistoryQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<MyNotificationHistoryQuery, MyNotificationHistoryQueryVariables>;
+export const SendTestMessengerMessageDocument = gql`
+    mutation SendTestMessengerMessage($type: MessengerType!, $channelId: String, $message: String) {
+  sendTestMessengerMessage(type: $type, channelId: $channelId, message: $message) {
+    type
+    channelId
+    success
+    detail
+    sentAt
+  }
+}
+    `;
+
+/**
+ * __useSendTestMessengerMessageMutation__
+ *
+ * To run a mutation, you first call `useSendTestMessengerMessageMutation` within a Vue component and pass it any options that fit your needs.
+ * When your component renders, `useSendTestMessengerMessageMutation` returns an object that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
+ *
+ * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
+ *
+ * @example
+ * const { mutate, loading, error, onDone } = useSendTestMessengerMessageMutation({
+ *   variables: {
+ *     type: // value for 'type'
+ *     channelId: // value for 'channelId'
+ *     message: // value for 'message'
+ *   },
+ * });
+ */
+export function useSendTestMessengerMessageMutation(options: VueApolloComposable.UseMutationOptions<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>> = {}) {
+  return VueApolloComposable.useMutation<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>(SendTestMessengerMessageDocument, options);
+}
+export type SendTestMessengerMessageMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<SendTestMessengerMessageMutation, SendTestMessengerMessageMutationVariables>;
+export const ClientReviewOrderDocument = gql`
+    mutation ClientReviewOrder($orderId: ID!, $decision: Decision!) {
+  clientReviewOrder(orderId: $orderId, decision: $decision) {
+    id
+    status
+    clientApproved
+    managerApproved
+  }
+}
+    `;
+
+/**
+ * __useClientReviewOrderMutation__
+ *
+ * To run a mutation, you first call `useClientReviewOrderMutation` within a Vue component and pass it any options that fit your needs.
+ * When your component renders, `useClientReviewOrderMutation` returns an object that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
+ *
+ * @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
+ *
+ * @example
+ * const { mutate, loading, error, onDone } = useClientReviewOrderMutation({
+ *   variables: {
+ *     orderId: // value for 'orderId'
+ *     decision: // value for 'decision'
+ *   },
+ * });
+ */
+export function useClientReviewOrderMutation(options: VueApolloComposable.UseMutationOptions<ClientReviewOrderMutation, ClientReviewOrderMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<ClientReviewOrderMutation, ClientReviewOrderMutationVariables>> = {}) {
+  return VueApolloComposable.useMutation<ClientReviewOrderMutation, ClientReviewOrderMutationVariables>(ClientReviewOrderDocument, options);
+}
+export type ClientReviewOrderMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<ClientReviewOrderMutation, ClientReviewOrderMutationVariables>;
 export const MyCurrentOrdersDocument = gql`
    query MyCurrentOrders {
  myCurrentOrders {