api: fetch and create care actions/medicines

eletrotupi / tcc/ commit / ce66d00

api: fetch and create care actions/medicines

Pedro Lucas Porcellis porcellis@eletrotupi.com 1 month ago ce66d00c4b0f0549e45ca233432cd6098e28455c

Parents: b4b8847

6 file(s) changed

api/src/controllers/careActions.ts +74 -0
api/src/controllers/medicineRegimens.ts +67 -0
api/src/routes/careActions.ts +12 -0
api/src/routes/medicineRegimens.ts +12 -0
api/src/services/careAction.service.ts +204 -0
api/src/services/medicineRegimen.service.ts +42 -0

api/src/controllers/careActions.ts
@@ -0,0 +1,74 @@
  + import { Response, NextFunction } from 'express';
  + import { AuthenticatedRequest } from '@app/middleware/auth';
  + import { CareActionType } from '@prisma/client';
  + import { CreateCareActionSchema } from '@app/schemas';
  + import {
  +   getCareActionsByUserId,
  +   getCareActionById,
  +   createCareAction,
  +   destroyCareActionById,
  + } from '@app/services/careAction.service';
  + 
  + export const CareActionsController = {
  +   index: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const result = await getCareActionsByUserId(Number(req.userId), {
  +         type: req.query.type as CareActionType | undefined,
  +         from: req.query.from as string | undefined,
  +         to: req.query.to as string | undefined,
  +         limit: req.query.limit ? Number(req.query.limit) : undefined,
  +         page: req.query.page ? Number(req.query.page) : undefined,
  +       });
  + 
  +       return res.status(200).json(result);
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   show: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const careAction = await getCareActionById(
  +         Number(req.userId),
  +         Number(req.params.id),
  +       );
  + 
  +       if (!careAction) {
  +         return res.status(404).json({ errors: 'Care action was not found' });
  +       }
  + 
  +       return res.status(200).json({ careAction });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   create: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = CreateCareActionSchema.safeParse(req.body.careAction);
  + 
  +       req.log.info("Params: %s", req.body.careAction)
  +       req.log.info("Care action: %s", parsed.error)
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({ errors: parsed.error!.issues });
  +       }
  + 
  +       const careAction = await createCareAction(req.userId!, parsed.data);
  + 
  +       return res.status(201).json({ careAction });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   destroy: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       await destroyCareActionById(req.userId!, Number(req.params.id));
  + 
  +       return res.status(200).json({});
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + };
api/src/controllers/medicineRegimens.ts
@@ -0,0 +1,67 @@
  + import { Response, NextFunction } from 'express';
  + import { AuthenticatedRequest } from '@app/middleware/auth';
  + import { CreateMedicineRegimenSchema, UpdateMedicineRegimenSchema } from '@app/schemas';
  + import {
  +   getMedicineRegimensByUserId,
  +   createMedicineRegimen,
  +   updateMedicineRegimen,
  +   deactivateMedicineRegimen,
  + } from '@app/services/medicineRegimen.service';
  + 
  + export const MedicineRegimensController = {
  +   index: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const regimens = await getMedicineRegimensByUserId(Number(req.userId));
  + 
  +       return res.status(200).json({ regimens });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   create: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = CreateMedicineRegimenSchema.safeParse(req.body.regimen);
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({ errors: parsed.error!.issues });
  +       }
  + 
  +       const regimen = await createMedicineRegimen(req.userId!, parsed.data);
  + 
  +       return res.status(201).json({ regimen });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   update: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = UpdateMedicineRegimenSchema.safeParse(req.body.regimen);
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({ errors: parsed.error!.issues });
  +       }
  + 
  +       const regimen = await updateMedicineRegimen(
  +         req.userId!,
  +         Number(req.params.id),
  +         parsed.data,
  +       );
  + 
  +       return res.status(200).json({ regimen });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   destroy: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       await deactivateMedicineRegimen(req.userId!, Number(req.params.id));
  + 
  +       return res.status(200).json({});
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + };
api/src/routes/careActions.ts
@@ -0,0 +1,12 @@
  + import { Router } from 'express';
  + import { CareActionsController } from '@app/controllers/careActions';
  + import { requireAuth } from '@app/middleware/auth';
  + 
  + const router = Router();
  + 
  + router.get('/', requireAuth, CareActionsController.index);
  + router.post('/', requireAuth, CareActionsController.create);
  + router.get('/:id', requireAuth, CareActionsController.show);
  + router.delete('/:id', requireAuth, CareActionsController.destroy);
  + 
  + export default router;
