Merge branch 'develop' into tonys-branch

Author: chpy04

src/backend/src/controllers/projects.controllers.ts

@@ -437,13 +437,14 @@ export default class ProjectsController {
   static async editLinkType(req: Request, res: Response, next: NextFunction) {
     try {
       const { linkTypeName } = req.params;
-      const { iconName, required } = req.body;
+      const { name: newName, iconName, required } = req.body;
       const linkTypeUpdated = await ProjectsService.editLinkType(
         linkTypeName,
         iconName,
         required,
         req.currentUser,
-        req.organization
+        req.organization,
+        newName
       );
       res.status(200).json(linkTypeUpdated);
     } catch (error: unknown) {

src/backend/src/controllers/reimbursement-requests.controllers.ts

@@ -497,6 +497,25 @@ export default class ReimbursementRequestsController {
     }
   }
 
+  static async setVendorTaxExemptStatus(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { vendorId } = req.params;
+
+      const { taxExempt } = req.body;
+
+      const updatedVendor = await ReimbursementRequestService.setVendorTaxExemptStatus(
+        vendorId,
+        taxExempt,
+        req.currentUser,
+        req.organization
+      );
+
+      res.status(200).json(updatedVendor);
+    } catch (error) {
+      next(error);
+    }
+  }
+
   static async deleteVendor(req: Request, res: Response, next: NextFunction) {
     try {
       const { vendorId } = req.params;

src/backend/src/routes/projects.routes.ts

@@ -29,6 +29,7 @@ projectRouter.post(
 );
 projectRouter.post(
   '/link-types/:linkTypeName/edit',
+  nonEmptyString(body('name').optional()),
   nonEmptyString(body('iconName')),
   body('required').isBoolean(),
   validateInputs,

src/backend/src/routes/reimbursement-requests.routes.ts

@@ -101,6 +101,11 @@ reimbursementRequestsRouter.post(
   ReimbursementRequestController.editVendor
 );
 
+reimbursementRequestsRouter.post(
+  '/vendors/:vendorId/setTaxExemptStatus',
+  ReimbursementRequestController.setVendorTaxExemptStatus
+);
+
 reimbursementRequestsRouter.post('/:vendorId/vendors/delete', ReimbursementRequestController.deleteVendor);
 
 reimbursementRequestsRouter.post(
@@ -167,7 +172,7 @@ reimbursementRequestsRouter.post(
   body('taxExempt').optional().isBoolean(),
   body('twoFactorContacts').optional().isArray(),
   nonEmptyString(body('twoFactorContacts.*')),
-  nonEmptyString(body('notes')).optional(),
+  body('notes').optional().isString(),
   validateInputs,
   ReimbursementRequestController.createVendor
 );

src/backend/src/services/change-requests.services.ts

@@ -178,7 +178,7 @@ export default class ChangeRequestsService {
         dateReviewed: null
       },
       {
-        NOT: { scopeChangeRequest: null }
+        changes: { none: {} }
       }
     ];
 
@@ -666,9 +666,7 @@ export default class ChangeRequestsService {
       include: {
         changeRequests: {
           where: {
-            dateDeleted: {
-              not: null
-            }
+            dateDeleted: null
           },
           include: {
             changes: true

src/backend/src/services/finance.services.ts

@@ -1096,15 +1096,20 @@ export default class FinanceServices {
 
     if (!tier) throw new NotFoundException('Sponsor Tier', sponsorTierId);
 
-    const existingSponsor = await prisma.sponsor.findFirst({
-      where: {
-        name,
-        organizationId: organization.organizationId
-      }
-    });
+    if (name !== oldSponsor.name) {
+      const existingSponsor = await prisma.sponsor.findFirst({
+        where: {
+          name: {
+            equals: name,
+            mode: 'insensitive'
+          },
+          organizationId: organization.organizationId
+        }
+      });
 
-    if (existingSponsor) {
-      throw new HttpException(400, `A sponsor with the name "${name}" already exists.`);
+      if (existingSponsor) {
+        throw new HttpException(400, `A sponsor with the name "${name}" already exists.`);
+      }
     }
 
     const updatedSponsor = await prisma.sponsor.update({

src/backend/src/services/projects.services.ts

@@ -621,7 +621,8 @@ export default class ProjectsService {
     iconName: string,
     required: boolean,
     submitter: User,
-    organization: Organization
+    organization: Organization,
+    newName?: string
   ): Promise<LinkType> {
     if (!(await userHasPermission(submitter.userId, organization.organizationId, isAdmin)))
       throw new AccessDeniedException('Only an admin can update the linkType');
@@ -638,11 +639,25 @@ export default class ProjectsService {
 
     if (!linkType) throw new NotFoundException('Link Type', linkName);
 
+    // If attempting to rename, ensure new name does not conflict with an existing LinkType
+    if (newName && newName !== linkName) {
+      const existingWithNewName = await prisma.link_Type.findUnique({
+        where: {
+          uniqueLinkType: {
+            name: newName,
+            organizationId: organization.organizationId
+          }
+        }
+      });
+
+      if (existingWithNewName) throw new HttpException(400, 'LinkType with that name already exists in this organization.');
+    }
+
     // update the LinkType
     const linkTypeUpdated = await prisma.link_Type.update({
       where: { id: linkType.id },
       data: {
-        name: linkName,
+        name: newName && newName ? newName : linkName,
         iconName,
         required
       }

src/backend/src/services/reimbursement-requests.services.ts

@@ -1544,6 +1544,42 @@ export default class ReimbursementRequestService {
     return vendorTransformer(vendor);
   }
 
+  static async setVendorTaxExemptStatus(
+    vendorId: string,
+    taxExempt: boolean,
+    submitter: User,
+    organization: Organization
+  ): Promise<Vendor> {
+    const existingVendor = await prisma.vendor.findUnique({
+      where: { vendorId, dateDeleted: null },
+      include: { twoFactorContacts: { select: { userId: true } } }
+    });
+
+    if (!existingVendor) {
+      throw new NotFoundException('Vendor', vendorId);
+    }
+
+    if (existingVendor.organizationId !== organization.organizationId) {
+      throw new InvalidOrganizationException('Vendor');
+    }
+
+    const isUserAuthorized =
+      existingVendor.addedByUserId === submitter.userId ||
+      (await isUserOnFinanceTeam(submitter, organization.organizationId)) ||
+      (await userHasPermission(submitter.userId, organization.organizationId, isHead));
+    if (!isUserAuthorized) {
+      throw new AccessDeniedException(`You are not a member of the finance team!`);
+    }
+
+    const updatedVendor = await prisma.vendor.update({
+      where: { vendorId },
+      data: { taxExempt },
+      ...getVendorQueryArgs(organization.organizationId)
+    });
+
+    return vendorTransformer(updatedVendor);
+  }
+
   /**
    * Deletes the vendor
    *

src/backend/tests/unmocked/reimbursement-requests.test.ts

@@ -1,6 +1,12 @@
 import { alfred, robinMember, cyborgMember, theVisitorGuest } from '../test-data/users.test-data';
 import ReimbursementRequestService from '../../src/services/reimbursement-requests.services';
-import { AccessDeniedException, DeletedException, HttpException, NotFoundException } from '../../src/utils/errors.utils';
+import {
+  AccessDeniedException,
+  DeletedException,
+  HttpException,
+  InvalidOrganizationException,
+  NotFoundException
+} from '../../src/utils/errors.utils';
 import { createTestReimbursementRequest, createTestUser, resetUsers } from '../test-utils';
 import prisma from '../../src/prisma/prisma';
 import { addDaysToDate, IndexCode, ReimbursementRequest, ReimbursementStatusType, AccountCode } from 'shared';
@@ -1041,4 +1047,82 @@ describe('Reimbursement Requests', () => {
       expect(assignedRRs).toEqual([]);
     });
   });
+
+  describe('Set vendor tax exempt status', () => {
+    test('Finance member can set vendor tax exempt status', async () => {
+      const updatedVendor = await ReimbursementRequestService.setVendorTaxExemptStatus(
+        createdVendor.vendorId,
+        true,
+        financeMember,
+        org
+      );
+
+      expect(updatedVendor).not.toBeNull();
+      expect(updatedVendor.taxExempt).toBe(true);
+    });
+
+    test('Non-finance member cannot set vendor tax exempt status', async () => {
+      await expect(
+        ReimbursementRequestService.setVendorTaxExemptStatus(createdVendor.vendorId, true, regularMember, org)
+      ).rejects.toThrow(new AccessDeniedException('You are not a member of the finance team!'));
+    });
+
+    test('Cannot set tax exempt status for non-existent vendor', async () => {
+      await expect(
+        ReimbursementRequestService.setVendorTaxExemptStatus('non-existent-id', true, financeMember, org)
+      ).rejects.toThrow(new NotFoundException('Vendor', 'non-existent-id'));
+    });
+
+    test('Cannot set tax exempt status for vendor in different organization', async () => {
+      // Create a vendor in a different organization
+      const otherOrg = await prisma.organization.create({
+        data: {
+          name: 'Other Org',
+          userCreated: { connect: { userId: financeHead.userId } }
+        }
+      });
+
+      const otherMember: User = await prisma.user.create({
+        data: {
+          firstName: 'Other',
+          lastName: 'Member',
+          googleAuthId: '99',
+          email: 'email@email.other',
+          roles: {
+            create: {
+              roleType: Role_Type.MEMBER,
+              organization: {
+                connect: { organizationId: otherOrg.organizationId }
+              }
+            }
+          }
+        }
+      });
+
+      const otherVendor = await ReimbursementRequestService.createVendor(
+        otherMember,
+        'Other Org Vendor',
+        otherOrg,
+        false,
+        [],
+        'Some notes'
+      );
+
+      await expect(
+        ReimbursementRequestService.setVendorTaxExemptStatus(otherVendor.vendorId, true, financeMember, org)
+      ).rejects.toThrow(new InvalidOrganizationException('Vendor'));
+    });
+
+    test('head can set vendor tax exempt status', async () => {
+      const updatedVendor = await ReimbursementRequestService.setVendorTaxExemptStatus(
+        createdVendor.vendorId,
+        true,
+        financeHead,
+        org
+      );
+
+      expect(updatedVendor).not.toBeNull();
+      expect(updatedVendor.taxExempt).toBe(true);
+    });
+  });
 });

src/frontend/src/apis/finance.api.ts

@@ -441,6 +441,16 @@ export const editVendor = async (id: string, vendorData: EditVendorPayload) => {
   return axios.post(apiUrls.financeEditVendor(id), vendorData);
 };
 
+/**
+ * API call to set the tax exempt status of a vendor
+ * @param vendorId id of vendor to set
+ * @param taxExempt whether the vendor is tax exempt
+ * @returns updated vendor
+ */
+export const setTaxExemptStatus = async (vendorId: string, taxExempt: boolean) => {
+  return axios.post(apiUrls.financeSetVendorTaxExemptStatus(vendorId), { taxExempt });
+};
+
 /**
  * API call to delete a given vendor
  *