@culturefy/shared 1.0.28 → 1.0.29

package/src/service/user.service.ts

@@ -0,0 +1,99 @@
+import { Types } from "mongoose";
+import { InvocationContext } from "@azure/functions";
+import IUser, { UserModel } from "../models/user.model";
+import { Initializers, WithDb } from "@culturefy/shared";
+
+export class UserService extends Initializers {
+
+    private readonly schema = UserModel.schema;
+    constructor(context: InvocationContext, dbUrl:string) {
+        super(context, dbUrl);
+    }
+
+    private getModel() {
+      const connection = (this as any).getConnection();
+      if (!connection) {
+        throw new Error('Database connection not established');
+      }
+      return connection.model(UserModel.modelName, this.schema);
+    }
+
+    @WithDb
+    async getUserById(userId: string): Promise<IUser | null> {
+        try {
+            let model = this.getModel();
+            this.context.log("UserId:", JSON.stringify(userId));
+            
+            // Handle both string and SchemaObjectId inputs
+            let objectId: Types.ObjectId;
+            if (typeof userId === 'string') {
+                objectId = new Types.ObjectId(userId);
+            } else {
+                // If it's already a SchemaObjectId, extract the string value
+                const userIdString = (userId as any).path || (userId as any).toString();
+                objectId = new Types.ObjectId(userIdString);
+            }
+            
+            this.context.log("ObjectId:", JSON.stringify(objectId));
+            const user = await model.findById(objectId);
+            this.context.log("User:", JSON.stringify(user));
+            return user;
+        } catch (error) {
+            this.context.error("Error in getUserById", error);
+            throw error;
+        }
+    }
+
+    @WithDb
+    async getUserByBusinessId(businessId: string, email: string): Promise<IUser | null> {
+        try {
+            let model = this.getModel();
+            this.context.log("BusinessId:", JSON.stringify(businessId));
+            this.context.log("Email:", JSON.stringify(email));
+
+            if(!businessId) return null;
+            if(!email) return null;
+
+            businessId = businessId.toLowerCase();
+            businessId = businessId.trim();
+
+            email = email.toLowerCase();
+            email = email.trim();
+
+            // Handle both string and SchemaObjectId inputs
+            let objectId: Types.ObjectId;
+            if (typeof businessId === 'string') {
+                objectId = new Types.ObjectId(businessId);
+            } else {
+                // If it's already a SchemaObjectId, extract the string value
+                const businessIdString = (businessId as any).path || (businessId as any).toString();
+                objectId = new Types.ObjectId(businessIdString);
+            }
+            
+            this.context.log("ObjectId:", JSON.stringify(objectId));
+            const user = await model.findOne({ businessId: objectId, email: email });
+            this.context.log("User:", JSON.stringify(user));
+            return user;
+        } catch (error) {
+            this.context.error("Error in getUserByBusinessId", error);
+            throw error;
+        }
+    }
+
+    @WithDb
+    async getUserByEmail(email: string) {
+        try {
+            let model = this.getModel();
+            this.context.log("Email:", JSON.stringify(email));
+
+            email = email.toLowerCase();
+            email = email.trim();
+            const user = await model.findOne({ email: email });
+            this.context.log("User:", JSON.stringify(user));
+            return user;
+        } catch (error) {
+            this.context.error("Error in getUserByEmail", error);
+            throw error;
+        }
+    }
+}

package/src/utils/index.ts

@@ -1,4 +1,5 @@
 export * from './secrets';
 export * from './response';
 export * from './initializers';
-export * from './mapper';
+export * from './mapper';
+export * from './jwt';

package/src/utils/jwt.ts

@@ -0,0 +1,10 @@
+import { jwtDecode } from "jwt-decode";
+
+export function verifyJsonWebToken(token: string): Record<string, any> | false {
+    try {
+        const decoded = jwtDecode(token);
+        return decoded;
+    } catch (error: any) {
+        return false;
+    }
+}

package/src/utils/response.ts

@@ -63,4 +63,23 @@ export function asyncHandler(handler: Function) {
             return sendResponse(500, null, error.message ? error.message : 'An unexpected error occurred');
         }
     };
+}
+
+// Parse cookies from request headers
+export function parseCookies(req: any, context: InvocationContext): Record<string, any> {
+    // Convert Headers object to plain object for logging
+    const headersObj: Record<string, string> = {};
+    req.headers.forEach((value: string, key: string) => {
+        headersObj[key] = value;
+    });
+    context.info("Parse headers", JSON.stringify(headersObj));
+
+    const cookieHeader = req.headers.get("Cookie") || "";
+    context.info("Parse cookies", JSON.stringify(cookieHeader));
+    return cookieHeader.split(";").reduce((cookies: Record<string, any>, cookie: string) => {
+        const [name, ...rest] = cookie.split("=");
+        if (!name) return cookies;
+        cookies[name.trim()] = decodeURIComponent(rest.join("="));
+        return cookies;
+    }, {});
 }