api/src/routes/medicineRegimens.ts
@@ -0,0 +1,12 @@
  + import { Router } from 'express';
  + import { MedicineRegimensController } from '@app/controllers/medicineRegimens';
  + import { requireAuth } from '@app/middleware/auth';
  + 
  + const router = Router();
  + 
  + router.get('/', requireAuth, MedicineRegimensController.index);
  + router.post('/', requireAuth, MedicineRegimensController.create);
  + router.patch('/:id', requireAuth, MedicineRegimensController.update);
  + router.delete('/:id', requireAuth, MedicineRegimensController.destroy);
  + 
  + export default router;
api/src/services/careAction.service.ts
@@ -0,0 +1,204 @@
  + import { prisma } from '@app/lib/prisma';
  + import { CareAction, CareActionType } from '@prisma/client';
  + import { CreateCareActionInput } from '@app/schemas';
  + 
  + const careActionIncludes = {
  +   medicineLog: { include: { regimen: true } },
  +   appointment: true,
  +   activity: true,
  + } as const;
  + 
  + export const getCareActionsByUserId = async (
  +   userId: number,
  +   params?: {
  +     type?: CareActionType;
  +     from?: string;
  +     to?: string;
  +     page?: number;
  +     limit?: number;
  +   },
  + ) => {
  +   const page = params?.page ?? 1;
  +   const limit = params?.limit ?? 20;
  +   const skip = (page - 1) * limit;
  + 
  +   const where = {
  +     userId,
  +     ...(params?.type ? { type: params.type } : {}),
  +     ...(params?.from || params?.to
  +       ? {
  +           moment: {
  +             ...(params?.from && { gte: new Date(params.from) }),
  +             ...(params?.to && { lte: new Date(params.to) }),
  +           },
  +         }
  +       : {}),
  +   };
  + 
  +   const [entries, total] = await Promise.all([
  +     prisma.careAction.findMany({
  +       where,
  +       include: careActionIncludes,
  +       orderBy: { moment: 'desc' },
  +       take: limit,
  +       skip,
  +     }),
  +     prisma.careAction.count({ where }),
  +   ]);
  + 
  +   const totalPages = Math.ceil(total / limit);
  + 
  +   return {
  +     entries,
  +     total,
  +     page,
  +     nextPage: page < totalPages ? page + 1 : null,
  +   };
  + };
  + 
  + export const getCareActionById = async (userId: number, id: number) => {
  +   return prisma.careAction.findUnique({
  +     where: { id, userId },
  +     include: careActionIncludes,
  +   });
  + };
  + 
  + export const destroyCareActionById = async (
  +   userId: number,
  +   id: number,
  + ): Promise<CareAction> => {
  +   return prisma.careAction.delete({
  +     where: { id, userId },
  +   });
  + };
  + 
  + export const createCareAction = async (
  +   userId: number,
  +   input: CreateCareActionInput,
  + ) => {
  +   if (input.type === CareActionType.MEDICINE) {
  +     if (input.regimenId) {
  +       const regimenId = input.regimenId;
  +       const [careAction] = await prisma.$transaction([
  +         prisma.careAction.create({
  +           data: {
  +             userId,
  +             type: input.type,
  +             moment: input.moment,
  +             triggerId: input.triggerId,
  +             moodId: input.moodId,
  +             medicineLog: {
  +               create: { regimenId },
  +             },
  +           },
  +           include: careActionIncludes,
  +         }),
  +       ]);
  +       return careAction;
  +     }
  + 
  +     if (input.medicine) {
  +       const med = input.medicine;
  +       const [careAction] = await prisma.$transaction([
  +         prisma.careAction.create({
  +           data: {
  +             userId,
  +             type: input.type,
  +             moment: input.moment,
  +             triggerId: input.triggerId,
  +             moodId: input.moodId,
  +             medicineLog: {
  +               create: {
  +                 regimen: {
  +                   create: {
  +                     name: med.name,
  +                     dosage: med.dosage,
  +                     periodicity: med.periodicity,
  +                     scheduledAt: med.scheduledAt,
  +                     userId,
  +                   },
  +                 },
  +               },
  +             },
  +           },
  +           include: careActionIncludes,
  +         }),
  +       ]);
  +       return careAction;
  +     }
  + 
  +     // MEDICINE with no regimen info: create action without log
  +     const [careAction] = await prisma.$transaction([
  +       prisma.careAction.create({
  +         data: {
  +           userId,
  +           type: input.type,
  +           moment: input.moment,
  +           triggerId: input.triggerId,
  +           moodId: input.moodId,
  +         },
  +         include: careActionIncludes,
  +       }),
  +     ]);
  +     return careAction;
  +   }
  + 
  +   if (input.type === CareActionType.APPOINTMENT && input.appointment) {
  +     const appt = input.appointment;
  +     const [careAction] = await prisma.$transaction([
  +       prisma.careAction.create({
  +         data: {
  +           userId,
  +           type: input.type,
  +           moment: input.moment,
  +           triggerId: input.triggerId,
  +           moodId: input.moodId,
  +           appointment: {
  +             create: {
  +               type: appt.type,
  +               duration: appt.duration,
  +               note: appt.note,
  +             },
  +           },
  +         },
  +         include: careActionIncludes,
  +       }),
  +     ]);
  +     return careAction;
  +   }
  + 
  +   if (input.type === CareActionType.ACTIVITY && input.activity) {
  +     const act = input.activity;
  +     const [careAction] = await prisma.$transaction([
  +       prisma.careAction.create({
  +         data: {
  +           userId,
  +           type: input.type,
  +           moment: input.moment,
  +           triggerId: input.triggerId,
  +           moodId: input.moodId,
  +           activity: {
  +             create: {
  +               type: act.type,
  +               duration: act.duration,
  +             },
  +           },
  +         },
  +         include: careActionIncludes,
  +       }),
  +     ]);
  +     return careAction;
  +   }
  + 
  +   // Fallback: create without subtype
  +   return prisma.careAction.create({
  +     data: {
  +       userId,
  +       type: input.type,
  +       moment: input.moment,
  +       triggerId: input.triggerId,
  +       moodId: input.moodId,
  +     },
  +     include: careActionIncludes,
  +   });
  + };
