Untitled

export const rbacController = s.router(contract.v1.procurementRbac.buyer, {
  organizations: {
    getAllOrganizations: {
      handler: async ({ query, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getAllOrganizations({
          session,
          page: query.page,
          perPage: query.limit,
          search: query.keyword,
        });
  
        return {
          status: 200,
          body: {
            message: 'Organizations fetched successfully',
            data: result.items,
            meta: {
              current_page: result.meta.page,
              per_page: result.meta.perPage,
              last_page: result.meta.totalPages,
              total: result.meta.totalItems,
            }
          }
        }
      }
    },
    getOrganizationById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getOrganizationById({
          orgId: params.organizationId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Organization fetched successfully',
            data: result
          }
        }
      }
    },
    createOrganization: {
      handler: async ({ body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.createOrganization({
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Organization created successfully',
            data: result
          }
        } 
      }
    },
    updateOrganizationById: {
      handler: async ({ params, body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.updateOrganizationById({
          orgId: params.organizationId,
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Organization updated successfully',
            data: result
          }
        }
      }
    },
    deleteOrganizationById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.deleteOrganizationById({
          orgId: params.organizationId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Organization deleted successfully',
            data: result
          }
        }
      }
    },
  },
  teams: {
    getAllTeams: {
      handler: async ({ params, query, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getAllTeams({
          orgId: params.organizationId,
          session,
          page: query.page,
          perPage: query.limit,
          search: query.keyword,
        });
  
        return {
          status: 200,
          body: {
            message: 'Teams fetched successfully',
            data: result.items.map((item) => ({
              ...item,
              members: item.members.map((member) => ({
                ...member,
                email: member.email ?? '',
              }))
            })),
            meta: {
              current_page: result.meta.page,
              per_page: result.meta.perPage,
              last_page: result.meta.totalPages,
              total: result.meta.totalItems,
            }
          }
        }
      }
    },
    getTeamById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getTeamById({
          teamId: params.teamId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team fetched successfully',
            data: result
          }
        }
      }
    },
    createTeam: {
      handler: async ({ params, body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.createTeam({
          orgId: params.organizationId,
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team created successfully',
            data: result
          }
        }
      }
    },
    updateTeamById: {
      handler: async ({ params, body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.updateTeamById({
          teamId: params.teamId,
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team updated successfully',
            data: result
          }
        }
      }
    },
    deleteTeamById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.deleteTeamById({
          teamId: params.teamId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team deleted successfully',
            data: result
          }
        }
      }
    },
  },
  teamMembers: {
    getAllTeamMembers: {
      handler: async ({ params, query, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getAllTeamMembers({
          teamId: params.teamId,
          session,
          page: query.page,
          perPage: query.limit,
          search: query.keyword,
        });
  
        return {
          status: 200,
          body: {
            message: 'Team members fetched successfully',
            data: result.items,
            meta: {
              current_page: result.meta.page,
              per_page: result.meta.perPage,
              last_page: result.meta.totalPages,
              total: result.meta.totalItems,
            }
          }
        }
      }
    },
    createTeamMember: {
      handler: async ({ params, body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.createTeamMember({
          teamId: params.teamId,
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team member created successfully',
            data: result
          }
        }
      }
    },
    updateTeamMemberById: {
      handler: async ({ params, body, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.updateTeamMemberById({
          teamMemberId: params.teamMemberId,
          body,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team member updated successfully',
            data: result
          }
        }
      }
    },
    deleteTeamMemberById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.deleteTeamMemberById({
          teamMemberId: params.teamMemberId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team member deleted successfully',
            data: result
          }
        }
      }
    },
    getTeamMemberById: {
      handler: async ({ params, request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getTeamMemberById({
          teamMemberId: params.teamMemberId,
          session
        });
  
        return {
          status: 200,
          body: {
            message: 'Team member fetched successfully',
            data: result
          }
        }
      }
    },
    getUserByEmail: {
      handler: async ({ body, request }) => {
        const result = await RbacService.getUserByEmail({
          email: body.email,
        });
  
        if (!result) {
          return {
            status: 204,
            body: {
              message: 'User not found',
              data: null
            }
          }
        }
  
        return {
          status: 200,
          body: {
            message: 'User fetched successfully',
            data: result
          }
        }
      }
    },
    getUserProcurementRoleInfo: {
      handler: async ({ request }) => {
        const session = request.requestContext.get('session')!;
        const result = await RbacService.getUserProcurementRoleInfo({
          userId: session.user?.id ?? '',
        });
  
        return {  
          status: 200,
          body: {
            message: 'User procurement role info fetched successfully',
            data: result
          }
        }
      }
    }
  }
})