Changeset 057453c for src/app


Ignore:
Timestamp:
02/26/25 10:05:32 (6 weeks ago)
Author:
Naum Shapkarovski <naumshapkarovski@…>
Branches:
main
Children:
299af01
Parents:
5d6f37a
Message:

feat: implement employees

Location:
src/app
Files:
5 added
4 edited

Legend:

Unmodified
Added
Removed

  • src/app/api/customers/[id]/route.ts

    r5d6f37a r057453c  
    11import { NextRequest, NextResponse } from 'next/server';
    2 import { customerSchema } from 'mvpmasters-shared';
     2import { customerSchema } from 'src/schemas';
    33import prisma from 'src/lib/prisma';
    44import { authenticateRequest } from 'src/lib/auth-middleware';
    … …  
    1414    const validatedData = customerSchema.partial().parse(body);
    1515
    16     const customer = await prisma.customer.update({
    17       where: { id: params.id, userId },
    18       data: validatedData,
     16    const customer = await prisma.client.update({
     17      where: { id: params.id },
     18      data: {
     19        ...validatedData,
     20        bankAccounts: undefined,
     21      },
    1922    });
    2023

  • src/app/api/customers/route.ts

    r5d6f37a r057453c  
    11import { NextRequest, NextResponse } from 'next/server';
    2 import { customerTableFiltersSchema, newCustomerSchema } from 'mvpmasters-shared';
     2import { customerTableFiltersSchema, newCustomerSchema } from 'src/schemas';
    33import prisma from 'src/lib/prisma';
    44import { authenticateRequest } from 'src/lib/auth-middleware';
     5import { CustomerStatus } from '@prisma/client';
    56
    67export async function GET(request: NextRequest) {
    … …  
    2324    const validatedFilters = customerTableFiltersSchema.parse(filters);
    2425
    25     const customers = await prisma.customer.findMany({
     26    const customers = await prisma.client.findMany({
    2627      where: {
    2728        name: { contains: validatedFilters.name, mode: 'insensitive' },
    28         status: validatedFilters.status ? { equals: validatedFilters.status } : undefined,
     29        status: validatedFilters.status
     30          ? { equals: validatedFilters.status as CustomerStatus }
     31          : undefined,
    2932      },
    3033    });
    … …  
    5053    console.log('validatedData', validatedData);
    5154
    52     const customer = await prisma.customer.create({
     55    const customer = await prisma.client.create({
    5356      data: {
    5457        ...validatedData,

  • src/app/api/invoices/[id]/route.ts

    r5d6f37a r057453c  
    11import { NextRequest, NextResponse } from 'next/server';
    2 import { invoiceSchema } from 'mvpmasters-shared';
     2import { invoiceSchema, updateInvoiceSchema } from 'src/schemas';
    33import prisma from 'src/lib/prisma';
    44import { authenticateRequest } from 'src/lib/auth-middleware';
     5import { Prisma } from '@prisma/client';
    56
    6 export async function PATCH(request: NextRequest, { params }: { params: { id: string } }) {
     7export async function GET(request: NextRequest, { params }: { params: { id: string } }) {
    78  try {
    8     // Authenticate the request
     9    // Validate ID format
     10    if (!params.id || !/^[0-9a-fA-F-]+$/.test(params.id)) {
     11      return NextResponse.json({ error: 'Invalid invoice ID format' }, { status: 400 });
     12    }
     13
     14    // Authenticate request
    915    const authResult = await authenticateRequest(request);
    1016    if (authResult instanceof NextResponse) {
    … …  
    1319    const { userId } = authResult;
    1420
    15     const body = await request.json();
    16     const validatedData = invoiceSchema.partial().parse(body);
    17 
    18     const invoice = await prisma.invoice.update({
    19       where: { id: params.id, userId },
    20       data: {
    21         ...validatedData,
    22         items: validatedData.items
    23           ? {
    24               deleteMany: {},
    25               create: validatedData.items,
    26             }
    27           : undefined,
     21    // Fetch invoice with user check
     22    const invoice = await prisma.invoice.findFirst({
     23      where: {
     24        id: params.id,
     25        // invoiceFromId: userId,
    2826      },
    2927      include: {
    30         items: {
    31           include: {
    32             service: true,
    33           },
    34         },
    3528        invoiceFrom: true,
    3629        invoiceTo: true,
     30        items: true,
    3731      },
    3832    });
    3933
     34    if (!invoice) {
     35      return NextResponse.json({ error: 'Invoice not found or access denied' }, { status: 404 });
     36    }
     37
    4038    return NextResponse.json(invoice);
    4139  } catch (error) {
    42     return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
     40    console.error('Error fetching invoice:', error);
     41
     42    if (error instanceof Prisma.PrismaClientKnownRequestError) {
     43      return NextResponse.json({ error: 'Database error occurred' }, { status: 500 });
     44    }
     45
     46    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
    4347  }
    4448}
     49
     50export async function PATCH(request: NextRequest, { params }: { params: { id: string } }) {
     51  try {
     52    // Validate ID format
     53    if (!params.id || !/^[0-9a-fA-F-]+$/.test(params.id)) {
     54      return NextResponse.json({ error: 'Invalid invoice ID format' }, { status: 400 });
     55    }
     56
     57    // Authenticate request
     58    const authResult = await authenticateRequest(request);
     59    if (authResult instanceof NextResponse) {
     60      return authResult;
     61    }
     62    const { userId } = authResult;
     63
     64    // Parse and validate request body
     65    const body = await request.json();
     66
     67    const validation = updateInvoiceSchema.partial().safeParse(body);
     68
     69    if (!validation.success) {
     70      return NextResponse.json(
     71        { error: 'Invalid invoice data', details: validation.error.format() },
     72        { status: 400 }
     73      );
     74    }
     75
     76    // Verify invoice exists and belongs to user
     77    const existingInvoice = await prisma.invoice.findFirst({
     78      where: {
     79        id: params.id,
     80        // invoiceFromId: userId,
     81      },
     82    });
     83
     84    if (!existingInvoice) {
     85      return NextResponse.json({ error: 'Invoice not found or access denied' }, { status: 404 });
     86    }
     87
     88    // Update invoice and related data
     89    const updatedInvoice = await prisma.$transaction(async (tx) => {
     90      // Conditionally delete and recreate items only if they are provided
     91      if (validation.data.items) {
     92        await tx.invoiceItem.deleteMany({
     93          where: { invoiceId: params.id },
     94        });
     95      }
     96
     97      // Update the invoice and create new items if provided
     98      return tx.invoice.update({
     99        where: { id: params.id },
     100        data: {
     101          invoiceNumber: validation.data.invoiceNumber,
     102          createDate: validation.data.createDate,
     103          dueDate: validation.data.dueDate,
     104          status: validation.data.status,
     105          currency: validation.data.currency,
     106          quantityType: validation.data.quantityType,
     107          subTotal: validation.data.subTotal,
     108          month: validation.data.month,
     109          totalAmount: validation.data.totalAmount,
     110          discount: validation.data.discount,
     111          taxes: validation.data.taxes,
     112          pdfRef: validation.data.pdfRef,
     113          invoiceTo: {
     114            update: validation.data.invoiceTo,
     115          },
     116          items: validation.data.items
     117            ? {
     118                create: validation.data.items.map((item) => ({
     119                  ...item,
     120                  service: {
     121                    connect: { id: item.service.id },
     122                  },
     123                })),
     124              }
     125            : undefined,
     126        },
     127        include: {
     128          invoiceFrom: true,
     129          invoiceTo: true,
     130          items: true,
     131        },
     132      });
     133    });
     134
     135    return NextResponse.json(updatedInvoice);
     136  } catch (error) {
     137    console.error('Error updating invoice:', error);
     138
     139    if (error instanceof Prisma.PrismaClientKnownRequestError) {
     140      return NextResponse.json({ error: 'Database error occurred' }, { status: 500 });
     141    }
     142
     143    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
     144  }
     145}
     146
     147export async function DELETE(request: NextRequest, { params }: { params: { id: string } }) {
     148  try {
     149    // Validate ID format
     150    if (!params.id || !/^[0-9a-fA-F-]+$/.test(params.id)) {
     151      return NextResponse.json({ error: 'Invalid invoice ID format' }, { status: 400 });
     152    }
     153
     154    // Authenticate request
     155    const authResult = await authenticateRequest(request);
     156    if (authResult instanceof NextResponse) {
     157      return authResult;
     158    }
     159    const { userId } = authResult;
     160    console.log('userId', userId);
     161
     162    // Verify invoice exists and belongs to user
     163    const existingInvoice = await prisma.invoice.findFirst({
     164      where: {
     165        id: params.id,
     166      },
     167    });
     168
     169    if (!existingInvoice) {
     170      return NextResponse.json({ error: 'Invoice not found or access denied' }, { status: 404 });
     171    }
     172
     173    // Delete invoice and related items in a transaction
     174    await prisma.$transaction(async (tx) => {
     175      // Delete related items first
     176      await tx.invoiceItem.deleteMany({
     177        where: { invoiceId: params.id },
     178      });
     179
     180      // Delete the invoice
     181      await tx.invoice.delete({
     182        where: { id: params.id },
     183      });
     184    });
     185
     186    return NextResponse.json({ message: 'Invoice deleted successfully' }, { status: 200 });
     187  } catch (error) {
     188    console.error('Error deleting invoice:', error);
     189
     190    if (error instanceof Prisma.PrismaClientKnownRequestError) {
     191      if (error.code === 'P2025') {
     192        return NextResponse.json({ error: 'Invoice not found' }, { status: 404 });
     193      }
     194      return NextResponse.json({ error: 'Database error occurred' }, { status: 500 });
     195    }
     196
     197    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
     198  }
     199}

  • src/app/api/invoices/route.ts

    r5d6f37a r057453c  
    11import { NextRequest, NextResponse } from 'next/server';
    2 import { invoiceSchema, invoiceTableFiltersSchema } from 'mvpmasters-shared';
     2import { createInvoiceSchema, invoiceSchema, invoiceTableFiltersSchema } from 'src/schemas';
    33import prisma from 'src/lib/prisma';
    44import { auth } from 'src/lib/firebase-admin';
     5import { InvoiceStatus } from '@prisma/client';
    56
    67// Helper function to get userId from Authorization header
    … …  
    4142    const invoices = await prisma.invoice.findMany({
    4243      where: {
    43         userId,
    44         status: validatedFilters.status ? { equals: validatedFilters.status } : undefined,
     44        status: validatedFilters.status
     45          ? { equals: validatedFilters.status as InvoiceStatus }
     46          : undefined,
    4547        createDate: {
    46           gte: validatedFilters.startDate,
    47           lte: validatedFilters.endDate,
     48          ...(validatedFilters.startDate && { gte: validatedFilters.startDate }),
     49          ...(validatedFilters.endDate && { lte: validatedFilters.endDate }),
    4850        },
    4951        items:
    … …  
    7779
    7880    const body = await request.json();
    79     const validatedData = invoiceSchema.parse(body);
     81    const validatedData = createInvoiceSchema.parse(body);
     82
     83    const tenant = await prisma.tenant.findUnique({
     84      where: { id: validatedData.invoiceFrom.id },
     85    });
     86
     87    const toCustomer = await prisma.client.findUnique({
     88      where: { id: validatedData.invoiceTo.id },
     89    });
     90
     91    if (!tenant || !toCustomer) {
     92      return NextResponse.json({ error: 'Invoice sender or recipient not found' }, { status: 404 });
     93    }
     94
     95    // Update lastInvoiceNumber in tenant
     96    const updatedTenant = await prisma.tenant.update({
     97      where: { id: tenant.id },
     98      data: {
     99        lastInvoiceNumber: validatedData.invoiceNumber,
     100      },
     101    });
    80102
    81103    const invoice = await prisma.invoice.create({
    82104      data: {
    83         ...validatedData,
    84         userId,
     105        dueDate: validatedData.dueDate,
     106        status: validatedData.status,
     107        currency: validatedData.currency,
     108        quantityType: validatedData.quantityType,
     109        subTotal: validatedData.subTotal,
     110        createDate: validatedData.createDate,
     111        month: validatedData.month,
     112        discount: validatedData.discount,
     113        taxes: validatedData.taxes,
     114        totalAmount: validatedData.totalAmount,
     115        invoiceNumber: validatedData.invoiceNumber,
     116        invoiceFromId: tenant.id,
     117        invoiceToId: toCustomer.id,
    85118        items: {
    86           create: validatedData.items,
     119          create: validatedData.items.map((item) => ({
     120            title: item.title,
     121            price: item.price,
     122            total: item.total,
     123            quantity: item.quantity,
     124            description: item.description,
     125            service: {
     126              connect: { id: item.service.id },
     127            },
     128          })),
    87129        },
    88130      },
    … …  
    100142    return NextResponse.json(invoice, { status: 201 });
    101143  } catch (error) {
     144    console.error(error);
    102145    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
    103146  }
Note: See TracChangeset for help on using the changeset viewer.