api/src/services/medicineRegimen.service.ts
@@ -0,0 +1,42 @@
  + import { prisma } from '@app/lib/prisma';
  + import { MedicineRegimen } from '@prisma/client';
  + import { CreateMedicineRegimenInput, UpdateMedicineRegimenInput } from '@app/schemas';
  + 
  + export const getMedicineRegimensByUserId = async (
  +   userId: number,
  + ): Promise<MedicineRegimen[]> => {
  +   return prisma.medicineRegimen.findMany({
  +     where: { userId, active: true },
  +     orderBy: { createdAt: 'desc' },
  +   });
  + };
  + 
  + export const createMedicineRegimen = async (
  +   userId: number,
  +   input: CreateMedicineRegimenInput,
  + ): Promise<MedicineRegimen> => {
  +   return prisma.medicineRegimen.create({
  +     data: { ...input, userId },
  +   });
  + };
  + 
  + export const updateMedicineRegimen = async (
  +   userId: number,
  +   id: number,
  +   input: UpdateMedicineRegimenInput,
  + ): Promise<MedicineRegimen> => {
  +   return prisma.medicineRegimen.update({
  +     where: { id, userId },
  +     data: input,
  +   });
  + };
  + 
  + export const deactivateMedicineRegimen = async (
  +   userId: number,
  +   id: number,
  + ): Promise<MedicineRegimen> => {
  +   return prisma.medicineRegimen.update({
  +     where: { id, userId },
  +     data: { active: false },
  +   });
  + };