Dwinzo-Backend-V0.0/src/shared/services/v1Project/v1projectservice.ts

import projectModel from "../../V1Models/Project/project-model.ts";
import versionModel from "../../V1Models/Version/versionModel.ts";
import {
  existingProject,
  existingUser,
  archiveProject,
  previousVersion,
  generateUntitledProjectName,
} from "../helpers/v1projecthelperFns.ts";
import UsersDataModel from "../../V1Models/Auth/user.ts";
interface CreateProjectInput {
  projectName: string;
  projectUuid: string;
  userId: string; // user ID
  thumbnail?: string;
  sharedUsers?: string[];
  organization: string;
}
interface updateProjectInput {
  projectName: string;
  projectId: string;
  userId: string; // user ID
  thumbnail?: string;
  sharedUsers?: string[];
  organization: string;
  role: string;
}
interface GetProjectsInterface {
  userId: string;
  organization: string;
  role: string;
}
interface ProjectInterface {
  projectId: string;
  userId: string;
  organization: string;
  role: string;
}
interface RoleFilter {
  isArchive: boolean;
  createdBy?: string;
}
export const createProject = async (data: CreateProjectInput) => {
  try {
    const { thumbnail, sharedUsers, projectUuid, userId, organization } = data;
    const userExisting = await existingUser(userId, organization);
    if (!userExisting) {
      return {
        status: "user_not_found",
      };
    }
    const projectExisting = await existingProject(
      projectUuid,
      organization,
      userId
    );

    if (projectExisting) {
      return {
        status: "project_exists",
        project: projectExisting,
      };
    }
    const newProjectName = await generateUntitledProjectName(
      organization,
      userId
    );
    const project = await projectModel(organization).create({
      projectName: newProjectName,
      projectUuid: projectUuid,
      createdBy: userId,
      thumbnail: thumbnail,
      sharedUsers: sharedUsers || [],
      isArchive: false,
    });
    const versionData = await previousVersion(project._id, organization);
    if (!versionData || versionData.length === 0) {
      const newVersion = await versionModel(organization).create({
        projectId: project._id,
        createdBy: userId,
        version: 0.0,
      });
      await projectModel(organization).findByIdAndUpdate(
        { _id: project._id, isArchive: false },
        { total_versions: `v-${newVersion.version.toFixed(2)}` }
      );
    }
    return {
      status: "Success",
      project: project,
    };
  } catch (error) {
    console.log("error: ", error);
    return {
      status: error,
    };
  }
};

export const GetAllProjects = async (data: GetProjectsInterface) => {
  try {
    const { userId, organization, role } = data;
    await existingUser(userId, organization);
    if (!existingUser) return { status: "User not found" };
    let filter = { isArchive: false } as RoleFilter;
    if (role === "User") {
      filter.createdBy = userId;
    }
    const projectDatas = await projectModel(organization)
      .find(filter)
      .select("_id projectName createdBy thumbnail createdAt projectUuid");
    if (projectDatas) return { status: "Success", Datas: projectDatas };
  } catch (error: unknown) {
    return { status: error };
  }
};

export const DeleteProject = async (data: ProjectInterface) => {
  try {
    const { projectId, organization, userId, role } = data;
    const ExistingUser = await existingUser(userId, organization);
    if (!ExistingUser) return { status: "User not found" };
    let filter = { _id: projectId, isArchive: false } as RoleFilter;
    if (role === "User") {
      filter.createdBy = userId;
    }
    const existingProject = await projectModel(organization).findOne(filter);
    if (!existingProject) return { status: "Project not found" };
    const updateProject = await projectModel(organization).findOneAndUpdate(
      filter,
      { isArchive: true, DeletedAt: new Date() },
      { new: true }
    );
    if (updateProject) return { status: "Success", project: updateProject };
  } catch (error: unknown) {
    return { status: error };
  }
};
export const updateProject = async (data: updateProjectInput) => {
  try {
    const { projectId, organization, userId, projectName, thumbnail, role } =
      data;
    const ExistingUser = await existingUser(userId, organization);
    if (!ExistingUser) return { status: "User not found" };
    let filter = { _id: projectId, isArchive: false } as RoleFilter;
    if (role === "User") {
      filter.createdBy = userId;
    }
    const existingProject = await projectModel(organization).findOne(filter);
    if (!existingProject) return { status: "Project not found" };
    if (projectName !== undefined) projectName;
    if (thumbnail !== undefined) thumbnail;
    const updateProject = await projectModel(organization)
      .findOneAndUpdate(
        filter,
        { projectName: projectName, thumbnail: thumbnail },
        { new: true }
      )
      .select("_id projectName createdBy thumbnail createdAt");
    if (updateProject) return { status: "Success", data: updateProject };
  } catch (error: unknown) {
    return { status: error };
  }
};
const maxLength: number = 6;
export const viewProject = async (data: ProjectInterface) => {
  try {
    const { projectId, organization, userId, role } = data;
    const userExisting = await existingUser(userId, organization);
    if (!userExisting) return { status: "User not found" };
    const RecentUserDoc = await UsersDataModel(organization).findOne({
      userId: userId,
      isArchive: false,
    });
    let filter = { _id: projectId, isArchive: false } as RoleFilter;
    if (role === "User") {
      filter.createdBy = userId;
    }
    const existingProject = await projectModel(organization).findOne(filter);
    if (!existingProject) return { status: "Project not found" };
    const newArr = RecentUserDoc?.recentlyViewed || [];
    if (RecentUserDoc?.recentlyViewed.length === 0) {
      newArr.push(projectId);
      await RecentUserDoc.save();
    } else {
      const index = newArr.indexOf(projectId);
      if (index !== -1) {
        newArr.splice(index, 1);
      }
      newArr.unshift(projectId);

      if (newArr.length > maxLength) {
        newArr.pop();
      }
    }
    await UsersDataModel(organization).updateOne(
      { _id: userId },
      { recentlyViewed: newArr },
      { new: true }
    );
    const projectData = await projectModel(organization)
      .findOneAndUpdate(filter, { isViewed: Date.now() }, { new: true })
      .select("_id projectName createdBy thumbnail createdAt");
    return { status: "Success", data: projectData };
  } catch (error: unknown) {
    return { status: error };
  }
};