- {{ form.upload?.name }} already exists in {{ form.folder }}{{ conflictDetail }}. Choose how to continue: -
+ {{ form.upload?.name }} already exists in {{ form.folder }}{{ conflictDetail }}. Choose how to continue: +
['"]).*?\k|[^;\n]*)/u, + ) + if (filenameMatch?.groups?.filename) { + filename = filenameMatch.groups.filename.replaceAll(/['"]/gu, "") } } @@ -303,3 +305,4 @@ function downloadBlob(blob: Blob, filename: string): void { } export { useFetch, postForBlob, downloadBlob, HTTP_STATUS } +export type { Result, Pagination } diff --git a/VueApp/src/composables/__tests__/use-person-search.test.ts b/VueApp/src/composables/__tests__/use-person-search.test.ts new file mode 100644 index 000000000..9c8d790cc --- /dev/null +++ b/VueApp/src/composables/__tests__/use-person-search.test.ts @@ -0,0 +1,82 @@ +import { usePersonSearch } from "../use-person-search" + +type Person = { iamId: string; fullName: string } + +type Deferred = { promise: Promise; resolve: (value: T) => void } + +// A controllable pending promise, for simulating a search that hasn't resolved yet. The `as` +// cast lets `resolve` be filled in by the executor without a separate uninitialized declaration. +function createDeferred(): Deferred { + const deferred = {} as Deferred + // eslint-disable-next-line avoid-new -- a controllable pending promise is the point of this helper + deferred.promise = new Promise((resolve) => { + deferred.resolve = resolve + }) + return deferred +} + +function applyUpdate(fn: () => void): void { + fn() +} + +function runFilter(searchPeople: (val: string, update: (fn: () => void) => void) => Promise, val: string) { + return searchPeople(val, applyUpdate) +} + +describe("usePersonSearch()", () => { + it("clears options without calling search when the term is below two characters", async () => { + expect.hasAssertions() + const search = vi.fn<(value: string) => Promise>() + const { searchPeople, options, loading } = usePersonSearch(search) + options.value = [{ iamId: "a", fullName: "Existing Person" }] + + await runFilter(searchPeople, "a") + + expect(search).not.toHaveBeenCalled() + expect(options.value).toStrictEqual([]) + expect(loading.value).toBeFalsy() + }) + + it("sets loading and populates options for a valid search", async () => { + expect.hasAssertions() + const results: Person[] = [{ iamId: "person01", fullName: "Amy Smith" }] + const search = vi.fn<(value: string) => Promise>().mockResolvedValue(results) + const { searchPeople, options } = usePersonSearch(search) + + await runFilter(searchPeople, " ab ") + + expect(search).toHaveBeenCalledWith("ab") + expect(options.value).toStrictEqual(results) + }) + + it("falls back to an empty list when search resolves null", async () => { + expect.hasAssertions() + const search = vi.fn<(value: string) => Promise>().mockResolvedValue(null) + const { searchPeople, options } = usePersonSearch(search) + + await runFilter(searchPeople, "ab") + + expect(options.value).toStrictEqual([]) + }) + + it("discards a slower, earlier response that resolves after a newer search", async () => { + expect.hasAssertions() + const first = createDeferred() + const second = createDeferred() + const search = vi + .fn<(value: string) => Promise>() + .mockReturnValueOnce(first.promise) + .mockReturnValueOnce(second.promise) + const { searchPeople, options } = usePersonSearch(search) + + const firstFilter = runFilter(searchPeople, "first") + const secondFilter = runFilter(searchPeople, "second") + + second.resolve([{ iamId: "second", fullName: "Second Result" }]) + await secondFilter + first.resolve([{ iamId: "first", fullName: "First Result" }]) + await firstFilter + + expect(options.value).toStrictEqual([{ iamId: "second", fullName: "Second Result" }]) + }) +}) diff --git a/VueApp/src/composables/use-person-search.ts b/VueApp/src/composables/use-person-search.ts new file mode 100644 index 000000000..56634b78c --- /dev/null +++ b/VueApp/src/composables/use-person-search.ts @@ -0,0 +1,41 @@ +import { ref } from "vue" + +/** + * Debounced, out-of-order-safe server search for a QSelect's @filter handler. Shared by every + * PersonSelector variant (CMS, Personnel): the search/race-guard logic is identical across them, + * only the search function and result type differ per caller. + */ +function usePersonSearch(search: (value: string) => Promise) { + const options = ref([]) + const loading = ref(false) + // Guards against out-of-order responses: only the latest search may update options + let searchSeq = 0 + + async function searchPeople(val: string, update: (fn: () => void) => void) { + if (val.trim().length < 2) { + // Invalidate any in-flight search too, or its late response would repopulate + // the options we just cleared. + searchSeq += 1 + loading.value = false + update(() => { + options.value = [] + }) + return + } + searchSeq += 1 + const seq = searchSeq + loading.value = true + const result = await search(val.trim()) + if (seq !== searchSeq) { + return + } + loading.value = false + update(() => { + options.value = result ?? [] + }) + } + + return { options, loading, searchPeople } +} + +export { usePersonSearch } diff --git a/VueApp/vueapp.esproj b/VueApp/vueapp.esproj index 8513a0c6b..1c514331e 100644 --- a/VueApp/vueapp.esproj +++ b/VueApp/vueapp.esproj @@ -18,7 +18,9 @@ + + - \ No newline at end of file + diff --git a/test/Classes/Utilities/PersonSearchHelperTests.cs b/test/Classes/Utilities/PersonSearchHelperTests.cs new file mode 100644 index 000000000..3eaaa3971 --- /dev/null +++ b/test/Classes/Utilities/PersonSearchHelperTests.cs @@ -0,0 +1,137 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Classes.Utilities; + +namespace Viper.test.Classes.Utilities; + +/// +/// Tests for PersonSearchHelper, the shared "search current people by partial name" query shape +/// used by both the CMS file/permission pickers and the Personnel phone directory. A regression +/// here affects every autocomplete built on it. +/// +public class PersonSearchHelperTests +{ + private sealed class Person + { + public required string LastName { get; set; } + public required string FirstName { get; set; } + public string LoginId { get; set; } = ""; + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + [InlineData("a")] + [InlineData(" a ")] + public void Normalize_ReturnsNull_WhenBelowMinimumLength(string? search) + { + Assert.Null(PersonSearchHelper.Normalize(search)); + } + + [Fact] + public void Normalize_ReturnsTrimmedValue_WhenAtOrAboveMinimumLength() + { + var result = PersonSearchHelper.Normalize(" ab "); + + Assert.Equal("ab", result); + } + + [Fact] + public void NameMatches_MatchesLastCommaFirstForm() + { + var people = new[] { new Person { LastName = "Smith", FirstName = "Amy" } }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "mith, A"); + + var results = people.Where(predicate).ToList(); + + Assert.Single(results); + } + + [Fact] + public void NameMatches_MatchesFirstSpaceLastForm() + { + var people = new[] { new Person { LastName = "Smith", FirstName = "Amy" } }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Amy Sm"); + + var results = people.Where(predicate).ToList(); + + Assert.Single(results); + } + + [Fact] + public void NameMatches_ExcludesNonMatchingPeople() + { + var people = new[] + { + new Person { LastName = "Smith", FirstName = "Amy" }, + new Person { LastName = "Jones", FirstName = "Bob" }, + }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Smith"); + + var results = people.Where(predicate).ToList(); + + var match = Assert.Single(results); + Assert.Equal("Smith", match.LastName); + } + + [Fact] + public void OrderAndCap_OrdersByLastNameThenFirstName_AndCapsToMaxResults() + { + var people = Enumerable.Range(0, 30) + .Select(i => new Person { LastName = $"Person{i:D2}", FirstName = "X" }) + .Reverse() + .AsQueryable(); + + var results = PersonSearchHelper.OrderAndCap(people, p => p.LastName, p => p.FirstName).ToList(); + + Assert.Equal(PersonSearchHelper.MaxResults, results.Count); + Assert.Equal("Person00", results[0].LastName); + Assert.Equal("Person24", results[^1].LastName); + } + + [Fact] + public void Or_IncludesRecordsMatchingEitherPredicate() + { + var people = new[] + { + new Person { LastName = "Smith", FirstName = "Amy", LoginId = "asmith" }, + new Person { LastName = "Jones", FirstName = "Bob", LoginId = "bjones" }, + }.AsQueryable(); + var namePredicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Smith"); + var combined = namePredicate.Or(p => p.LoginId == "bjones"); + + var results = people.Where(combined).ToList(); + + Assert.Equal(2, results.Count); + } + + private sealed class SearchTestContext(DbContextOptions options) : DbContext(options) + { + public DbSet People => Set(); + + protected override void OnModelCreating(ModelBuilder modelBuilder) + => modelBuilder.Entity().HasKey(p => p.LastName); + } + + [Fact] + public void NameMatches_EmitsASqlParameter_RatherThanALiteral() + { + // These autocompletes fire per keystroke, so a term embedded as a literal would give every + // distinct search its own query plan. The literal form also drops the ESCAPE clause, which + // is what stops a typed % or _ from being treated as a wildcard. + var options = new DbContextOptionsBuilder() + .UseSqlServer("Server=none;Database=none;Trusted_Connection=True;") + .Options; + using var context = new SearchTestContext(options); + + var sql = context.People + .Where(PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "smith")) + .ToQueryString(); + + // Assert on the predicate, not the whole string: ToQueryString prefixes a DECLARE that + // spells the value out for copy-paste even when the query itself is parameterized. + Assert.Contains("LIKE @", sql, StringComparison.Ordinal); + Assert.DoesNotContain("LIKE N'", sql, StringComparison.Ordinal); + Assert.Contains("ESCAPE", sql, StringComparison.Ordinal); + } +} diff --git a/test/Personnel/PhoneListControllerTests.cs b/test/Personnel/PhoneListControllerTests.cs new file mode 100644 index 000000000..dfeeb5e00 --- /dev/null +++ b/test/Personnel/PhoneListControllerTests.cs @@ -0,0 +1,165 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListController. GetListInfo is what the client renders from before +/// it fetches any rows, so the two capability flags it reports have to match what the write and +/// read endpoints actually enforce: CanMaintain follows the list's own MaintainRole, and +/// CanViewDirectPhone is deliberately broader - a member of the list sees direct numbers without +/// being able to edit it. A flag that overstated either would show the client controls the API +/// then refuses. +/// +public sealed class PhoneListControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListController _controller; + + private const string CallerIam = "caller01"; + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + + public PhoneListControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, _userHelper, permissionsService); + + _controller = new PhoneListController(phoneListService, unitService, permissionsService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = CallerIam, Phone = "530-555-1000" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + /// Puts the caller on the list itself, which is not the same as maintaining it. + private void AddCallerToList() + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = 1, + PhoneListUnitId = 1, + PersonIam = CallerIam, + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + private async Task GetInfo(string code) + { + var result = await _controller.GetListInfo(code, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsType(okResult.Value); + } + + [Fact] + public async Task GetListInfo_ReturnsTheListIdentity() + { + var info = await GetInfo("VMDO"); + + Assert.Equal(1, info.PhoneListId); + Assert.Equal("VMDO", info.Code); + Assert.Equal("Dean's Office", info.Name); + } + + [Fact] + public async Task GetListInfo_ReportsNoCapabilities_ForACallerWithNeitherRoleNorMembership() + { + var info = await GetInfo("VMDO"); + + Assert.False(info.CanMaintain); + Assert.False(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReportsBothCapabilities_ForAMaintainer() + { + GrantRole(VmdoRole); + + var info = await GetInfo("VMDO"); + + Assert.True(info.CanMaintain); + Assert.True(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReportsDirectPhoneOnly_ForAMemberWhoCannotMaintain() + { + // Membership is what grants the direct-number view, so the two flags have to move + // independently: reporting CanMaintain here would offer edit controls the API refuses. + AddCallerToList(); + + var info = await GetInfo("VMDO"); + + Assert.False(info.CanMaintain); + Assert.True(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_IgnoresMembershipOfAnotherList() + { + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + AddCallerToList(); + + var info = await GetInfo("OTHER"); + + Assert.False(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetListInfo("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneListModifiedDateControllerTests.cs b/test/Personnel/PhoneListModifiedDateControllerTests.cs new file mode 100644 index 000000000..f97e34392 --- /dev/null +++ b/test/Personnel/PhoneListModifiedDateControllerTests.cs @@ -0,0 +1,140 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListModifiedDateController, the endpoint clients poll to decide +/// whether their cached copy of a list is stale. Two properties matter: deleted rows still count +/// (a removal is a change the client has to pick up, and soft-deleted rows are the only record of +/// it), and the date is scoped to the list named in the route. +/// +public sealed class PhoneListModifiedDateControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneListModifiedDateController _controller; + + private static readonly DateTime Older = new(2026, 1, 1, 9, 0, 0, DateTimeKind.Local); + private static readonly DateTime Newer = new(2026, 6, 1, 9, 0, 0, DateTimeKind.Local); + + public PhoneListModifiedDateControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, userHelper, permissionsService); + + _controller = new PhoneListModifiedDateController(phoneListService, unitService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain", + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 2, PhoneListId = 2, Name = "Other Office" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void AddRow(int unitPersonId, int unitId, DateTime? modifiedDate, bool isActive = true) + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = "person01", + ListFirst = false, + IsActive = isActive, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private async Task GetDate(string code) + { + var result = await _controller.GetLastModifiedDate(code, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return (DateTime?)okResult.Value; + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheMostRecentDate() + { + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 1, Newer); + + Assert.Equal(Newer, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_CountsDeletedRows() + { + // A removal is the change most likely to matter to a client holding stale rows, and the + // soft-deleted row is the only record that it happened. + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 1, Newer, isActive: false); + + Assert.Equal(Newer, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_IgnoresAnotherListsRows() + { + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 2, Newer); + + Assert.Equal(Older, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNull_WhenNothingHasBeenModified() + { + AddRow(unitPersonId: 1, unitId: 1, modifiedDate: null); + + Assert.Null(await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetLastModifiedDate("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneListServiceTests.cs b/test/Personnel/PhoneListServiceTests.cs new file mode 100644 index 000000000..0401a9277 --- /dev/null +++ b/test/Personnel/PhoneListServiceTests.cs @@ -0,0 +1,78 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneListService, the entry point every list-scoped request resolves a list +/// through. Lookup is by Code rather than Name so that renaming a list for display cannot +/// break the routes and API paths that address it. +/// +public sealed class PhoneListServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneListService _service; + + public PhoneListServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + _service = new PhoneListService(_context); + } + + public void Dispose() => _context.Dispose(); + + private void SeedLists() + { + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain", + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + _context.SaveChanges(); + } + + [Fact] + public async Task GetListByCode_ReturnsMatchingList() + { + SeedLists(); + + var result = await _service.GetListByCode("OTHER", TestContext.Current.CancellationToken); + + Assert.Equal(2, result.PhoneListId); + Assert.Equal("Some Other Unit", result.Name); + } + + [Fact] + public async Task GetListByCode_ResolvesIndependentlyOfDisplayName() + { + SeedLists(); + var list = await _context.PhoneList.SingleAsync(l => l.Code == "VMDO", TestContext.Current.CancellationToken); + list.Name = "Office of the Dean"; + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _service.GetListByCode("VMDO", TestContext.Current.CancellationToken); + + Assert.Equal(1, result.PhoneListId); + } + + [Fact] + public async Task GetListByCode_Throws_WhenCodeNotFound() + { + await Assert.ThrowsAsync( + () => _service.GetListByCode("NOPE", TestContext.Current.CancellationToken)); + } +} diff --git a/test/Personnel/PhoneListUnitControllerTests.cs b/test/Personnel/PhoneListUnitControllerTests.cs new file mode 100644 index 000000000..cea934723 --- /dev/null +++ b/test/Personnel/PhoneListUnitControllerTests.cs @@ -0,0 +1,234 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListUnitController. Beyond the InvalidOperationException-to-400 +/// mapping, these cover the authorization model: write access is the role named by the target +/// list's own MaintainRole column, so holding one list's role must grant nothing on another, +/// and a record id from one list must not be reachable through another list's route. +/// +public sealed class PhoneListUnitControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListUnitController _controller; + + private const string CallerIam = "caller01"; + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string OtherRole = "SVMSecure.PhoneLists.OtherMaintain"; + + public PhoneListUnitControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, _userHelper, permissionsService); + + _controller = new PhoneListUnitController(phoneListService, unitService, permissionsService); + + // Two lists, each with its own unit and its own maintain role. + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = OtherRole, + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 2, PhoneListId = 2, Name = "Other Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "person01", Phone = "530-555-1000" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + /// Grants the caller exactly one maintain role. + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + private void AddUnitPersonRow(int unitPersonId, int unitId) + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = "person01", + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + private static PhoneListUnitDataRequest Request(int unitId) => new() + { + UnitId = unitId, + EmployeeIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + Office = "Room 100", + }; + + [Fact] + public async Task GetUnits_ReturnsOk_WithUnitsForTheNamedList() + { + var result = await _controller.GetUnits("VMDO", TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var units = Assert.IsAssignableFrom>(okResult.Value); + Assert.Equal("Front Office", Assert.Single(units).Name); + } + + [Fact] + public async Task GetUnits_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetUnits("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } + + [Fact] + public async Task AddUnitPersonData_ReturnsOk_ForAMaintainerOfThatList() + { + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("VMDO", Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task AddUnitPersonData_IsForbidden_WithoutTheRoleForThatList() + { + var result = await _controller.AddUnitPersonData("VMDO", Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task AddUnitPersonData_IsForbidden_ForAMaintainerOfADifferentList() + { + // Holding VMDOMaintain must not confer write access to the OTHER list, which is what a + // hard-coded permission attribute on the endpoint would have allowed. + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("OTHER", Request(2), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.PhoneListUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddUnitPersonData_ReturnsBadRequest_WhenTheUnitBelongsToAnotherList() + { + // Unit 2 is on the OTHER list; routing through VMDO must not reach it. + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("VMDO", Request(2), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.PhoneListUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task UpdateUnitPersonData_ReturnsBadRequest_WhenNotFound() + { + GrantRole(VmdoRole); + + var result = await _controller.UpdateUnitPersonData("VMDO", 999, Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task UpdateUnitPersonData_ReturnsBadRequest_WhenTheRecordBelongsToAnotherList() + { + AddUnitPersonRow(unitPersonId: 5, unitId: 2); + GrantRole(VmdoRole); + + var result = await _controller.UpdateUnitPersonData("VMDO", 5, Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + var untouched = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 5 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouched); + Assert.True(untouched.IsActive); + } + + [Fact] + public async Task DeleteUnitPersonData_ReturnsBadRequest_WhenNotFound() + { + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteUnitPersonData_ReturnsOk_AndSoftDeletes_WhenFound() + { + AddUnitPersonRow(unitPersonId: 1, unitId: 1); + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } + + [Fact] + public async Task DeleteUnitPersonData_LeavesTheRecordAlone_WhenItBelongsToAnotherList() + { + AddUnitPersonRow(unitPersonId: 5, unitId: 2); + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 5, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var untouched = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 5 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouched); + Assert.True(untouched.IsActive); + } +} diff --git a/test/Personnel/PhoneListUnitServiceTests.cs b/test/Personnel/PhoneListUnitServiceTests.cs new file mode 100644 index 000000000..e7a89769d --- /dev/null +++ b/test/Personnel/PhoneListUnitServiceTests.cs @@ -0,0 +1,406 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneListUnitService, focused on the direct-phone visibility rule: +/// a caller may only see DirectPhone for a list if they hold the list's maintain +/// permission, OR they are themselves an active member of that list. +/// +public sealed class PhoneListUnitServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListUnitService _service; + + private const string MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string CallerIam = "caller01"; + + public PhoneListUnitServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + // rapsContext is unused when IUserHelper.HasPermission is mocked directly, + // so a bare substitute (no seeded roles) is sufficient here. + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + + _service = new PhoneListUnitService(_context, _userHelper, permissionsService); + + SeedList(); + } + + public void Dispose() => _context.Dispose(); + + /// The seeded list, as the controller would hand it to the service. + private PhoneList TestList() => + _context.PhoneList.Single(l => l.PhoneListId == 1); + + private void AddUnit(int unitId, string name) + { + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = unitId, PhoneListId = 1, Name = name }); + _context.SaveChanges(); + } + + /// Puts a person on a unit, with the phone row the read paths expect them to have. + private void AddMember(int unitPersonId, int unitId, string personIam, bool listFirst) + { + _context.PhonePerson.Add(new PhonePerson { PersonIam = personIam, Phone = "530-555-0000" }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = personIam, + ListFirst = listFirst, + IsActive = true, + }); + _context.SaveChanges(); + } + + private async Task FindMember(int unitPersonId) => + await _context.PhoneListUnitPerson.FindAsync(new object?[] { unitPersonId }, TestContext.Current.CancellationToken); + + private void SeedList() + { + _context.PhoneList.Add(new PhoneList { PhoneListId = 1, Code = "VMDO", Name = "Dean's Office", MaintainRole = MaintainRole }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Dean's Office" }); + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "listedperson", + FirstName = "Listed", + LastName = "Person", + FullName = "Listed Person", + CurrentEmployee = true, + }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "listedperson", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + Office = "Room 100", + }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitId = 1, + PersonIam = "listedperson", + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + [Fact] + public async Task GetPhoneListUnits_MasksDirectPhone_WhenCallerHasNoAccess() + { + // Caller has neither the maintain permission nor a membership row on this list. + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + + var units = await _service.GetPhoneListUnits(TestList(), TestContext.Current.CancellationToken); + + var person = Assert.Single(Assert.Single(units).PhoneListUnitPersons); + Assert.Equal("530-555-1000", person.Person.Phone); + Assert.Equal("", person.Person.DirectPhone); + } + + [Fact] + public async Task GetPhoneListUnits_ShowsDirectPhone_WhenCallerIsListMember() + { + // No maintain permission, but the caller is themselves an active member of the list - + // membership alone should be enough to unlock direct numbers for that list. + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + _context.PhonePerson.Add(new PhonePerson { PersonIam = CallerIam, Phone = "", DirectPhone = "", Office = "" }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitId = 1, + PersonIam = CallerIam, + ListFirst = false, + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var units = await _service.GetPhoneListUnits(TestList(), TestContext.Current.CancellationToken); + + var person = Assert.Single(units.Single().PhoneListUnitPersons, p => p.PersonIam == "listedperson"); + Assert.Equal("530-555-2000", person.Person.DirectPhone); + } + + [Fact] + public async Task AddUnitPersonData_UnsetsPreviousListFirst_WhenNewPersonIsMarkedFirst() + { + var existingFirstPerson = Assert.Single(_context.PhoneListUnitPerson); + existingFirstPerson.ListFirst = true; + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 2, + IamId = "newperson", + FirstName = "New", + LastName = "Person", + FullName = "New Person", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "newperson", + Phone = "530-555-5000", + DirectPhone = "530-555-6000", + Office = "Room 300", + ListFirst = true, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + Assert.False(existingFirstPerson.ListFirst); + var newPerson = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "newperson", TestContext.Current.CancellationToken); + Assert.True(newPerson.ListFirst); + } + + [Fact] + public async Task AddUnitPersonData_CalledTwiceForSamePerson_UpsertsInsteadOfDuplicating() + { + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-9000", + DirectPhone = "530-555-9001", + Office = "Room 900", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var associations = await _context.PhoneListUnitPerson + .Where(p => p.PersonIam == "listedperson" && p.PhoneListUnitId == 1) + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Single(associations); + + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + Assert.Equal("530-555-9000", phonePerson.Phone); + Assert.Equal("530-555-9001", phonePerson.DirectPhone); + Assert.Equal("Room 900", phonePerson.Office); + } + + [Fact] + public async Task AddUnitPersonData_TrimsWhitespace_ForANewPerson() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 3, + IamId = "paddedperson", + FirstName = "Padded", + LastName = "Person", + FullName = "Padded Person", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = " paddedperson ", + Phone = " 530-555-9500 ", + DirectPhone = " 530-555-9501 ", + Office = " Room 950 ", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "paddedperson", TestContext.Current.CancellationToken); + Assert.Equal("530-555-9500", phonePerson.Phone); + Assert.Equal("Room 950", phonePerson.Office); + } + + [Fact] + public async Task AddUnitPersonData_CalledTwiceWithAPaddedIam_UpsertsInsteadOfDuplicating() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 4, + IamId = "paddedtwice", + FirstName = "Padded", + LastName = "Twice", + FullName = "Padded Twice", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // The existing-row lookup has to trim the same way the insert does. Matching a padded + // request against the trimmed PersonIam already stored finds nothing, so every resubmit + // would add another association row for the same person and unit. + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = " paddedtwice ", + Phone = " 530-555-9600 ", + DirectPhone = " 530-555-9601 ", + Office = " Room 960 ", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var association = Assert.Single(await _context.PhoneListUnitPerson + .Where(p => p.PersonIam == "paddedtwice" && p.PhoneListUnitId == 1) + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.True(association.IsActive); + Assert.Equal("paddedtwice", association.PersonIam); + } + + [Fact] + public async Task UpdateUnitPersonData_UpdatesThePhonePerson_AndModifiedMetadata() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = " 530-555-7000 ", + DirectPhone = " 530-555-7001 ", + Office = " Room 700 ", + }; + + await _service.UpdateUnitPersonData( + 1, unitPerson.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + var phonePerson = await _context.PhonePerson + .FindAsync(new object?[] { "listedperson" }, TestContext.Current.CancellationToken); + Assert.NotNull(phonePerson); + Assert.Equal("530-555-7000", phonePerson.Phone); + Assert.Equal("530-555-7001", phonePerson.DirectPhone); + Assert.Equal("Room 700", phonePerson.Office); + Assert.Equal(CallerIam, unitPerson.ModifiedBy); + Assert.NotNull(unitPerson.ModifiedDate); + } + + [Fact] + public async Task UpdateUnitPersonData_ClearsListFirstOnTheRecordsOwnUnit_NotTheRequestedOne() + { + // The request carries a UnitId, but the record already knows which unit it lives in. Only + // the record's own unit may be cleared: taking the caller's word for it would let a + // mismatched UnitId unset the first-listed entry of an unrelated unit. + AddUnit(unitId: 2, name: "Other Office"); + AddMember(unitPersonId: 10, unitId: 1, personIam: "sameunitfirst", listFirst: true); + AddMember(unitPersonId: 20, unitId: 2, personIam: "otherunitfirst", listFirst: true); + var target = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 2, + EmployeeIam = "listedperson", + Phone = "530-555-7000", + ListFirst = true, + }; + + await _service.UpdateUnitPersonData( + 1, target.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + Assert.True(target.ListFirst); + Assert.False((await FindMember(10))!.ListFirst); + Assert.True((await FindMember(20))!.ListFirst); + } + + [Fact] + public async Task UpdateUnitPersonData_LeavesTheExistingFirstEntry_WhenListFirstIsNotSet() + { + AddMember(unitPersonId: 10, unitId: 1, personIam: "sameunitfirst", listFirst: true); + var target = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-7000", + ListFirst = false, + }; + + await _service.UpdateUnitPersonData( + 1, target.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + Assert.False(target.ListFirst); + Assert.True((await FindMember(10))!.ListFirst); + } + + [Fact] + public async Task DeleteUnitPersonData_SoftDeletes_KeepsRowButMarksInactive() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + + await _service.DeleteUnitPersonData(1, unitPerson.PhoneListUnitPersonId, TestContext.Current.CancellationToken); + + var stillExists = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { unitPerson.PhoneListUnitPersonId }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + Assert.Equal(CallerIam, stillExists.ModifiedBy); + } + + [Fact] + public async Task DeleteUnitPersonData_Throws_WhenNotFound() + { + await Assert.ThrowsAsync( + () => _service.DeleteUnitPersonData(1, 9999, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task EditingAnAlreadyDeletedRecord_ReportsItAsRemoved_RatherThanResurrectingIt() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + await _service.DeleteUnitPersonData(1, unitPerson.PhoneListUnitPersonId, TestContext.Current.CancellationToken); + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-9000", + }; + + // A maintainer whose page predates someone else's delete. Saving must not bring the row + // back, and the message becomes an error banner, so it is worded for that reader. + var ex = await Assert.ThrowsAsync( + () => _service.UpdateUnitPersonData( + 1, unitPerson.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken)); + Assert.Equal("That record has already been removed.", ex.Message); + + var stillDeleted = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { unitPerson.PhoneListUnitPersonId }, TestContext.Current.CancellationToken); + Assert.NotNull(stillDeleted); + Assert.False(stillDeleted.IsActive); + } +} diff --git a/test/Personnel/PhonePersonControllerTests.cs b/test/Personnel/PhonePersonControllerTests.cs new file mode 100644 index 000000000..cd692c5b1 --- /dev/null +++ b/test/Personnel/PhonePersonControllerTests.cs @@ -0,0 +1,204 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhonePersonController, the person picker behind the phone-record dialogs. +/// The controller does the merge itself rather than delegating it: two independent queries (people +/// from users.Person, phone rows from phones.Person) are joined in memory, so the cases worth +/// pinning are the ones the join can get wrong - a person with no phone row, a phone row with no +/// matching person - plus the direct-number masking, which depends on a list code supplied by the +/// caller and so must fail closed when that code is absent or bogus. +/// +public sealed class PhonePersonControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhonePersonController _controller; + + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + + public PhonePersonControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var lookupService = new PhonePersonLookupService(_context, permissionsService); + + _controller = new PhonePersonController(phoneListService, lookupService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Ada", + LastName = "Smithers", + FullName = "Ada Smithers", + CurrentEmployee = true, + MailId = "asmithers", + }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + private async Task> Search(string search, string? listCode = null) + { + var result = await _controller.GetCurrentEmployees(search, listCode, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsAssignableFrom>(okResult.Value); + } + + [Fact] + public async Task GetCurrentEmployees_MergesPhoneDataOntoTheMatchedPerson() + { + var results = await Search("Smithers"); + + var person = Assert.Single(results); + Assert.Equal("person01", person.IamId); + Assert.Equal("Ada Smithers", person.FullName); + Assert.NotNull(person.PhoneData); + Assert.Equal("530-555-1000", person.PhoneData.Phone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_WhenNoListIsNamed() + { + var results = await Search("Smithers"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_ForANonMaintainer() + { + var results = await Search("Smithers", "VMDO"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsDirectPhone_ForAMaintainerOfTheNamedList() + { + GrantRole(VmdoRole); + + var results = await Search("Smithers", "VMDO"); + + Assert.Equal("530-555-2000", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_ForAnUnknownListCode() + { + // An unresolvable code drops to "no list", not "no permission check": holding the role + // must not be enough on its own, since the code is caller-supplied. + GrantRole(VmdoRole); + + var results = await Search("Smithers", "NOPE"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsThePerson_WhenTheyHaveNoPhoneRow() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 2, + IamId = "person02", + FirstName = "Bo", + LastName = "Smithfield", + FullName = "Bo Smithfield", + CurrentEmployee = true, + MailId = "bsmithfield", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await Search("Smithfield"); + + var person = Assert.Single(results); + Assert.Equal("person02", person.IamId); + Assert.Null(person.PhoneData); + } + + [Fact] + public async Task GetCurrentEmployees_IgnoresPhoneRowsWithNoMatchingPerson() + { + // phones.Person outlives users.Person entries, so an orphaned phone row must not + // materialize as a pickable person. + _context.PhonePerson.Add(new PhonePerson { PersonIam = "ghost01", Phone = "530-555-9999" }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await Search("Smithers"); + + Assert.Equal("person01", Assert.Single(results).IamId); + } + + [Fact] + public async Task GetCurrentEmployees_ExcludesFormerEmployees() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 3, + IamId = "person03", + FirstName = "Cy", + LastName = "Smithson", + FullName = "Cy Smithson", + CurrentEmployee = false, + MailId = "csmithson", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + Assert.Empty(await Search("Smithson")); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsEmpty_ForASearchTermBelowTheMinimumLength() + { + Assert.Empty(await Search("S")); + } +} diff --git a/test/Personnel/PhonePersonLookupServiceTests.cs b/test/Personnel/PhonePersonLookupServiceTests.cs new file mode 100644 index 000000000..8b458288e --- /dev/null +++ b/test/Personnel/PhonePersonLookupServiceTests.cs @@ -0,0 +1,157 @@ +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhonePersonLookupService: GetPhonePeople implements the same +/// permission-based DirectPhone masking as PhoneListUnitService, but as an independent code +/// path used by the person-picker autocomplete, so a regression there wouldn't be caught by +/// the PhoneListUnitService tests. GetViperCurrentEmployees layers PersonSearchHelper on top +/// of the CurrentEmployee filter. +/// +public sealed class PhonePersonLookupServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhonePersonLookupService _service; + + private const string MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string CallerIam = "caller01"; + + public PhonePersonLookupServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + _service = new PhonePersonLookupService(_context, permissionsService); + + _context.PhoneList.Add(new PhoneList { PhoneListId = 1, Code = "VMDO", Name = "Dean's Office", MaintainRole = MaintainRole }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + /// The seeded list, as the controller would hand it to the service. + private PhoneList TestList() => + _context.PhoneList.Single(l => l.PhoneListId == 1); + + [Fact] + public async Task GetPhonePeople_MasksDirectPhone_WhenNoListSupplied() + { + var results = await _service.GetPhonePeople(["person01"], ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_MasksDirectPhone_WhenCallerLacksMaintainAccessToList() + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + + var results = await _service.GetPhonePeople(["person01"], TestList(), ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_ShowsDirectPhone_WhenCallerHasMaintainAccessToList() + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(true); + + var results = await _service.GetPhonePeople(["person01"], TestList(), ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("530-555-2000", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_IgnoresBlankAndWhitespaceIamIds() + { + var results = await _service.GetPhonePeople( + ["person01", "", " ", null!], + ct: TestContext.Current.CancellationToken); + + Assert.Single(results); + } + + [Fact] + public async Task GetViperCurrentEmployees_ReturnsEmpty_WhenSearchBelowMinimumLength() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Amy", + LastName = "Smith", + FullName = "Amy Smith", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetViperCurrentEmployees("a", TestContext.Current.CancellationToken); + + Assert.Empty(results); + } + + [Fact] + public async Task GetViperCurrentEmployees_ExcludesFormerEmployees() + { + _context.ViperPerson.AddRange( + new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Amy", + LastName = "Smith", + FullName = "Amy Smith", + CurrentEmployee = true, + }, + new ViperPerson + { + PersonId = 2, + IamId = "person02", + FirstName = "Amy", + LastName = "Smithson", + FullName = "Amy Smithson", + CurrentEmployee = false, + } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetViperCurrentEmployees("Smith", TestContext.Current.CancellationToken); + + var match = Assert.Single(results); + Assert.Equal("person01", match.IamId); + } +} diff --git a/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs b/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs new file mode 100644 index 000000000..c124be591 --- /dev/null +++ b/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs @@ -0,0 +1,101 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller wiring tests for PhoneSVMFrequentNumberController: verifies the +/// InvalidOperationException-to-400 mapping used across the phones endpoints when +/// a maintain action targets a row that doesn't exist (or was already removed). +/// +public sealed class PhoneSVMFrequentNumberControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMFrequentNumberController _controller; + + public PhoneSVMFrequentNumberControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + _controller = new PhoneSVMFrequentNumberController(new PhoneSVMFrequentNumberService(_context, userHelper)); + } + + public void Dispose() => _context.Dispose(); + + [Fact] + public async Task UpdateFrequentNumber_ReturnsBadRequest_WhenNotFound() + { + var request = new SVMFrequentNumberRequest { Label = "Front Desk", Phone = "530-555-1000" }; + + var result = await _controller.UpdateFrequentNumber(999, request, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteFrequentNumber_ReturnsBadRequest_WhenNotFound() + { + var result = await _controller.DeleteFrequentNumber(999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteFrequentNumber_ReturnsOk_AndSoftDeletes_WhenFound() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Pharmacy", + Phone = "530-555-2000", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.DeleteFrequentNumber(1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await _context.SVMFrequentNumber + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } + + [Fact] + public async Task GetFrequentNumbers_ReturnsOnlyActiveNumbers() + { + _context.SVMFrequentNumber.AddRange( + new SVMFrequentNumber { NumberId = 1, Label = "Active Line", Phone = "1", IsActive = true }, + new SVMFrequentNumber { NumberId = 2, Label = "Retired Line", Phone = "2", IsActive = false } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.GetFrequentNumbers(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var numbers = Assert.IsAssignableFrom>(okResult.Value); + Assert.Equal(["Active Line"], numbers.Select(n => n.Label)); + } +} diff --git a/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs b/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs new file mode 100644 index 000000000..629f64bf2 --- /dev/null +++ b/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs @@ -0,0 +1,201 @@ +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMFrequentNumberService, focused on the soft-delete +/// convention (rows are marked inactive rather than removed, so ModifiedDate keeps +/// tracking when the list last changed) and the SQL Server 2016-safe null-last +/// SortOrder ordering. +/// +public sealed class PhoneSVMFrequentNumberServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneSVMFrequentNumberService _service; + + private const string CallerIam = "caller01"; + + public PhoneSVMFrequentNumberServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _service = new PhoneSVMFrequentNumberService(_context, _userHelper); + } + + public void Dispose() => _context.Dispose(); + + private void SeedNumber(string label, string phone, bool isActive = true) + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = label, + Phone = phone, + IsActive = isActive, + }); + _context.SaveChanges(); + } + + private async Task FindNumber(int numberId) => + await _context.SVMFrequentNumber.FindAsync(new object?[] { numberId }, TestContext.Current.CancellationToken); + + [Fact] + public async Task AddFrequentNumber_SetsIsActiveTrue_AndModifiedMetadata() + { + var request = new SVMFrequentNumberRequest { Label = "Front Desk", Phone = "530-555-1000" }; + + await _service.AddFrequentNumber(request, TestContext.Current.CancellationToken); + + var saved = await _context.SVMFrequentNumber + .SingleAsync(n => n.Label == "Front Desk", TestContext.Current.CancellationToken); + Assert.True(saved.IsActive); + Assert.Equal(CallerIam, saved.ModifiedBy); + Assert.NotNull(saved.ModifiedDate); + } + + [Fact] + public async Task DeleteFrequentNumber_SoftDeletes_ExcludesRowFromGetSVMFrequentNumbers() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Pharmacy", + Phone = "530-555-2000", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteFrequentNumber(1, TestContext.Current.CancellationToken); + + var stillExists = await _context.SVMFrequentNumber + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + + var activeNumbers = await _service.GetSVMFrequentNumbers(TestContext.Current.CancellationToken); + Assert.Empty(activeNumbers); + } + + [Fact] + public async Task DeleteFrequentNumber_Throws_WhenAlreadyInactive() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Retired Line", + Phone = "530-555-3000", + IsActive = false, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await Assert.ThrowsAsync( + () => _service.DeleteFrequentNumber(1, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task UpdateFrequentNumber_OverwritesFields_AndModifiedMetadata() + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = "Reception", Phone = "530-555-4000" }; + + await _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken); + + var saved = await FindNumber(1); + Assert.NotNull(saved); + Assert.Equal("Reception", saved.Label); + Assert.Equal("530-555-4000", saved.Phone); + Assert.Equal(CallerIam, saved.ModifiedBy); + Assert.NotNull(saved.ModifiedDate); + Assert.True(saved.IsActive); + } + + [Fact] + public async Task UpdateFrequentNumber_TrimsWhitespace() + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = " Reception ", Phone = " 530-555-4000 " }; + + await _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken); + + var saved = await FindNumber(1); + Assert.NotNull(saved); + Assert.Equal("Reception", saved.Label); + Assert.Equal("530-555-4000", saved.Phone); + } + + [Theory] + [InlineData("", "530-555-4000", "Location must not be empty.")] + // Whitespace-only rather than empty: the guard is IsNullOrWhiteSpace, and a bare "" would + // still pass if it were ever weakened to IsNullOrEmpty. + [InlineData(" ", "530-555-4000", "Location must not be empty.")] + [InlineData("Reception", "", "Phone Number must not be empty.")] + [InlineData("Reception", " ", "Phone Number must not be empty.")] + public async Task UpdateFrequentNumber_Throws_ForBlankFields(string label, string phone, string expectedMessage) + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = label, Phone = phone }; + + var ex = await Assert.ThrowsAsync( + () => _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken)); + + Assert.Equal(expectedMessage, ex.Message); + var unchanged = await FindNumber(1); + Assert.NotNull(unchanged); + Assert.Equal("Front Desk", unchanged.Label); + } + + [Fact] + public async Task UpdateFrequentNumber_Throws_WhenTheRowWasAlreadyDeleted() + { + // A maintainer whose page predates someone else's delete. Editing must not resurrect the + // row, which the IsActive half of the guard is what prevents - an id-only lookup would + // find the soft-deleted record and happily write to it. + SeedNumber(label: "Retired Line", phone: "530-555-3000", isActive: false); + var request = new SVMFrequentNumberRequest { Label = "Reception", Phone = "530-555-4000" }; + + await Assert.ThrowsAsync( + () => _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken)); + + var stillDeleted = await FindNumber(1); + Assert.NotNull(stillDeleted); + Assert.False(stillDeleted.IsActive); + Assert.Equal("Retired Line", stillDeleted.Label); + } + + [Fact] + public async Task GetSVMFrequentNumbers_OrdersRowsWithNoSortOrderLast() + { + _context.SVMFrequentNumber.AddRange( + new SVMFrequentNumber { NumberId = 1, Label = "Zebra Unsorted", Phone = "1", IsActive = true, SortOrder = null }, + new SVMFrequentNumber { NumberId = 2, Label = "Pharmacy", Phone = "2", IsActive = true, SortOrder = 2 }, + new SVMFrequentNumber { NumberId = 3, Label = "Front Desk", Phone = "3", IsActive = true, SortOrder = 1 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetSVMFrequentNumbers(TestContext.Current.CancellationToken); + + Assert.Equal(["Front Desk", "Pharmacy", "Zebra Unsorted"], results.Select(r => r.Label)); + } +} diff --git a/test/Personnel/PhoneSVMModifiedDateControllerTests.cs b/test/Personnel/PhoneSVMModifiedDateControllerTests.cs new file mode 100644 index 000000000..531370460 --- /dev/null +++ b/test/Personnel/PhoneSVMModifiedDateControllerTests.cs @@ -0,0 +1,130 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMModifiedDateController, which clients poll to decide whether their +/// cached SVM list is stale. The SVM page renders two independently-maintained datasets - frequent +/// numbers and unit people - behind one freshness date, so the endpoint has to report the later of +/// the two and stay correct when either side has never been modified. Reporting the earlier one +/// would leave a client believing its copy is current. +/// +public sealed class PhoneSVMModifiedDateControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMModifiedDateController _controller; + + private static readonly DateTime Older = new(2026, 1, 1, 9, 0, 0, DateTimeKind.Local); + private static readonly DateTime Newer = new(2026, 6, 1, 9, 0, 0, DateTimeKind.Local); + + public PhoneSVMModifiedDateControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + _controller = new PhoneSVMModifiedDateController( + new PhoneSVMFrequentNumberService(_context, userHelper), + new PhoneSVMUnitService(_context, userHelper)); + + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void AddFrequentNumber(DateTime? modifiedDate) + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Front Desk", + Phone = "530-555-1000", + IsActive = true, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private void AddUnitPerson(DateTime? modifiedDate) + { + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private async Task GetDate() + { + var result = await _controller.GetLastModifiedDate(TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return (DateTime?)okResult.Value; + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNull_WhenNeitherDatasetHasBeenModified() + { + Assert.Null(await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheUnitPersonDate_WhenNoFrequentNumberHasOne() + { + AddUnitPerson(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheFrequentNumberDate_WhenNoUnitPersonHasOne() + { + AddFrequentNumber(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheUnitPersonDate_WhenItIsTheLater() + { + AddFrequentNumber(Older); + AddUnitPerson(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheFrequentNumberDate_WhenItIsTheLater() + { + AddFrequentNumber(Newer); + AddUnitPerson(Older); + + Assert.Equal(Newer, await GetDate()); + } +} diff --git a/test/Personnel/PhoneSVMSectionControllerTests.cs b/test/Personnel/PhoneSVMSectionControllerTests.cs new file mode 100644 index 000000000..80775977e --- /dev/null +++ b/test/Personnel/PhoneSVMSectionControllerTests.cs @@ -0,0 +1,61 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMSectionController. Sections are the page's top-level grouping, so +/// the order they come back in is the order the page renders; unsorted sections fall to the end +/// alphabetically rather than jumping to the front on a null SortOrder. +/// +public sealed class PhoneSVMSectionControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMSectionController _controller; + + public PhoneSVMSectionControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _controller = new PhoneSVMSectionController(new PhoneSVMSectionService(_context)); + } + + public void Dispose() => _context.Dispose(); + + private async Task> GetSections() + { + var result = await _controller.GetSections(TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsAssignableFrom>(okResult.Value); + } + + [Fact] + public async Task GetSections_ReturnsSortedSectionsBeforeUnsortedOnes() + { + _context.SVMSection.AddRange( + new SVMSection { SectionId = 1, Name = "Anatomy", SortOrder = null }, + new SVMSection { SectionId = 2, Name = "Dean's Office", SortOrder = 1 }, + new SVMSection { SectionId = 3, Name = "Zoology", SortOrder = 2 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var sections = await GetSections(); + + Assert.Equal(["Dean's Office", "Zoology", "Anatomy"], sections.Select(s => s.Name)); + } + + [Fact] + public async Task GetSections_ReturnsNotFound_WhenThereAreNoSections() + { + var result = await _controller.GetSections(TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneSVMSectionServiceTests.cs b/test/Personnel/PhoneSVMSectionServiceTests.cs new file mode 100644 index 000000000..dfd484fa8 --- /dev/null +++ b/test/Personnel/PhoneSVMSectionServiceTests.cs @@ -0,0 +1,51 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMSectionService, covering the SQL Server 2016-safe null-last +/// SortOrder ordering convention shared with PhoneListUnitService and +/// PhoneSVMFrequentNumberService. +/// +public sealed class PhoneSVMSectionServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMSectionService _service; + + public PhoneSVMSectionServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + _service = new PhoneSVMSectionService(_context); + } + + public void Dispose() => _context.Dispose(); + + [Fact] + public async Task GetSVMSections_ReturnsEmptyList_WhenNoSectionsExist() + { + var results = await _service.GetSVMSections(TestContext.Current.CancellationToken); + + Assert.Empty(results); + } + + [Fact] + public async Task GetSVMSections_OrdersRowsWithNoSortOrderLast() + { + _context.SVMSection.AddRange( + new SVMSection { SectionId = 1, Name = "Zebra Unsorted", SortOrder = null }, + new SVMSection { SectionId = 2, Name = "Registrar", SortOrder = 2 }, + new SVMSection { SectionId = 3, Name = "Dean's Office", SortOrder = 1 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetSVMSections(TestContext.Current.CancellationToken); + + Assert.Equal(["Dean's Office", "Registrar", "Zebra Unsorted"], results.Select(r => r.Name)); + } +} diff --git a/test/Personnel/PhoneSVMUnitControllerTests.cs b/test/Personnel/PhoneSVMUnitControllerTests.cs new file mode 100644 index 000000000..8946163f4 --- /dev/null +++ b/test/Personnel/PhoneSVMUnitControllerTests.cs @@ -0,0 +1,206 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMUnitController: the read shape the SVM page renders from, and the +/// InvalidOperationException-to-400 mapping on the three maintain endpoints. Unlike the per-list +/// controllers, write access here is a fixed role on the endpoint rather than a per-row lookup, so +/// what the controller itself decides is narrower - which makes the failure mapping the thing +/// worth pinning, since a 500 here would surface to a maintainer as an unexplained error banner +/// instead of the message the service wrote for them. +/// +public sealed class PhoneSVMUnitControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMUnitController _controller; + + private const string CallerIam = "caller01"; + + public PhoneSVMUnitControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _controller = new PhoneSVMUnitController(new PhoneSVMUnitService(_context, userHelper)); + + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + // The read projection joins phones.Person to users.Person on a required relationship, so + // a phone row without its person is invisible to GetUnits. + AddPerson(personId: 1, "dean01", "Dinah", "Deanly", "530-555-1000"); + AddPerson(personId: 2, "staff01", "Sam", "Staffly", "530-555-2000"); + _context.SaveChanges(); + } + + private void AddPerson(int personId, string iamId, string firstName, string lastName, string phone) + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = personId, + IamId = iamId, + FirstName = firstName, + LastName = lastName, + FullName = $"{firstName} {lastName}", + CurrentEmployee = true, + }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = iamId, Phone = phone }); + } + + public void Dispose() => _context.Dispose(); + + private void AddUnitPerson(int unitPersonId, string personIam, string posType, bool isActive = true) + { + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = unitPersonId, + UnitId = 1, + PersonIam = personIam, + PosType = posType, + IsActive = isActive, + }); + _context.SaveChanges(); + } + + private static SVMUnitDataRequest Request() => new() + { + Fax = "530-555-3000", + Location = "Room 100", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + }; + + private async Task FindUnitPerson(int unitPersonId) => + await _context.SVMUnitPerson.FindAsync(new object?[] { unitPersonId }, TestContext.Current.CancellationToken); + + [Fact] + public async Task GetUnits_ReturnsOk_WithActivePeopleOnly() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + AddUnitPerson(unitPersonId: 2, "staff01", "Staff", isActive: false); + + var result = await _controller.GetUnits(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var units = Assert.IsAssignableFrom>(okResult.Value); + var unit = Assert.Single(units); + Assert.Equal("dean01", Assert.Single(unit.UnitPersons).PersonIam); + } + + [Fact] + public async Task GetUnits_ReturnsOk_WithAnEmptyListWhenThereAreNoUnits() + { + // An empty SVM list is a legitimate state, not a 404: the page still renders its sections. + _context.SVMUnit.RemoveRange(_context.SVMUnit); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.GetUnits(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + Assert.Empty(Assert.IsAssignableFrom>(okResult.Value)); + } + + [Fact] + public async Task AddUnitData_ReturnsBadRequest_ForAnUnknownUnit() + { + var result = await _controller.AddUnitData(999, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.SVMUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddUnitData_ReturnsOk_AndAddsTheLeader() + { + var result = await _controller.AddUnitData(1, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + var added = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("dean01", added.PersonIam); + Assert.Equal("Dean", added.PosType); + } + + [Fact] + public async Task UpdateUnitData_ReturnsBadRequest_ForAnUnknownUnit() + { + var result = await _controller.UpdateUnitData(999, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task UpdateUnitData_ReturnsOk_AndReplacesTheNamedRow() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + var request = Request(); + request.DeanUnitPerson = 1; + + var result = await _controller.UpdateUnitData(1, request, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var replaced = await FindUnitPerson(1); + Assert.NotNull(replaced); + Assert.False(replaced.IsActive); + Assert.Equal("Room 100", Assert.Single(await _context.SVMUnitPerson + .Where(p => p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)).Office); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsBadRequest_WhenNotFound() + { + var result = await _controller.DeleteUnitRow(999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsBadRequest_WhenTheRowWasAlreadyRemoved() + { + // The realistic way to miss through the UI: two maintainers on the same list. + AddUnitPerson(unitPersonId: 1, "dean01", "Dean", isActive: false); + + var result = await _controller.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var badRequest = Assert.IsType(result); + Assert.Equal("That record has already been removed.", badRequest.Value); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsOk_AndSoftDeletes_WhenFound() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + + var result = await _controller.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await FindUnitPerson(1); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } +} diff --git a/test/Personnel/PhoneSVMUnitServiceTests.cs b/test/Personnel/PhoneSVMUnitServiceTests.cs new file mode 100644 index 000000000..3a87ad664 --- /dev/null +++ b/test/Personnel/PhoneSVMUnitServiceTests.cs @@ -0,0 +1,516 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMUnitService, covering the two places its row handling is asymmetric. +/// DeleteUnitRow: a row is a leader plus the unit-wide admin staff, so deleting it removes the +/// leader and then the staff only once no other row still lists them - in one transaction, since +/// as separate per-record requests the pair could half-apply. +/// AddOrUpdateUnitData: one method serves both POST and PUT, so add and edit are distinguished +/// only by DeanUnitPerson/StaffUnitPerson - unset (-1) means "add another person to this unit" +/// and leaves existing rows alone, while a real id means "replace the person on that row" and +/// must deactivate it even though the incoming DeanIam/StaffIam no longer names its occupant. +/// +public sealed class PhoneSVMUnitServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMUnitService _service; + + private const string CallerIam = "caller01"; + + public PhoneSVMUnitServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _service = new PhoneSVMUnitService(_context, userHelper); + } + + public void Dispose() => _context.Dispose(); + + private void SeedUnit() + { + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "dean01", Phone = "530-555-1000" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "staff01", Phone = "530-555-2000" }); + _context.SaveChanges(); + } + + + [Fact] + public async Task DeleteUnitRow_SoftDeletesTheLeader_AndTheStaffItWasTheLastRowFor() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // One call, not one per underlying record: the caller names the row, the service decides + // which records that covers. + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + Assert.Empty(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task DeleteUnitRow_KeepsTheStaff_WhenAnotherLeaderRowStillListsThem() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "dean02", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 3, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var staffRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 3 }, TestContext.Current.CancellationToken); + Assert.NotNull(staffRow); + Assert.True(staffRow.IsActive); + + var survivingLeader = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(survivingLeader); + Assert.True(survivingLeader.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_RemovesTheStaff_WhenNamedForAStaffOnlyRow() + { + SeedUnit(); + // A unit with staff but no active leader renders one row keyed by the staff record, so + // that id is what the delete arrives with. + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var staffRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(staffRow); + Assert.False(staffRow.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_LeavesOtherUnitsAlone() + { + SeedUnit(); + _context.SVMUnit.Add(new SVMUnit { UnitId = 2, SectionId = 1, Name = "Another Unit" }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 2, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var otherUnitStaff = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(otherUnitStaff); + Assert.True(otherUnitStaff.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_Throws_WhenNotFound() + { + await Assert.ThrowsAsync( + () => _service.DeleteUnitRow(999, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddOrUpdateUnitData_Throws_WhenUnitNotFound() + { + var request = new SVMUnitDataRequest { DeanIam = "dean01", DeanPhone = "530-555-1000" }; + + await Assert.ThrowsAsync( + () => _service.AddOrUpdateUnitData(999, request, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesPreviousUnitPeople_AndAddsNewActiveRows() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Fax = " 530-555-9999 ", + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1111", + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var oldRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(oldRow); + Assert.False(oldRow.IsActive); + + var newRow = await _context.SVMUnitPerson + .SingleAsync(p => p.IsActive && p.PersonIam == "dean01", TestContext.Current.CancellationToken); + Assert.Equal("Dean", newRow.PosType); + + var unit = await _context.SVMUnit.FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.Equal("530-555-9999", unit!.Fax); + } + + [Fact] + public async Task GetSVMUnits_AlwaysBlanksDirectPhone() + { + SeedUnit(); + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "dean01", TestContext.Current.CancellationToken); + phonePerson.DirectPhone = "530-555-4000"; + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "dean01", + FirstName = "Dean", + LastName = "Person", + FullName = "Dean Person", + CurrentEmployee = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var units = await _service.GetSVMUnits(TestContext.Current.CancellationToken); + + var person = Assert.Single(Assert.Single(units).UnitPersons); + Assert.Equal("", person.Person.DirectPhone); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesTheEditedRow_WhenTheDeanIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // Editing the row for dean01 and choosing dean02 instead. The outgoing person is + // identified only by DeanUnitPerson, since DeanIam now names the incoming person. + var request = new SVMUnitDataRequest + { + Fax = "530-555-9999", + Location = "Room 500", + DeanIam = "dean02", + DeanPhone = "530-555-1112", + DeanUnitPerson = 1, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var replacedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(replacedRow); + Assert.False(replacedRow.IsActive); + + var activeLeader = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("dean02", activeLeader.PersonIam); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesTheEditedRow_WhenTheStaffIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + DeanUnitPerson = 1, + StaffIam = "staff02", + StaffPhone = "530-555-2002", + StaffUnitPerson = 2, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var replacedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(replacedRow); + Assert.False(replacedRow.IsActive); + + var activeStaff = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType == "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("staff02", activeStaff.PersonIam); + } + + [Fact] + public async Task AddOrUpdateUnitData_LeavesOtherLeaderRowsActive_WhenOneLeaderIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "dean02", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // A unit legitimately has several leader rows; replacing one must not disturb the rest. + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean03", + DeanPhone = "530-555-1113", + DeanUnitPerson = 1, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var untouchedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouchedRow); + Assert.True(untouchedRow.IsActive); + + var activeLeaders = await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Equal(2, activeLeaders.Count); + Assert.Contains(activeLeaders, p => p.PersonIam == "dean02"); + Assert.Contains(activeLeaders, p => p.PersonIam == "dean03"); + } + + [Fact] + public async Task AddOrUpdateUnitData_KeepsExistingLeaders_WhenUnitPersonIdsAreUnset() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // The add path leaves DeanUnitPerson/StaffUnitPerson at their -1 default, which is what + // separates "add another leader to this unit" from "replace the person on this row". + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean02", + DeanPhone = "530-555-1112", + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var existingRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(existingRow); + Assert.True(existingRow.IsActive); + + var activeLeaders = await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Equal(2, activeLeaders.Count); + } + + [Fact] + public async Task AddOrUpdateUnitData_RemovesStaff_WhenClearedFromTheEditedRow() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + DeanUnitPerson = 1, + StaffIam = "", + StaffUnitPerson = 2, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var clearedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(clearedRow); + Assert.False(clearedRow.IsActive); + + Assert.Empty(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType == "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task DeleteUnitRow_ReportsAnAlreadyDeletedRow_AsRemoved() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + // A maintainer whose page predates someone else's delete. Deleting again must say so + // rather than silently repeating the cascade over rows that are already gone. + var ex = await Assert.ThrowsAsync( + () => _service.DeleteUnitRow(1, TestContext.Current.CancellationToken)); + Assert.Equal("That record has already been removed.", ex.Message); + } +} diff --git a/web/Areas/CMS/Controllers/CMSOptionsController.cs b/web/Areas/CMS/Controllers/CMSOptionsController.cs index 1a7419353..549f059a6 100644 --- a/web/Areas/CMS/Controllers/CMSOptionsController.cs +++ b/web/Areas/CMS/Controllers/CMSOptionsController.cs @@ -4,6 +4,8 @@ using Viper.Areas.RAPS.Services; using Viper.Classes; using Viper.Classes.SQLContext; +using Viper.Classes.Utilities; +using Viper.Models.AAUD; using Web.Authorization; namespace Viper.Areas.CMS.Controllers @@ -65,22 +67,23 @@ public async Task>> GetPermissions(CancellationToken c [HttpGet("people")] public async Task>> SearchPeople(string search, CancellationToken ct = default) { - if (string.IsNullOrWhiteSpace(search) || search.Trim().Length < 2) + var normalizedSearch = PersonSearchHelper.Normalize(search); + if (normalizedSearch == null) { return new List(); } - search = search.Trim(); - return await _aaudContext.AaudUsers + var namePredicate = PersonSearchHelper + .NameMatches(u => u.DisplayLastName, u => u.DisplayFirstName, normalizedSearch) + .Or(u => u.LoginId != null && u.LoginId.Contains(normalizedSearch)) + .Or(u => u.MailId != null && u.MailId.Contains(normalizedSearch)); + + var query = _aaudContext.AaudUsers .AsNoTracking() .Where(u => u.Current != 0 && u.IamId != null) - .Where(u => (u.DisplayLastName + ", " + u.DisplayFirstName).Contains(search) - || (u.DisplayFirstName + " " + u.DisplayLastName).Contains(search) - || (u.LoginId != null && u.LoginId.Contains(search)) - || (u.MailId != null && u.MailId.Contains(search))) - .OrderBy(u => u.DisplayLastName) - .ThenBy(u => u.DisplayFirstName) - .Take(25) + .Where(namePredicate); + + return await PersonSearchHelper.OrderAndCap(query, u => u.DisplayLastName, u => u.DisplayFirstName) .Select(u => new CmsPersonOption { IamId = u.IamId!, diff --git a/web/Areas/Personnel/Controllers/PhoneListController.cs b/web/Areas/Personnel/Controllers/PhoneListController.cs new file mode 100644 index 000000000..c657ad635 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListController.cs @@ -0,0 +1,48 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/phonelist")] + [Permission(Allow = "SVMSecure")] + public class PhoneListController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService, + PhonePermissionsService phonePermissionsService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + private readonly PhonePermissionsService _phonePermissionsService = phonePermissionsService; + + /// + /// Everything a client needs before it fetches rows: + /// Returns the list's display name plus this caller's permissions. + /// Returned together to reduce API calls on the front end. + /// The backend continues to enforce permissions, but the front end + /// knows what data to expect and display based on these results. + /// + [HttpGet("{code}")] + public async Task> GetListInfo(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + return Ok(new PhoneListInfo + { + PhoneListId = list.PhoneListId, + Code = list.Code, + Name = list.Name, + CanMaintain = _phonePermissionsService.CanMaintainList(list), + CanViewDirectPhone = await _phoneListUnitService.CanViewDirectPhone(list, ct), + }); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs b/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs new file mode 100644 index 000000000..a0ee9926a --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs @@ -0,0 +1,36 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/phonelist/{code}/modifiedDate")] + [Permission(Allow = "SVMSecure")] + public class PhoneListModifiedDateController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + + /// + /// Returns the latest modification date of a UnitPerson in this list. + /// Includes deleted rows. + /// + [HttpGet] + public async Task> GetLastModifiedDate(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + var unitPersonDate = await _phoneListUnitService.GetUnitPersonModifiedDate(list.PhoneListId, ct); + return Ok(unitPersonDate); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneListUnitController.cs b/web/Areas/Personnel/Controllers/PhoneListUnitController.cs new file mode 100644 index 000000000..f7bb1a398 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListUnitController.cs @@ -0,0 +1,132 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + /// + /// Unit and unit-person endpoints for a phone list, addressed by the list's stable Code. + /// Write access is the role named by that list's MaintainRole column, so each list + /// can have separate permissions. + /// + [Route("/api/phones/phonelist/{code}")] + [Permission(Allow = "SVMSecure")] + public class PhoneListUnitController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService, + PhonePermissionsService phonePermissionsService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + private readonly PhonePermissionsService _phonePermissionsService = phonePermissionsService; + + /// + /// Resolves the list named in the route and confirms the caller may edit it. Returns the + /// list id on success, or the ActionResult to return to the caller on failure. + /// + private async Task<(int ListId, ActionResult? Failure)> ResolveListForMaintain(string code, CancellationToken ct) + { + PhoneList list; + try + { + list = await _phoneListService.GetListByCode(code, ct); + } + catch (InvalidOperationException ex) + { + return (0, NotFound(ex.Message)); + } + if (!_phonePermissionsService.CanMaintainList(list)) + { + return (0, Forbid()); + } + return (list.PhoneListId, null); + } + + /// + /// Retrieves the PhoneListUnits associated with a given list code, including the PhoneListUnitPersons + /// in that unit. + /// + [HttpGet("units")] + public async Task>> GetUnits(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + var results = await _phoneListUnitService.GetPhoneListUnits(list, ct); + return Ok(results); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + + /// + /// Adds a unit person to a given list, provided the user has appropriate permissions. + /// + [HttpPost("unitPerson")] + public async Task AddUnitPersonData(string code, PhoneListUnitDataRequest request, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.AddUnitPersonData(listId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates a unit person in a given list, provided the user has appropriate permissions. + /// + [HttpPut("unitPerson/{unitPersonId}")] + public async Task UpdateUnitPersonData(string code, int unitPersonId, PhoneListUnitDataRequest request, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.UpdateUnitPersonData(listId, unitPersonId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes a unit person from a given list, provided the user has appropriate permissions. + /// + [HttpDelete("unitPerson/{unitPersonId}")] + public async Task DeleteUnitPersonData(string code, int unitPersonId, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.DeleteUnitPersonData(listId, unitPersonId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhonePersonController.cs b/web/Areas/Personnel/Controllers/PhonePersonController.cs new file mode 100644 index 000000000..efa54a533 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhonePersonController.cs @@ -0,0 +1,59 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/people")] + [Permission(Allow = "SVMSecure")] + public class PhonePersonController( + PhoneListService phoneListService, + PhonePersonLookupService phonePersonService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhonePersonLookupService _phonePersonService = phonePersonService; + + /// + /// Person picker for the phone-record dialogs. Only returns direct numbers if the user + /// can edit the current list (and so has access to the data). + /// + [HttpGet] + public async Task>> GetCurrentEmployees(string search, string? listCode = null, CancellationToken ct = default) + { + PhoneList? list = null; + if (!string.IsNullOrWhiteSpace(listCode)) + { + try + { + list = await _phoneListService.GetListByCode(listCode, ct); + } + catch (InvalidOperationException) + { + list = null; + } + } + + List viperResults = await _phonePersonService.GetViperCurrentEmployees(search, ct); + List iamIds = []; + foreach (ViperPerson result in viperResults) + { + iamIds.Add(result.IamId); + } + List phoneResults = await _phonePersonService.GetPhonePeople(iamIds, list, ct); + Dictionary mergedResultsDict = []; + foreach (ViperPerson result in viperResults) + { + mergedResultsDict[result.IamId] = PersonnelMapper.ToAugmentedViperPerson(result); + } + List matchingResults = [.. phoneResults.Where(x => mergedResultsDict.ContainsKey(x.PersonIam))]; + + foreach (PhonePerson result in matchingResults) + { + mergedResultsDict[result.PersonIam].AddPhoneData(result); + } + return Ok(mergedResultsDict.Values.ToList()); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs b/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs new file mode 100644 index 000000000..94aa79f84 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs @@ -0,0 +1,79 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/frequentnumbers")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMFrequentNumberController(PhoneSVMFrequentNumberService phoneSVMFrequentNumberService) : ApiController + { + private readonly PhoneSVMFrequentNumberService _phoneSVMFrequentNumberService = phoneSVMFrequentNumberService; + + /// + /// Gets the list of frequently called numbers for the SVM Phone List. + /// + [HttpGet] + public async Task>> GetFrequentNumbers(CancellationToken ct = default) + { + var results = await _phoneSVMFrequentNumberService.GetSVMFrequentNumbers(ct); + return Ok(results); + } + + /// + /// Adds a frequently called number to the SVM Phone List. + /// + [HttpPost] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task AddFrequentNumber(SVMFrequentNumberRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.AddFrequentNumber(request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates a frequently called number in the SVM Phone List. + /// + [HttpPut("{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task UpdateFrequentNumber(int entryId, SVMFrequentNumberRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.UpdateFrequentNumber(entryId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes a frequently called number from the SVM Phone List. + /// + [HttpDelete("{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task DeleteFrequentNumber(int entryId, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.DeleteFrequentNumber(entryId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs b/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs new file mode 100644 index 000000000..28407ab24 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs @@ -0,0 +1,32 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/modifiedDate")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMModifiedDateController( + PhoneSVMFrequentNumberService phoneSVMFrequentNumberService, + PhoneSVMUnitService phoneSVMUnitService) : ApiController + { + private readonly PhoneSVMFrequentNumberService _phoneSVMFrequentNumberService = phoneSVMFrequentNumberService; + private readonly PhoneSVMUnitService _phoneSVMUnitService = phoneSVMUnitService; + + /// + /// Identfies when frequent numbers were last modified. + /// + [HttpGet] + public async Task> GetLastModifiedDate(CancellationToken ct = default) + { + var frequentNumberDate = await _phoneSVMFrequentNumberService.GetSVMFrequentNumbersModifiedDate(ct); + var unitPersonDate = await _phoneSVMUnitService.GetSVMUnitPersonModifiedDate(ct); + if (frequentNumberDate == null || unitPersonDate != null && unitPersonDate > frequentNumberDate) + { + return Ok(unitPersonDate); + } + return Ok(frequentNumberDate); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs b/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs new file mode 100644 index 000000000..ceb19ce64 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs @@ -0,0 +1,29 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/sections")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMSectionController(PhoneSVMSectionService phoneSVMSectionService) : ApiController + { + private readonly PhoneSVMSectionService _phoneSVMSectionService = phoneSVMSectionService; + + /// + /// Gets the sections to include in the SVM Phone List. + /// + [HttpGet] + public async Task>> GetSections(CancellationToken ct = default) + { + var results = await _phoneSVMSectionService.GetSVMSections(ct); + if (results.Count == 0) + { + return NotFound("No sections for the SVM Phone List were found."); + } + return Ok(results); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs b/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs new file mode 100644 index 000000000..759e7a2ba --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs @@ -0,0 +1,84 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMUnitController(PhoneSVMUnitService phoneSVMUnitService) : ApiController + { + private readonly PhoneSVMUnitService _phoneSVMUnitService = phoneSVMUnitService; + + /// + /// Gets all units for every section in the SVM Phone List. + /// + [HttpGet("units")] + public async Task>> GetUnits(CancellationToken ct = default) + { + var results = await _phoneSVMUnitService.GetSVMUnits(ct); + return Ok(results); + } + + /// + /// Adds data to a unit for the SVM Phone List. + /// This affects both SVMUnit and SVMUnitPerson. + /// + [HttpPost("units/{unitId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task AddUnitData(int unitId, SVMUnitDataRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.AddOrUpdateUnitData(unitId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates data in a unit for the SVM Phone List. + /// This affects both SVMUnit and SVMUnitPerson. + /// + [HttpPut("units/{unitId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task UpdateUnitData(int unitId, SVMUnitDataRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.AddOrUpdateUnitData(unitId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes one row of the SVM list, identified by the row key the list renders. + /// This may delete multiple SVMUnitPerson. + /// Handled this way to match the end user experience and wrap multiple + /// deletions in a transaction. + /// + [HttpDelete("rows/{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task DeleteUnitRow(int entryId, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.DeleteUnitRow(entryId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Models/AugmentedViperPerson.cs b/web/Areas/Personnel/Models/AugmentedViperPerson.cs new file mode 100644 index 000000000..a7725fdee --- /dev/null +++ b/web/Areas/Personnel/Models/AugmentedViperPerson.cs @@ -0,0 +1,22 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for combining ViperPerson and PhonePerson results for name searches. + /// + public class AugmentedViperPerson + { + public int PersonId { get; set; } + public string FirstName { get; set; } = string.Empty; + public string LastName { get; set; } = string.Empty; + public string FullName { get; set; } = string.Empty; + public string IamId { get; set; } = string.Empty; + public required bool CurrentEmployee { get; set; } + public string MailId { get; set; } = string.Empty; + public PhonePerson? PhoneData { get; set; } + + public void AddPhoneData(PhonePerson phonePerson) + { + this.PhoneData = phonePerson; + } + } +} diff --git a/web/Areas/Personnel/Models/PersonnelMapper.cs b/web/Areas/Personnel/Models/PersonnelMapper.cs new file mode 100644 index 000000000..71797c45b --- /dev/null +++ b/web/Areas/Personnel/Models/PersonnelMapper.cs @@ -0,0 +1,13 @@ +using Riok.Mapperly.Abstractions; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Mapperly mapper to create an AugmentedViperPerson from a ViperPerson. + /// + [Mapper(RequiredMappingStrategy = RequiredMappingStrategy.None)] + public static partial class PersonnelMapper + { + public static partial AugmentedViperPerson ToAugmentedViperPerson(ViperPerson source); + } +} diff --git a/web/Areas/Personnel/Models/PhoneList.cs b/web/Areas/Personnel/Models/PhoneList.cs new file mode 100644 index 000000000..f56a35a8f --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneList.cs @@ -0,0 +1,24 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneList, + /// a (typically unit/department-level) grouping for phone numbers. + /// + public class PhoneList + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListId { get; set; } + + /** + * Stable lookup key used in routes and API paths (e.g. "VMDO"). + * Allows changing Name without breaking links. + */ + public required string Code { get; set; } + public required string Name { get; set; } + public required string MaintainRole { get; set; } + + public virtual ICollection PhoneListUnits { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/PhoneListInfo.cs b/web/Areas/Personnel/Models/PhoneListInfo.cs new file mode 100644 index 000000000..18b30abad --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListInfo.cs @@ -0,0 +1,16 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// What a client needs to render a phone list before it fetches any rows: the display name + /// plus the caller's own capabilities. Allows the client to render correctly + /// based on the permissions that will be enforced on the back end. + /// + public class PhoneListInfo + { + public int PhoneListId { get; set; } + public required string Code { get; set; } + public required string Name { get; set; } + public bool CanMaintain { get; set; } + public bool CanViewDirectPhone { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnit.cs b/web/Areas/Personnel/Models/PhoneListUnit.cs new file mode 100644 index 000000000..ff0b73b9f --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnit.cs @@ -0,0 +1,20 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneListUnit, + /// a grouping within a phone list. + /// + public class PhoneListUnit + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListUnitId { get; set; } + public required int PhoneListId { get; set; } + public required string Name { get; set; } + public int? SortOrder { get; set; } + + public virtual PhoneList PhoneList { get; set; } = null!; + public virtual ICollection PhoneListUnitPersons { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs b/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs new file mode 100644 index 000000000..1ac8a0fd6 --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs @@ -0,0 +1,15 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in unit-specific phone list tables. + /// + public class PhoneListUnitDataRequest + { + public required int UnitId { get; set; } + public string Office { get; set; } = ""; + public required string EmployeeIam { get; set; } + public string Phone { get; set; } = ""; + public string DirectPhone { get; set; } = ""; + public bool ListFirst { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnitPerson.cs b/web/Areas/Personnel/Models/PhoneListUnitPerson.cs new file mode 100644 index 000000000..133b30d00 --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnitPerson.cs @@ -0,0 +1,24 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneListUnitPerson, + /// connecting people to a given unit for a phone list. + /// + public class PhoneListUnitPerson + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListUnitPersonId { get; set; } + public required int PhoneListUnitId { get; set; } + public required string PersonIam { get; set; } + public required bool ListFirst { get; set; } + public required bool IsActive { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + + public virtual PhoneListUnit PhoneListUnit { get; set; } = null!; + public virtual PhonePerson Person { get; set; } = null!; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhonePerson.cs b/web/Areas/Personnel/Models/PhonePerson.cs new file mode 100644 index 000000000..73c182cc4 --- /dev/null +++ b/web/Areas/Personnel/Models/PhonePerson.cs @@ -0,0 +1,21 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents data from phones.Person. + /// Ties a person to phone number and office data. + /// + public class PhonePerson + { + public required string PersonIam { get; set; } + public string? Phone { get; set; } + public string? DirectPhone { get; set; } + public string? Office { get; set; } + public DateTime? ModifiedDate { get; set; } + public string? ModifiedBy { get; set; } + + public virtual ICollection UnitPersons { get; set; } = []; + public virtual ICollection PhoneListUnitPersons { get; set; } = []; + public virtual ViperPerson? ViperPerson { get; set; } + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMFrequentNumber.cs b/web/Areas/Personnel/Models/SVMFrequentNumber.cs new file mode 100644 index 000000000..0e1da9e46 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMFrequentNumber.cs @@ -0,0 +1,22 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents data from phones.SVMFrequentNumber. + /// Provides a spot for additional important phone + /// numbers not tied to a specific person. + /// + public class SVMFrequentNumber + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int NumberId { get; set; } + public required string Label { get; set; } + public required string Phone { get; set; } + public int? SortOrder { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + public bool IsActive { get; set; } + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs b/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs new file mode 100644 index 000000000..89a365e84 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs @@ -0,0 +1,11 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in the SVM frequently called numbers table. + /// + public class SVMFrequentNumberRequest + { + public required string Label { get; set; } = ""; + public required string Phone { get; set; } = ""; + } +} diff --git a/web/Areas/Personnel/Models/SVMSection.cs b/web/Areas/Personnel/Models/SVMSection.cs new file mode 100644 index 000000000..4901b625b --- /dev/null +++ b/web/Areas/Personnel/Models/SVMSection.cs @@ -0,0 +1,18 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMSection, + /// a grouping for the SVM Phone List. + /// + public class SVMSection + { + public required int SectionId { get; set; } + public string? Name { get; set; } + public bool? IncludeAbbrv { get; set; } + public string? UnitName { get; set; } + public string? DirectorTitle { get; set; } + public int? SortOrder { get; set; } + + public virtual ICollection Units { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/SVMUnit.cs b/web/Areas/Personnel/Models/SVMUnit.cs new file mode 100644 index 000000000..77459a484 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnit.cs @@ -0,0 +1,22 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMUnit, + /// a department, unit, or dean's office. + /// + public class SVMUnit + { + public required int UnitId { get; set; } + public required int SectionId { get; set; } + public string? Name { get; set; } + public string? Abbrv { get; set; } + public int? SortOrder { get; set; } + public string? Fax { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + + public virtual SVMSection Section { get; set; } = null!; + public virtual ICollection UnitPersons { get; set; } = []; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMUnitDataRequests.cs b/web/Areas/Personnel/Models/SVMUnitDataRequests.cs new file mode 100644 index 000000000..d6e64cf08 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnitDataRequests.cs @@ -0,0 +1,19 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in the SVM table. + /// + public class SVMUnitDataRequest + { + public string Fax { get; set; } = ""; + public string Location { get; set; } = ""; + public string DeanIam { get; set; } = ""; + public string DeanPhone { get; set; } = ""; + public string DeanInterim { get; set; } = ""; + public int DeanUnitPerson { get; set; } = -1; + public string StaffIam { get; set; } = ""; + public string StaffPhone { get; set; } = ""; + public string StaffInterim { get; set; } = ""; + public int StaffUnitPerson { get; set; } = -1; + } +} diff --git a/web/Areas/Personnel/Models/SVMUnitPerson.cs b/web/Areas/Personnel/Models/SVMUnitPerson.cs new file mode 100644 index 000000000..fa5c08863 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnitPerson.cs @@ -0,0 +1,27 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMUnitPerson, + /// connecting people in leadership and admin roles to a + /// given unit. + /// + public class SVMUnitPerson + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int UnitPersonId { get; set; } + public required int UnitId { get; set; } + public required string PersonIam { get; set; } + public string? Office { get; set; } + public string? PosType { get; set; } + public string? Interim { get; set; } + public DateTime? ModifiedDate { get; set; } + public string? ModifiedBy { get; set; } + public bool IsActive { get; set; } + + public virtual SVMUnit Unit { get; set; } = null!; + public virtual PhonePerson Person { get; set; } = null!; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/ViperPerson.cs b/web/Areas/Personnel/Models/ViperPerson.cs new file mode 100644 index 000000000..39c11f64a --- /dev/null +++ b/web/Areas/Personnel/Models/ViperPerson.cs @@ -0,0 +1,17 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Read-only entity for accessing users.Person table within PhonesDbContext. + /// Used for joining to get employee names without cross-context queries. + /// + public class ViperPerson + { + public int PersonId { get; set; } + public string FirstName { get; set; } = string.Empty; + public string LastName { get; set; } = string.Empty; + public string FullName { get; set; } = string.Empty; + public required string IamId { get; set; } + public required bool CurrentEmployee { get; set; } + public string MailId { get; set; } = string.Empty; + } +} diff --git a/web/Areas/Personnel/PhonesDbContext.cs b/web/Areas/Personnel/PhonesDbContext.cs new file mode 100644 index 000000000..ee695b077 --- /dev/null +++ b/web/Areas/Personnel/PhonesDbContext.cs @@ -0,0 +1,216 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel.Models; + +namespace Viper.Areas.Personnel; + +/// +/// Entity Framework DbContext for the Personnel phone numbers system. +/// All tables are in the [phones] schema in the VIPER database. +/// +public class PhonesDbContext : DbContext +{ + public PhonesDbContext(DbContextOptions options) : base(options) + { + } + + // Core data tables + public virtual DbSet PhonePerson { get; set; } + public virtual DbSet SVMSection { get; set; } + public virtual DbSet SVMUnit { get; set; } + public virtual DbSet SVMUnitPerson { get; set; } + public virtual DbSet SVMFrequentNumber { get; set; } + public virtual DbSet PhoneList { get; set; } + public virtual DbSet PhoneListUnit { get; set; } + public virtual DbSet PhoneListUnitPerson { get; set; } + + // Read-only cross-schema reference (users schema in same database) + public virtual DbSet ViperPerson { get; set; } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + base.OnModelCreating(modelBuilder); + + // PhonePerson (phones.Person) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.PersonIam); + entity.ToTable("Person", schema: "phones"); + + entity.Property(e => e.PersonIam).HasColumnName("PersonIam"); + entity.Property(e => e.Phone).HasColumnName("Phone").HasMaxLength(25); + entity.Property(e => e.DirectPhone).HasColumnName("DirectPhone").HasMaxLength(25); + entity.Property(e => e.Office).HasColumnName("Office").HasMaxLength(100); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy"); + + // Cross-schema FK to users.Person + entity.HasOne(e => e.ViperPerson) + .WithMany() + .HasForeignKey(e => e.PersonIam) + .HasPrincipalKey(e => e.IamId) + .IsRequired(); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMSection (phones.SVMSection) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.SectionId); + entity.ToTable("SVMSection", schema: "phones"); + + entity.Property(e => e.SectionId).HasColumnName("SectionId"); + entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(100); + entity.Property(e => e.IncludeAbbrv).HasColumnName("IncludeAbbrv"); + entity.Property(e => e.UnitName).HasColumnName("UnitName").HasMaxLength(50); + entity.Property(e => e.DirectorTitle).HasColumnName("DirectorTitle").HasMaxLength(50); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + }); + + // SVMUnit (phones.SVMUnit) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.UnitId); + entity.ToTable("SVMUnit", schema: "phones"); + + entity.Property(e => e.UnitId).HasColumnName("UnitId"); + entity.Property(e => e.SectionId).HasColumnName("SectionId"); + entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(100); + entity.Property(e => e.Fax).HasColumnName("Fax").HasMaxLength(25); + entity.Property(e => e.Abbrv).HasColumnName("Abbrv").HasMaxLength(20); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + + entity.HasOne(e => e.Section) + .WithMany(s => s.Units) + .HasForeignKey(e => e.SectionId); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMUnitPerson (phones.SVMUnitPerson) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.UnitPersonId); + entity.ToTable("SVMUnitPerson", schema: "phones"); + + entity.Property(e => e.UnitPersonId).HasColumnName("UnitPersonId"); + entity.Property(e => e.UnitId).HasColumnName("UnitId"); + entity.Property(e => e.PersonIam).HasColumnName("PersonIam").HasMaxLength(10); + entity.Property(e => e.Office).HasColumnName("Office").HasMaxLength(50); + entity.Property(e => e.PosType).HasColumnName("PosType").HasMaxLength(25); + entity.Property(e => e.Interim).HasColumnName("Interim").HasMaxLength(10); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + entity.Property(e => e.IsActive).HasColumnName("IsActive"); + + entity.HasOne(e => e.Unit) + .WithMany(s => s.UnitPersons) + .HasForeignKey(e => e.UnitId); + + entity.HasOne(e => e.Person) + .WithMany(s => s.UnitPersons) + .HasForeignKey(e => e.PersonIam); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMFrequentNumber (phones.SVMFrequentNumber) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.NumberId); + entity.ToTable("SVMFrequentNumber", schema: "phones"); + + entity.Property(e => e.NumberId).HasColumnName("NumberId"); + entity.Property(e => e.Label).HasColumnName("Label").HasMaxLength(100); + entity.Property(e => e.Phone).HasColumnName("Phone").HasMaxLength(25); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + entity.Property(e => e.IsActive).HasColumnName("IsActive"); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // PhoneList (phones.PhoneList) + modelBuilder.Entity
|[^;\n]*)/u, + ) + if (filenameMatch?.groups?.filename) { + filename = filenameMatch.groups.filename.replaceAll(/['"]/gu, "") } } @@ -303,3 +305,4 @@ function downloadBlob(blob: Blob, filename: string): void { } export { useFetch, postForBlob, downloadBlob, HTTP_STATUS } +export type { Result, Pagination } diff --git a/VueApp/src/composables/__tests__/use-person-search.test.ts b/VueApp/src/composables/__tests__/use-person-search.test.ts new file mode 100644 index 000000000..9c8d790cc --- /dev/null +++ b/VueApp/src/composables/__tests__/use-person-search.test.ts @@ -0,0 +1,82 @@ +import { usePersonSearch } from "../use-person-search" + +type Person = { iamId: string; fullName: string } + +type Deferred = { promise: Promise; resolve: (value: T) => void } + +// A controllable pending promise, for simulating a search that hasn't resolved yet. The `as` +// cast lets `resolve` be filled in by the executor without a separate uninitialized declaration. +function createDeferred(): Deferred { + const deferred = {} as Deferred + // eslint-disable-next-line avoid-new -- a controllable pending promise is the point of this helper + deferred.promise = new Promise((resolve) => { + deferred.resolve = resolve + }) + return deferred +} + +function applyUpdate(fn: () => void): void { + fn() +} + +function runFilter(searchPeople: (val: string, update: (fn: () => void) => void) => Promise, val: string) { + return searchPeople(val, applyUpdate) +} + +describe("usePersonSearch()", () => { + it("clears options without calling search when the term is below two characters", async () => { + expect.hasAssertions() + const search = vi.fn<(value: string) => Promise>() + const { searchPeople, options, loading } = usePersonSearch(search) + options.value = [{ iamId: "a", fullName: "Existing Person" }] + + await runFilter(searchPeople, "a") + + expect(search).not.toHaveBeenCalled() + expect(options.value).toStrictEqual([]) + expect(loading.value).toBeFalsy() + }) + + it("sets loading and populates options for a valid search", async () => { + expect.hasAssertions() + const results: Person[] = [{ iamId: "person01", fullName: "Amy Smith" }] + const search = vi.fn<(value: string) => Promise>().mockResolvedValue(results) + const { searchPeople, options } = usePersonSearch(search) + + await runFilter(searchPeople, " ab ") + + expect(search).toHaveBeenCalledWith("ab") + expect(options.value).toStrictEqual(results) + }) + + it("falls back to an empty list when search resolves null", async () => { + expect.hasAssertions() + const search = vi.fn<(value: string) => Promise>().mockResolvedValue(null) + const { searchPeople, options } = usePersonSearch(search) + + await runFilter(searchPeople, "ab") + + expect(options.value).toStrictEqual([]) + }) + + it("discards a slower, earlier response that resolves after a newer search", async () => { + expect.hasAssertions() + const first = createDeferred() + const second = createDeferred() + const search = vi + .fn<(value: string) => Promise>() + .mockReturnValueOnce(first.promise) + .mockReturnValueOnce(second.promise) + const { searchPeople, options } = usePersonSearch(search) + + const firstFilter = runFilter(searchPeople, "first") + const secondFilter = runFilter(searchPeople, "second") + + second.resolve([{ iamId: "second", fullName: "Second Result" }]) + await secondFilter + first.resolve([{ iamId: "first", fullName: "First Result" }]) + await firstFilter + + expect(options.value).toStrictEqual([{ iamId: "second", fullName: "Second Result" }]) + }) +}) diff --git a/VueApp/src/composables/use-person-search.ts b/VueApp/src/composables/use-person-search.ts new file mode 100644 index 000000000..56634b78c --- /dev/null +++ b/VueApp/src/composables/use-person-search.ts @@ -0,0 +1,41 @@ +import { ref } from "vue" + +/** + * Debounced, out-of-order-safe server search for a QSelect's @filter handler. Shared by every + * PersonSelector variant (CMS, Personnel): the search/race-guard logic is identical across them, + * only the search function and result type differ per caller. + */ +function usePersonSearch(search: (value: string) => Promise) { + const options = ref([]) + const loading = ref(false) + // Guards against out-of-order responses: only the latest search may update options + let searchSeq = 0 + + async function searchPeople(val: string, update: (fn: () => void) => void) { + if (val.trim().length < 2) { + // Invalidate any in-flight search too, or its late response would repopulate + // the options we just cleared. + searchSeq += 1 + loading.value = false + update(() => { + options.value = [] + }) + return + } + searchSeq += 1 + const seq = searchSeq + loading.value = true + const result = await search(val.trim()) + if (seq !== searchSeq) { + return + } + loading.value = false + update(() => { + options.value = result ?? [] + }) + } + + return { options, loading, searchPeople } +} + +export { usePersonSearch } diff --git a/VueApp/vueapp.esproj b/VueApp/vueapp.esproj index 8513a0c6b..1c514331e 100644 --- a/VueApp/vueapp.esproj +++ b/VueApp/vueapp.esproj @@ -18,7 +18,9 @@ + + - \ No newline at end of file + diff --git a/test/Classes/Utilities/PersonSearchHelperTests.cs b/test/Classes/Utilities/PersonSearchHelperTests.cs new file mode 100644 index 000000000..3eaaa3971 --- /dev/null +++ b/test/Classes/Utilities/PersonSearchHelperTests.cs @@ -0,0 +1,137 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Classes.Utilities; + +namespace Viper.test.Classes.Utilities; + +/// +/// Tests for PersonSearchHelper, the shared "search current people by partial name" query shape +/// used by both the CMS file/permission pickers and the Personnel phone directory. A regression +/// here affects every autocomplete built on it. +/// +public class PersonSearchHelperTests +{ + private sealed class Person + { + public required string LastName { get; set; } + public required string FirstName { get; set; } + public string LoginId { get; set; } = ""; + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + [InlineData("a")] + [InlineData(" a ")] + public void Normalize_ReturnsNull_WhenBelowMinimumLength(string? search) + { + Assert.Null(PersonSearchHelper.Normalize(search)); + } + + [Fact] + public void Normalize_ReturnsTrimmedValue_WhenAtOrAboveMinimumLength() + { + var result = PersonSearchHelper.Normalize(" ab "); + + Assert.Equal("ab", result); + } + + [Fact] + public void NameMatches_MatchesLastCommaFirstForm() + { + var people = new[] { new Person { LastName = "Smith", FirstName = "Amy" } }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "mith, A"); + + var results = people.Where(predicate).ToList(); + + Assert.Single(results); + } + + [Fact] + public void NameMatches_MatchesFirstSpaceLastForm() + { + var people = new[] { new Person { LastName = "Smith", FirstName = "Amy" } }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Amy Sm"); + + var results = people.Where(predicate).ToList(); + + Assert.Single(results); + } + + [Fact] + public void NameMatches_ExcludesNonMatchingPeople() + { + var people = new[] + { + new Person { LastName = "Smith", FirstName = "Amy" }, + new Person { LastName = "Jones", FirstName = "Bob" }, + }.AsQueryable(); + var predicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Smith"); + + var results = people.Where(predicate).ToList(); + + var match = Assert.Single(results); + Assert.Equal("Smith", match.LastName); + } + + [Fact] + public void OrderAndCap_OrdersByLastNameThenFirstName_AndCapsToMaxResults() + { + var people = Enumerable.Range(0, 30) + .Select(i => new Person { LastName = $"Person{i:D2}", FirstName = "X" }) + .Reverse() + .AsQueryable(); + + var results = PersonSearchHelper.OrderAndCap(people, p => p.LastName, p => p.FirstName).ToList(); + + Assert.Equal(PersonSearchHelper.MaxResults, results.Count); + Assert.Equal("Person00", results[0].LastName); + Assert.Equal("Person24", results[^1].LastName); + } + + [Fact] + public void Or_IncludesRecordsMatchingEitherPredicate() + { + var people = new[] + { + new Person { LastName = "Smith", FirstName = "Amy", LoginId = "asmith" }, + new Person { LastName = "Jones", FirstName = "Bob", LoginId = "bjones" }, + }.AsQueryable(); + var namePredicate = PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "Smith"); + var combined = namePredicate.Or(p => p.LoginId == "bjones"); + + var results = people.Where(combined).ToList(); + + Assert.Equal(2, results.Count); + } + + private sealed class SearchTestContext(DbContextOptions options) : DbContext(options) + { + public DbSet People => Set(); + + protected override void OnModelCreating(ModelBuilder modelBuilder) + => modelBuilder.Entity().HasKey(p => p.LastName); + } + + [Fact] + public void NameMatches_EmitsASqlParameter_RatherThanALiteral() + { + // These autocompletes fire per keystroke, so a term embedded as a literal would give every + // distinct search its own query plan. The literal form also drops the ESCAPE clause, which + // is what stops a typed % or _ from being treated as a wildcard. + var options = new DbContextOptionsBuilder() + .UseSqlServer("Server=none;Database=none;Trusted_Connection=True;") + .Options; + using var context = new SearchTestContext(options); + + var sql = context.People + .Where(PersonSearchHelper.NameMatches(p => p.LastName, p => p.FirstName, "smith")) + .ToQueryString(); + + // Assert on the predicate, not the whole string: ToQueryString prefixes a DECLARE that + // spells the value out for copy-paste even when the query itself is parameterized. + Assert.Contains("LIKE @", sql, StringComparison.Ordinal); + Assert.DoesNotContain("LIKE N'", sql, StringComparison.Ordinal); + Assert.Contains("ESCAPE", sql, StringComparison.Ordinal); + } +} diff --git a/test/Personnel/PhoneListControllerTests.cs b/test/Personnel/PhoneListControllerTests.cs new file mode 100644 index 000000000..dfeeb5e00 --- /dev/null +++ b/test/Personnel/PhoneListControllerTests.cs @@ -0,0 +1,165 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListController. GetListInfo is what the client renders from before +/// it fetches any rows, so the two capability flags it reports have to match what the write and +/// read endpoints actually enforce: CanMaintain follows the list's own MaintainRole, and +/// CanViewDirectPhone is deliberately broader - a member of the list sees direct numbers without +/// being able to edit it. A flag that overstated either would show the client controls the API +/// then refuses. +/// +public sealed class PhoneListControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListController _controller; + + private const string CallerIam = "caller01"; + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + + public PhoneListControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, _userHelper, permissionsService); + + _controller = new PhoneListController(phoneListService, unitService, permissionsService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = CallerIam, Phone = "530-555-1000" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + /// Puts the caller on the list itself, which is not the same as maintaining it. + private void AddCallerToList() + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = 1, + PhoneListUnitId = 1, + PersonIam = CallerIam, + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + private async Task GetInfo(string code) + { + var result = await _controller.GetListInfo(code, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsType(okResult.Value); + } + + [Fact] + public async Task GetListInfo_ReturnsTheListIdentity() + { + var info = await GetInfo("VMDO"); + + Assert.Equal(1, info.PhoneListId); + Assert.Equal("VMDO", info.Code); + Assert.Equal("Dean's Office", info.Name); + } + + [Fact] + public async Task GetListInfo_ReportsNoCapabilities_ForACallerWithNeitherRoleNorMembership() + { + var info = await GetInfo("VMDO"); + + Assert.False(info.CanMaintain); + Assert.False(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReportsBothCapabilities_ForAMaintainer() + { + GrantRole(VmdoRole); + + var info = await GetInfo("VMDO"); + + Assert.True(info.CanMaintain); + Assert.True(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReportsDirectPhoneOnly_ForAMemberWhoCannotMaintain() + { + // Membership is what grants the direct-number view, so the two flags have to move + // independently: reporting CanMaintain here would offer edit controls the API refuses. + AddCallerToList(); + + var info = await GetInfo("VMDO"); + + Assert.False(info.CanMaintain); + Assert.True(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_IgnoresMembershipOfAnotherList() + { + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + AddCallerToList(); + + var info = await GetInfo("OTHER"); + + Assert.False(info.CanViewDirectPhone); + } + + [Fact] + public async Task GetListInfo_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetListInfo("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneListModifiedDateControllerTests.cs b/test/Personnel/PhoneListModifiedDateControllerTests.cs new file mode 100644 index 000000000..f97e34392 --- /dev/null +++ b/test/Personnel/PhoneListModifiedDateControllerTests.cs @@ -0,0 +1,140 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListModifiedDateController, the endpoint clients poll to decide +/// whether their cached copy of a list is stale. Two properties matter: deleted rows still count +/// (a removal is a change the client has to pick up, and soft-deleted rows are the only record of +/// it), and the date is scoped to the list named in the route. +/// +public sealed class PhoneListModifiedDateControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneListModifiedDateController _controller; + + private static readonly DateTime Older = new(2026, 1, 1, 9, 0, 0, DateTimeKind.Local); + private static readonly DateTime Newer = new(2026, 6, 1, 9, 0, 0, DateTimeKind.Local); + + public PhoneListModifiedDateControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, userHelper, permissionsService); + + _controller = new PhoneListModifiedDateController(phoneListService, unitService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain", + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 2, PhoneListId = 2, Name = "Other Office" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void AddRow(int unitPersonId, int unitId, DateTime? modifiedDate, bool isActive = true) + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = "person01", + ListFirst = false, + IsActive = isActive, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private async Task GetDate(string code) + { + var result = await _controller.GetLastModifiedDate(code, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return (DateTime?)okResult.Value; + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheMostRecentDate() + { + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 1, Newer); + + Assert.Equal(Newer, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_CountsDeletedRows() + { + // A removal is the change most likely to matter to a client holding stale rows, and the + // soft-deleted row is the only record that it happened. + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 1, Newer, isActive: false); + + Assert.Equal(Newer, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_IgnoresAnotherListsRows() + { + AddRow(unitPersonId: 1, unitId: 1, Older); + AddRow(unitPersonId: 2, unitId: 2, Newer); + + Assert.Equal(Older, await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNull_WhenNothingHasBeenModified() + { + AddRow(unitPersonId: 1, unitId: 1, modifiedDate: null); + + Assert.Null(await GetDate("VMDO")); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetLastModifiedDate("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneListServiceTests.cs b/test/Personnel/PhoneListServiceTests.cs new file mode 100644 index 000000000..0401a9277 --- /dev/null +++ b/test/Personnel/PhoneListServiceTests.cs @@ -0,0 +1,78 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneListService, the entry point every list-scoped request resolves a list +/// through. Lookup is by Code rather than Name so that renaming a list for display cannot +/// break the routes and API paths that address it. +/// +public sealed class PhoneListServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneListService _service; + + public PhoneListServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + _service = new PhoneListService(_context); + } + + public void Dispose() => _context.Dispose(); + + private void SeedLists() + { + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain", + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = "SVMSecure.PhoneLists.OtherMaintain", + }); + _context.SaveChanges(); + } + + [Fact] + public async Task GetListByCode_ReturnsMatchingList() + { + SeedLists(); + + var result = await _service.GetListByCode("OTHER", TestContext.Current.CancellationToken); + + Assert.Equal(2, result.PhoneListId); + Assert.Equal("Some Other Unit", result.Name); + } + + [Fact] + public async Task GetListByCode_ResolvesIndependentlyOfDisplayName() + { + SeedLists(); + var list = await _context.PhoneList.SingleAsync(l => l.Code == "VMDO", TestContext.Current.CancellationToken); + list.Name = "Office of the Dean"; + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _service.GetListByCode("VMDO", TestContext.Current.CancellationToken); + + Assert.Equal(1, result.PhoneListId); + } + + [Fact] + public async Task GetListByCode_Throws_WhenCodeNotFound() + { + await Assert.ThrowsAsync( + () => _service.GetListByCode("NOPE", TestContext.Current.CancellationToken)); + } +} diff --git a/test/Personnel/PhoneListUnitControllerTests.cs b/test/Personnel/PhoneListUnitControllerTests.cs new file mode 100644 index 000000000..cea934723 --- /dev/null +++ b/test/Personnel/PhoneListUnitControllerTests.cs @@ -0,0 +1,234 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneListUnitController. Beyond the InvalidOperationException-to-400 +/// mapping, these cover the authorization model: write access is the role named by the target +/// list's own MaintainRole column, so holding one list's role must grant nothing on another, +/// and a record id from one list must not be reachable through another list's route. +/// +public sealed class PhoneListUnitControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListUnitController _controller; + + private const string CallerIam = "caller01"; + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string OtherRole = "SVMSecure.PhoneLists.OtherMaintain"; + + public PhoneListUnitControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var unitService = new PhoneListUnitService(_context, _userHelper, permissionsService); + + _controller = new PhoneListUnitController(phoneListService, unitService, permissionsService); + + // Two lists, each with its own unit and its own maintain role. + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 2, + Code = "OTHER", + Name = "Some Other Unit", + MaintainRole = OtherRole, + }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Front Office" }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 2, PhoneListId = 2, Name = "Other Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "person01", Phone = "530-555-1000" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + /// Grants the caller exactly one maintain role. + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + private void AddUnitPersonRow(int unitPersonId, int unitId) + { + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = "person01", + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + private static PhoneListUnitDataRequest Request(int unitId) => new() + { + UnitId = unitId, + EmployeeIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + Office = "Room 100", + }; + + [Fact] + public async Task GetUnits_ReturnsOk_WithUnitsForTheNamedList() + { + var result = await _controller.GetUnits("VMDO", TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var units = Assert.IsAssignableFrom>(okResult.Value); + Assert.Equal("Front Office", Assert.Single(units).Name); + } + + [Fact] + public async Task GetUnits_ReturnsNotFound_ForAnUnknownCode() + { + var result = await _controller.GetUnits("NOPE", TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } + + [Fact] + public async Task AddUnitPersonData_ReturnsOk_ForAMaintainerOfThatList() + { + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("VMDO", Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task AddUnitPersonData_IsForbidden_WithoutTheRoleForThatList() + { + var result = await _controller.AddUnitPersonData("VMDO", Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task AddUnitPersonData_IsForbidden_ForAMaintainerOfADifferentList() + { + // Holding VMDOMaintain must not confer write access to the OTHER list, which is what a + // hard-coded permission attribute on the endpoint would have allowed. + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("OTHER", Request(2), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.PhoneListUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddUnitPersonData_ReturnsBadRequest_WhenTheUnitBelongsToAnotherList() + { + // Unit 2 is on the OTHER list; routing through VMDO must not reach it. + GrantRole(VmdoRole); + + var result = await _controller.AddUnitPersonData("VMDO", Request(2), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.PhoneListUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task UpdateUnitPersonData_ReturnsBadRequest_WhenNotFound() + { + GrantRole(VmdoRole); + + var result = await _controller.UpdateUnitPersonData("VMDO", 999, Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task UpdateUnitPersonData_ReturnsBadRequest_WhenTheRecordBelongsToAnotherList() + { + AddUnitPersonRow(unitPersonId: 5, unitId: 2); + GrantRole(VmdoRole); + + var result = await _controller.UpdateUnitPersonData("VMDO", 5, Request(1), TestContext.Current.CancellationToken); + + Assert.IsType(result); + var untouched = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 5 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouched); + Assert.True(untouched.IsActive); + } + + [Fact] + public async Task DeleteUnitPersonData_ReturnsBadRequest_WhenNotFound() + { + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteUnitPersonData_ReturnsOk_AndSoftDeletes_WhenFound() + { + AddUnitPersonRow(unitPersonId: 1, unitId: 1); + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } + + [Fact] + public async Task DeleteUnitPersonData_LeavesTheRecordAlone_WhenItBelongsToAnotherList() + { + AddUnitPersonRow(unitPersonId: 5, unitId: 2); + GrantRole(VmdoRole); + + var result = await _controller.DeleteUnitPersonData("VMDO", 5, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var untouched = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { 5 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouched); + Assert.True(untouched.IsActive); + } +} diff --git a/test/Personnel/PhoneListUnitServiceTests.cs b/test/Personnel/PhoneListUnitServiceTests.cs new file mode 100644 index 000000000..e7a89769d --- /dev/null +++ b/test/Personnel/PhoneListUnitServiceTests.cs @@ -0,0 +1,406 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneListUnitService, focused on the direct-phone visibility rule: +/// a caller may only see DirectPhone for a list if they hold the list's maintain +/// permission, OR they are themselves an active member of that list. +/// +public sealed class PhoneListUnitServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneListUnitService _service; + + private const string MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string CallerIam = "caller01"; + + public PhoneListUnitServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + // rapsContext is unused when IUserHelper.HasPermission is mocked directly, + // so a bare substitute (no seeded roles) is sufficient here. + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + + _service = new PhoneListUnitService(_context, _userHelper, permissionsService); + + SeedList(); + } + + public void Dispose() => _context.Dispose(); + + /// The seeded list, as the controller would hand it to the service. + private PhoneList TestList() => + _context.PhoneList.Single(l => l.PhoneListId == 1); + + private void AddUnit(int unitId, string name) + { + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = unitId, PhoneListId = 1, Name = name }); + _context.SaveChanges(); + } + + /// Puts a person on a unit, with the phone row the read paths expect them to have. + private void AddMember(int unitPersonId, int unitId, string personIam, bool listFirst) + { + _context.PhonePerson.Add(new PhonePerson { PersonIam = personIam, Phone = "530-555-0000" }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitPersonId = unitPersonId, + PhoneListUnitId = unitId, + PersonIam = personIam, + ListFirst = listFirst, + IsActive = true, + }); + _context.SaveChanges(); + } + + private async Task FindMember(int unitPersonId) => + await _context.PhoneListUnitPerson.FindAsync(new object?[] { unitPersonId }, TestContext.Current.CancellationToken); + + private void SeedList() + { + _context.PhoneList.Add(new PhoneList { PhoneListId = 1, Code = "VMDO", Name = "Dean's Office", MaintainRole = MaintainRole }); + _context.PhoneListUnit.Add(new PhoneListUnit { PhoneListUnitId = 1, PhoneListId = 1, Name = "Dean's Office" }); + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "listedperson", + FirstName = "Listed", + LastName = "Person", + FullName = "Listed Person", + CurrentEmployee = true, + }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "listedperson", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + Office = "Room 100", + }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitId = 1, + PersonIam = "listedperson", + ListFirst = false, + IsActive = true, + }); + _context.SaveChanges(); + } + + [Fact] + public async Task GetPhoneListUnits_MasksDirectPhone_WhenCallerHasNoAccess() + { + // Caller has neither the maintain permission nor a membership row on this list. + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + + var units = await _service.GetPhoneListUnits(TestList(), TestContext.Current.CancellationToken); + + var person = Assert.Single(Assert.Single(units).PhoneListUnitPersons); + Assert.Equal("530-555-1000", person.Person.Phone); + Assert.Equal("", person.Person.DirectPhone); + } + + [Fact] + public async Task GetPhoneListUnits_ShowsDirectPhone_WhenCallerIsListMember() + { + // No maintain permission, but the caller is themselves an active member of the list - + // membership alone should be enough to unlock direct numbers for that list. + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + _context.PhonePerson.Add(new PhonePerson { PersonIam = CallerIam, Phone = "", DirectPhone = "", Office = "" }); + _context.PhoneListUnitPerson.Add(new PhoneListUnitPerson + { + PhoneListUnitId = 1, + PersonIam = CallerIam, + ListFirst = false, + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var units = await _service.GetPhoneListUnits(TestList(), TestContext.Current.CancellationToken); + + var person = Assert.Single(units.Single().PhoneListUnitPersons, p => p.PersonIam == "listedperson"); + Assert.Equal("530-555-2000", person.Person.DirectPhone); + } + + [Fact] + public async Task AddUnitPersonData_UnsetsPreviousListFirst_WhenNewPersonIsMarkedFirst() + { + var existingFirstPerson = Assert.Single(_context.PhoneListUnitPerson); + existingFirstPerson.ListFirst = true; + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 2, + IamId = "newperson", + FirstName = "New", + LastName = "Person", + FullName = "New Person", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "newperson", + Phone = "530-555-5000", + DirectPhone = "530-555-6000", + Office = "Room 300", + ListFirst = true, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + Assert.False(existingFirstPerson.ListFirst); + var newPerson = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "newperson", TestContext.Current.CancellationToken); + Assert.True(newPerson.ListFirst); + } + + [Fact] + public async Task AddUnitPersonData_CalledTwiceForSamePerson_UpsertsInsteadOfDuplicating() + { + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-9000", + DirectPhone = "530-555-9001", + Office = "Room 900", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var associations = await _context.PhoneListUnitPerson + .Where(p => p.PersonIam == "listedperson" && p.PhoneListUnitId == 1) + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Single(associations); + + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + Assert.Equal("530-555-9000", phonePerson.Phone); + Assert.Equal("530-555-9001", phonePerson.DirectPhone); + Assert.Equal("Room 900", phonePerson.Office); + } + + [Fact] + public async Task AddUnitPersonData_TrimsWhitespace_ForANewPerson() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 3, + IamId = "paddedperson", + FirstName = "Padded", + LastName = "Person", + FullName = "Padded Person", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = " paddedperson ", + Phone = " 530-555-9500 ", + DirectPhone = " 530-555-9501 ", + Office = " Room 950 ", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "paddedperson", TestContext.Current.CancellationToken); + Assert.Equal("530-555-9500", phonePerson.Phone); + Assert.Equal("Room 950", phonePerson.Office); + } + + [Fact] + public async Task AddUnitPersonData_CalledTwiceWithAPaddedIam_UpsertsInsteadOfDuplicating() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 4, + IamId = "paddedtwice", + FirstName = "Padded", + LastName = "Twice", + FullName = "Padded Twice", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // The existing-row lookup has to trim the same way the insert does. Matching a padded + // request against the trimmed PersonIam already stored finds nothing, so every resubmit + // would add another association row for the same person and unit. + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = " paddedtwice ", + Phone = " 530-555-9600 ", + DirectPhone = " 530-555-9601 ", + Office = " Room 960 ", + ListFirst = false, + }; + + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + await _service.AddUnitPersonData(1, request, TestContext.Current.CancellationToken); + + var association = Assert.Single(await _context.PhoneListUnitPerson + .Where(p => p.PersonIam == "paddedtwice" && p.PhoneListUnitId == 1) + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.True(association.IsActive); + Assert.Equal("paddedtwice", association.PersonIam); + } + + [Fact] + public async Task UpdateUnitPersonData_UpdatesThePhonePerson_AndModifiedMetadata() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = " 530-555-7000 ", + DirectPhone = " 530-555-7001 ", + Office = " Room 700 ", + }; + + await _service.UpdateUnitPersonData( + 1, unitPerson.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + var phonePerson = await _context.PhonePerson + .FindAsync(new object?[] { "listedperson" }, TestContext.Current.CancellationToken); + Assert.NotNull(phonePerson); + Assert.Equal("530-555-7000", phonePerson.Phone); + Assert.Equal("530-555-7001", phonePerson.DirectPhone); + Assert.Equal("Room 700", phonePerson.Office); + Assert.Equal(CallerIam, unitPerson.ModifiedBy); + Assert.NotNull(unitPerson.ModifiedDate); + } + + [Fact] + public async Task UpdateUnitPersonData_ClearsListFirstOnTheRecordsOwnUnit_NotTheRequestedOne() + { + // The request carries a UnitId, but the record already knows which unit it lives in. Only + // the record's own unit may be cleared: taking the caller's word for it would let a + // mismatched UnitId unset the first-listed entry of an unrelated unit. + AddUnit(unitId: 2, name: "Other Office"); + AddMember(unitPersonId: 10, unitId: 1, personIam: "sameunitfirst", listFirst: true); + AddMember(unitPersonId: 20, unitId: 2, personIam: "otherunitfirst", listFirst: true); + var target = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 2, + EmployeeIam = "listedperson", + Phone = "530-555-7000", + ListFirst = true, + }; + + await _service.UpdateUnitPersonData( + 1, target.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + Assert.True(target.ListFirst); + Assert.False((await FindMember(10))!.ListFirst); + Assert.True((await FindMember(20))!.ListFirst); + } + + [Fact] + public async Task UpdateUnitPersonData_LeavesTheExistingFirstEntry_WhenListFirstIsNotSet() + { + AddMember(unitPersonId: 10, unitId: 1, personIam: "sameunitfirst", listFirst: true); + var target = await _context.PhoneListUnitPerson + .SingleAsync(p => p.PersonIam == "listedperson", TestContext.Current.CancellationToken); + + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-7000", + ListFirst = false, + }; + + await _service.UpdateUnitPersonData( + 1, target.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken); + + Assert.False(target.ListFirst); + Assert.True((await FindMember(10))!.ListFirst); + } + + [Fact] + public async Task DeleteUnitPersonData_SoftDeletes_KeepsRowButMarksInactive() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + + await _service.DeleteUnitPersonData(1, unitPerson.PhoneListUnitPersonId, TestContext.Current.CancellationToken); + + var stillExists = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { unitPerson.PhoneListUnitPersonId }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + Assert.Equal(CallerIam, stillExists.ModifiedBy); + } + + [Fact] + public async Task DeleteUnitPersonData_Throws_WhenNotFound() + { + await Assert.ThrowsAsync( + () => _service.DeleteUnitPersonData(1, 9999, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task EditingAnAlreadyDeletedRecord_ReportsItAsRemoved_RatherThanResurrectingIt() + { + var unitPerson = Assert.Single(_context.PhoneListUnitPerson); + await _service.DeleteUnitPersonData(1, unitPerson.PhoneListUnitPersonId, TestContext.Current.CancellationToken); + var request = new PhoneListUnitDataRequest + { + UnitId = 1, + EmployeeIam = "listedperson", + Phone = "530-555-9000", + }; + + // A maintainer whose page predates someone else's delete. Saving must not bring the row + // back, and the message becomes an error banner, so it is worded for that reader. + var ex = await Assert.ThrowsAsync( + () => _service.UpdateUnitPersonData( + 1, unitPerson.PhoneListUnitPersonId, request, TestContext.Current.CancellationToken)); + Assert.Equal("That record has already been removed.", ex.Message); + + var stillDeleted = await _context.PhoneListUnitPerson + .FindAsync(new object?[] { unitPerson.PhoneListUnitPersonId }, TestContext.Current.CancellationToken); + Assert.NotNull(stillDeleted); + Assert.False(stillDeleted.IsActive); + } +} diff --git a/test/Personnel/PhonePersonControllerTests.cs b/test/Personnel/PhonePersonControllerTests.cs new file mode 100644 index 000000000..cd692c5b1 --- /dev/null +++ b/test/Personnel/PhonePersonControllerTests.cs @@ -0,0 +1,204 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhonePersonController, the person picker behind the phone-record dialogs. +/// The controller does the merge itself rather than delegating it: two independent queries (people +/// from users.Person, phone rows from phones.Person) are joined in memory, so the cases worth +/// pinning are the ones the join can get wrong - a person with no phone row, a phone row with no +/// matching person - plus the direct-number masking, which depends on a list code supplied by the +/// caller and so must fail closed when that code is absent or bogus. +/// +public sealed class PhonePersonControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhonePersonController _controller; + + private const string VmdoRole = "SVMSecure.PhoneLists.VMDOMaintain"; + + public PhonePersonControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + var phoneListService = new PhoneListService(_context); + var lookupService = new PhonePersonLookupService(_context, permissionsService); + + _controller = new PhonePersonController(phoneListService, lookupService); + + _context.PhoneList.Add(new PhoneList + { + PhoneListId = 1, + Code = "VMDO", + Name = "Dean's Office", + MaintainRole = VmdoRole, + }); + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Ada", + LastName = "Smithers", + FullName = "Ada Smithers", + CurrentEmployee = true, + MailId = "asmithers", + }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void GrantRole(string role) + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), role).Returns(true); + } + + private async Task> Search(string search, string? listCode = null) + { + var result = await _controller.GetCurrentEmployees(search, listCode, TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsAssignableFrom>(okResult.Value); + } + + [Fact] + public async Task GetCurrentEmployees_MergesPhoneDataOntoTheMatchedPerson() + { + var results = await Search("Smithers"); + + var person = Assert.Single(results); + Assert.Equal("person01", person.IamId); + Assert.Equal("Ada Smithers", person.FullName); + Assert.NotNull(person.PhoneData); + Assert.Equal("530-555-1000", person.PhoneData.Phone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_WhenNoListIsNamed() + { + var results = await Search("Smithers"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_ForANonMaintainer() + { + var results = await Search("Smithers", "VMDO"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsDirectPhone_ForAMaintainerOfTheNamedList() + { + GrantRole(VmdoRole); + + var results = await Search("Smithers", "VMDO"); + + Assert.Equal("530-555-2000", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_MasksDirectPhone_ForAnUnknownListCode() + { + // An unresolvable code drops to "no list", not "no permission check": holding the role + // must not be enough on its own, since the code is caller-supplied. + GrantRole(VmdoRole); + + var results = await Search("Smithers", "NOPE"); + + Assert.Equal("", Assert.Single(results).PhoneData?.DirectPhone); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsThePerson_WhenTheyHaveNoPhoneRow() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 2, + IamId = "person02", + FirstName = "Bo", + LastName = "Smithfield", + FullName = "Bo Smithfield", + CurrentEmployee = true, + MailId = "bsmithfield", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await Search("Smithfield"); + + var person = Assert.Single(results); + Assert.Equal("person02", person.IamId); + Assert.Null(person.PhoneData); + } + + [Fact] + public async Task GetCurrentEmployees_IgnoresPhoneRowsWithNoMatchingPerson() + { + // phones.Person outlives users.Person entries, so an orphaned phone row must not + // materialize as a pickable person. + _context.PhonePerson.Add(new PhonePerson { PersonIam = "ghost01", Phone = "530-555-9999" }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await Search("Smithers"); + + Assert.Equal("person01", Assert.Single(results).IamId); + } + + [Fact] + public async Task GetCurrentEmployees_ExcludesFormerEmployees() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 3, + IamId = "person03", + FirstName = "Cy", + LastName = "Smithson", + FullName = "Cy Smithson", + CurrentEmployee = false, + MailId = "csmithson", + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + Assert.Empty(await Search("Smithson")); + } + + [Fact] + public async Task GetCurrentEmployees_ReturnsEmpty_ForASearchTermBelowTheMinimumLength() + { + Assert.Empty(await Search("S")); + } +} diff --git a/test/Personnel/PhonePersonLookupServiceTests.cs b/test/Personnel/PhonePersonLookupServiceTests.cs new file mode 100644 index 000000000..8b458288e --- /dev/null +++ b/test/Personnel/PhonePersonLookupServiceTests.cs @@ -0,0 +1,157 @@ +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes.SQLContext; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhonePersonLookupService: GetPhonePeople implements the same +/// permission-based DirectPhone masking as PhoneListUnitService, but as an independent code +/// path used by the person-picker autocomplete, so a regression there wouldn't be caught by +/// the PhoneListUnitService tests. GetViperCurrentEmployees layers PersonSearchHelper on top +/// of the CurrentEmployee filter. +/// +public sealed class PhonePersonLookupServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhonePersonLookupService _service; + + private const string MaintainRole = "SVMSecure.PhoneLists.VMDOMaintain"; + private const string CallerIam = "caller01"; + + public PhonePersonLookupServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + var rapsContext = Substitute.For(); + var permissionsService = new PhonePermissionsService(rapsContext, _userHelper); + _service = new PhonePersonLookupService(_context, permissionsService); + + _context.PhoneList.Add(new PhoneList { PhoneListId = 1, Code = "VMDO", Name = "Dean's Office", MaintainRole = MaintainRole }); + _context.PhonePerson.Add(new PhonePerson + { + PersonIam = "person01", + Phone = "530-555-1000", + DirectPhone = "530-555-2000", + }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + /// The seeded list, as the controller would hand it to the service. + private PhoneList TestList() => + _context.PhoneList.Single(l => l.PhoneListId == 1); + + [Fact] + public async Task GetPhonePeople_MasksDirectPhone_WhenNoListSupplied() + { + var results = await _service.GetPhonePeople(["person01"], ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_MasksDirectPhone_WhenCallerLacksMaintainAccessToList() + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(false); + + var results = await _service.GetPhonePeople(["person01"], TestList(), ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_ShowsDirectPhone_WhenCallerHasMaintainAccessToList() + { + _userHelper.HasPermission(Arg.Any(), Arg.Any(), MaintainRole).Returns(true); + + var results = await _service.GetPhonePeople(["person01"], TestList(), ct: TestContext.Current.CancellationToken); + + var person = Assert.Single(results); + Assert.Equal("530-555-2000", person.DirectPhone); + } + + [Fact] + public async Task GetPhonePeople_IgnoresBlankAndWhitespaceIamIds() + { + var results = await _service.GetPhonePeople( + ["person01", "", " ", null!], + ct: TestContext.Current.CancellationToken); + + Assert.Single(results); + } + + [Fact] + public async Task GetViperCurrentEmployees_ReturnsEmpty_WhenSearchBelowMinimumLength() + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Amy", + LastName = "Smith", + FullName = "Amy Smith", + CurrentEmployee = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetViperCurrentEmployees("a", TestContext.Current.CancellationToken); + + Assert.Empty(results); + } + + [Fact] + public async Task GetViperCurrentEmployees_ExcludesFormerEmployees() + { + _context.ViperPerson.AddRange( + new ViperPerson + { + PersonId = 1, + IamId = "person01", + FirstName = "Amy", + LastName = "Smith", + FullName = "Amy Smith", + CurrentEmployee = true, + }, + new ViperPerson + { + PersonId = 2, + IamId = "person02", + FirstName = "Amy", + LastName = "Smithson", + FullName = "Amy Smithson", + CurrentEmployee = false, + } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetViperCurrentEmployees("Smith", TestContext.Current.CancellationToken); + + var match = Assert.Single(results); + Assert.Equal("person01", match.IamId); + } +} diff --git a/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs b/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs new file mode 100644 index 000000000..c124be591 --- /dev/null +++ b/test/Personnel/PhoneSVMFrequentNumberControllerTests.cs @@ -0,0 +1,101 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller wiring tests for PhoneSVMFrequentNumberController: verifies the +/// InvalidOperationException-to-400 mapping used across the phones endpoints when +/// a maintain action targets a row that doesn't exist (or was already removed). +/// +public sealed class PhoneSVMFrequentNumberControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMFrequentNumberController _controller; + + public PhoneSVMFrequentNumberControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + _controller = new PhoneSVMFrequentNumberController(new PhoneSVMFrequentNumberService(_context, userHelper)); + } + + public void Dispose() => _context.Dispose(); + + [Fact] + public async Task UpdateFrequentNumber_ReturnsBadRequest_WhenNotFound() + { + var request = new SVMFrequentNumberRequest { Label = "Front Desk", Phone = "530-555-1000" }; + + var result = await _controller.UpdateFrequentNumber(999, request, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteFrequentNumber_ReturnsBadRequest_WhenNotFound() + { + var result = await _controller.DeleteFrequentNumber(999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteFrequentNumber_ReturnsOk_AndSoftDeletes_WhenFound() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Pharmacy", + Phone = "530-555-2000", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.DeleteFrequentNumber(1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await _context.SVMFrequentNumber + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } + + [Fact] + public async Task GetFrequentNumbers_ReturnsOnlyActiveNumbers() + { + _context.SVMFrequentNumber.AddRange( + new SVMFrequentNumber { NumberId = 1, Label = "Active Line", Phone = "1", IsActive = true }, + new SVMFrequentNumber { NumberId = 2, Label = "Retired Line", Phone = "2", IsActive = false } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.GetFrequentNumbers(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var numbers = Assert.IsAssignableFrom>(okResult.Value); + Assert.Equal(["Active Line"], numbers.Select(n => n.Label)); + } +} diff --git a/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs b/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs new file mode 100644 index 000000000..629f64bf2 --- /dev/null +++ b/test/Personnel/PhoneSVMFrequentNumberServiceTests.cs @@ -0,0 +1,201 @@ +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMFrequentNumberService, focused on the soft-delete +/// convention (rows are marked inactive rather than removed, so ModifiedDate keeps +/// tracking when the list last changed) and the SQL Server 2016-safe null-last +/// SortOrder ordering. +/// +public sealed class PhoneSVMFrequentNumberServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly IUserHelper _userHelper; + private readonly PhoneSVMFrequentNumberService _service; + + private const string CallerIam = "caller01"; + + public PhoneSVMFrequentNumberServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _userHelper = Substitute.For(); + _userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _service = new PhoneSVMFrequentNumberService(_context, _userHelper); + } + + public void Dispose() => _context.Dispose(); + + private void SeedNumber(string label, string phone, bool isActive = true) + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = label, + Phone = phone, + IsActive = isActive, + }); + _context.SaveChanges(); + } + + private async Task FindNumber(int numberId) => + await _context.SVMFrequentNumber.FindAsync(new object?[] { numberId }, TestContext.Current.CancellationToken); + + [Fact] + public async Task AddFrequentNumber_SetsIsActiveTrue_AndModifiedMetadata() + { + var request = new SVMFrequentNumberRequest { Label = "Front Desk", Phone = "530-555-1000" }; + + await _service.AddFrequentNumber(request, TestContext.Current.CancellationToken); + + var saved = await _context.SVMFrequentNumber + .SingleAsync(n => n.Label == "Front Desk", TestContext.Current.CancellationToken); + Assert.True(saved.IsActive); + Assert.Equal(CallerIam, saved.ModifiedBy); + Assert.NotNull(saved.ModifiedDate); + } + + [Fact] + public async Task DeleteFrequentNumber_SoftDeletes_ExcludesRowFromGetSVMFrequentNumbers() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Pharmacy", + Phone = "530-555-2000", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteFrequentNumber(1, TestContext.Current.CancellationToken); + + var stillExists = await _context.SVMFrequentNumber + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + + var activeNumbers = await _service.GetSVMFrequentNumbers(TestContext.Current.CancellationToken); + Assert.Empty(activeNumbers); + } + + [Fact] + public async Task DeleteFrequentNumber_Throws_WhenAlreadyInactive() + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Retired Line", + Phone = "530-555-3000", + IsActive = false, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await Assert.ThrowsAsync( + () => _service.DeleteFrequentNumber(1, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task UpdateFrequentNumber_OverwritesFields_AndModifiedMetadata() + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = "Reception", Phone = "530-555-4000" }; + + await _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken); + + var saved = await FindNumber(1); + Assert.NotNull(saved); + Assert.Equal("Reception", saved.Label); + Assert.Equal("530-555-4000", saved.Phone); + Assert.Equal(CallerIam, saved.ModifiedBy); + Assert.NotNull(saved.ModifiedDate); + Assert.True(saved.IsActive); + } + + [Fact] + public async Task UpdateFrequentNumber_TrimsWhitespace() + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = " Reception ", Phone = " 530-555-4000 " }; + + await _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken); + + var saved = await FindNumber(1); + Assert.NotNull(saved); + Assert.Equal("Reception", saved.Label); + Assert.Equal("530-555-4000", saved.Phone); + } + + [Theory] + [InlineData("", "530-555-4000", "Location must not be empty.")] + // Whitespace-only rather than empty: the guard is IsNullOrWhiteSpace, and a bare "" would + // still pass if it were ever weakened to IsNullOrEmpty. + [InlineData(" ", "530-555-4000", "Location must not be empty.")] + [InlineData("Reception", "", "Phone Number must not be empty.")] + [InlineData("Reception", " ", "Phone Number must not be empty.")] + public async Task UpdateFrequentNumber_Throws_ForBlankFields(string label, string phone, string expectedMessage) + { + SeedNumber(label: "Front Desk", phone: "530-555-1000"); + var request = new SVMFrequentNumberRequest { Label = label, Phone = phone }; + + var ex = await Assert.ThrowsAsync( + () => _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken)); + + Assert.Equal(expectedMessage, ex.Message); + var unchanged = await FindNumber(1); + Assert.NotNull(unchanged); + Assert.Equal("Front Desk", unchanged.Label); + } + + [Fact] + public async Task UpdateFrequentNumber_Throws_WhenTheRowWasAlreadyDeleted() + { + // A maintainer whose page predates someone else's delete. Editing must not resurrect the + // row, which the IsActive half of the guard is what prevents - an id-only lookup would + // find the soft-deleted record and happily write to it. + SeedNumber(label: "Retired Line", phone: "530-555-3000", isActive: false); + var request = new SVMFrequentNumberRequest { Label = "Reception", Phone = "530-555-4000" }; + + await Assert.ThrowsAsync( + () => _service.UpdateFrequentNumber(1, request, TestContext.Current.CancellationToken)); + + var stillDeleted = await FindNumber(1); + Assert.NotNull(stillDeleted); + Assert.False(stillDeleted.IsActive); + Assert.Equal("Retired Line", stillDeleted.Label); + } + + [Fact] + public async Task GetSVMFrequentNumbers_OrdersRowsWithNoSortOrderLast() + { + _context.SVMFrequentNumber.AddRange( + new SVMFrequentNumber { NumberId = 1, Label = "Zebra Unsorted", Phone = "1", IsActive = true, SortOrder = null }, + new SVMFrequentNumber { NumberId = 2, Label = "Pharmacy", Phone = "2", IsActive = true, SortOrder = 2 }, + new SVMFrequentNumber { NumberId = 3, Label = "Front Desk", Phone = "3", IsActive = true, SortOrder = 1 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetSVMFrequentNumbers(TestContext.Current.CancellationToken); + + Assert.Equal(["Front Desk", "Pharmacy", "Zebra Unsorted"], results.Select(r => r.Label)); + } +} diff --git a/test/Personnel/PhoneSVMModifiedDateControllerTests.cs b/test/Personnel/PhoneSVMModifiedDateControllerTests.cs new file mode 100644 index 000000000..531370460 --- /dev/null +++ b/test/Personnel/PhoneSVMModifiedDateControllerTests.cs @@ -0,0 +1,130 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMModifiedDateController, which clients poll to decide whether their +/// cached SVM list is stale. The SVM page renders two independently-maintained datasets - frequent +/// numbers and unit people - behind one freshness date, so the endpoint has to report the later of +/// the two and stay correct when either side has never been modified. Reporting the earlier one +/// would leave a client believing its copy is current. +/// +public sealed class PhoneSVMModifiedDateControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMModifiedDateController _controller; + + private static readonly DateTime Older = new(2026, 1, 1, 9, 0, 0, DateTimeKind.Local); + private static readonly DateTime Newer = new(2026, 6, 1, 9, 0, 0, DateTimeKind.Local); + + public PhoneSVMModifiedDateControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = "caller01", + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = "caller01", + }); + + _controller = new PhoneSVMModifiedDateController( + new PhoneSVMFrequentNumberService(_context, userHelper), + new PhoneSVMUnitService(_context, userHelper)); + + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + _context.SaveChanges(); + } + + public void Dispose() => _context.Dispose(); + + private void AddFrequentNumber(DateTime? modifiedDate) + { + _context.SVMFrequentNumber.Add(new SVMFrequentNumber + { + NumberId = 1, + Label = "Front Desk", + Phone = "530-555-1000", + IsActive = true, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private void AddUnitPerson(DateTime? modifiedDate) + { + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + ModifiedDate = modifiedDate, + }); + _context.SaveChanges(); + } + + private async Task GetDate() + { + var result = await _controller.GetLastModifiedDate(TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return (DateTime?)okResult.Value; + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsNull_WhenNeitherDatasetHasBeenModified() + { + Assert.Null(await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheUnitPersonDate_WhenNoFrequentNumberHasOne() + { + AddUnitPerson(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheFrequentNumberDate_WhenNoUnitPersonHasOne() + { + AddFrequentNumber(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheUnitPersonDate_WhenItIsTheLater() + { + AddFrequentNumber(Older); + AddUnitPerson(Newer); + + Assert.Equal(Newer, await GetDate()); + } + + [Fact] + public async Task GetLastModifiedDate_ReturnsTheFrequentNumberDate_WhenItIsTheLater() + { + AddFrequentNumber(Newer); + AddUnitPerson(Older); + + Assert.Equal(Newer, await GetDate()); + } +} diff --git a/test/Personnel/PhoneSVMSectionControllerTests.cs b/test/Personnel/PhoneSVMSectionControllerTests.cs new file mode 100644 index 000000000..80775977e --- /dev/null +++ b/test/Personnel/PhoneSVMSectionControllerTests.cs @@ -0,0 +1,61 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMSectionController. Sections are the page's top-level grouping, so +/// the order they come back in is the order the page renders; unsorted sections fall to the end +/// alphabetically rather than jumping to the front on a null SortOrder. +/// +public sealed class PhoneSVMSectionControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMSectionController _controller; + + public PhoneSVMSectionControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + + _controller = new PhoneSVMSectionController(new PhoneSVMSectionService(_context)); + } + + public void Dispose() => _context.Dispose(); + + private async Task> GetSections() + { + var result = await _controller.GetSections(TestContext.Current.CancellationToken); + var okResult = Assert.IsType(result.Result); + return Assert.IsAssignableFrom>(okResult.Value); + } + + [Fact] + public async Task GetSections_ReturnsSortedSectionsBeforeUnsortedOnes() + { + _context.SVMSection.AddRange( + new SVMSection { SectionId = 1, Name = "Anatomy", SortOrder = null }, + new SVMSection { SectionId = 2, Name = "Dean's Office", SortOrder = 1 }, + new SVMSection { SectionId = 3, Name = "Zoology", SortOrder = 2 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var sections = await GetSections(); + + Assert.Equal(["Dean's Office", "Zoology", "Anatomy"], sections.Select(s => s.Name)); + } + + [Fact] + public async Task GetSections_ReturnsNotFound_WhenThereAreNoSections() + { + var result = await _controller.GetSections(TestContext.Current.CancellationToken); + + Assert.IsType(result.Result); + } +} diff --git a/test/Personnel/PhoneSVMSectionServiceTests.cs b/test/Personnel/PhoneSVMSectionServiceTests.cs new file mode 100644 index 000000000..dfd484fa8 --- /dev/null +++ b/test/Personnel/PhoneSVMSectionServiceTests.cs @@ -0,0 +1,51 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMSectionService, covering the SQL Server 2016-safe null-last +/// SortOrder ordering convention shared with PhoneListUnitService and +/// PhoneSVMFrequentNumberService. +/// +public sealed class PhoneSVMSectionServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMSectionService _service; + + public PhoneSVMSectionServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _context = new PhonesDbContext(options); + _service = new PhoneSVMSectionService(_context); + } + + public void Dispose() => _context.Dispose(); + + [Fact] + public async Task GetSVMSections_ReturnsEmptyList_WhenNoSectionsExist() + { + var results = await _service.GetSVMSections(TestContext.Current.CancellationToken); + + Assert.Empty(results); + } + + [Fact] + public async Task GetSVMSections_OrdersRowsWithNoSortOrderLast() + { + _context.SVMSection.AddRange( + new SVMSection { SectionId = 1, Name = "Zebra Unsorted", SortOrder = null }, + new SVMSection { SectionId = 2, Name = "Registrar", SortOrder = 2 }, + new SVMSection { SectionId = 3, Name = "Dean's Office", SortOrder = 1 } + ); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var results = await _service.GetSVMSections(TestContext.Current.CancellationToken); + + Assert.Equal(["Dean's Office", "Registrar", "Zebra Unsorted"], results.Select(r => r.Name)); + } +} diff --git a/test/Personnel/PhoneSVMUnitControllerTests.cs b/test/Personnel/PhoneSVMUnitControllerTests.cs new file mode 100644 index 000000000..8946163f4 --- /dev/null +++ b/test/Personnel/PhoneSVMUnitControllerTests.cs @@ -0,0 +1,206 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Controllers; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Controller tests for PhoneSVMUnitController: the read shape the SVM page renders from, and the +/// InvalidOperationException-to-400 mapping on the three maintain endpoints. Unlike the per-list +/// controllers, write access here is a fixed role on the endpoint rather than a per-row lookup, so +/// what the controller itself decides is narrower - which makes the failure mapping the thing +/// worth pinning, since a 500 here would surface to a maintainer as an unexplained error banner +/// instead of the message the service wrote for them. +/// +public sealed class PhoneSVMUnitControllerTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMUnitController _controller; + + private const string CallerIam = "caller01"; + + public PhoneSVMUnitControllerTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _controller = new PhoneSVMUnitController(new PhoneSVMUnitService(_context, userHelper)); + + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + // The read projection joins phones.Person to users.Person on a required relationship, so + // a phone row without its person is invisible to GetUnits. + AddPerson(personId: 1, "dean01", "Dinah", "Deanly", "530-555-1000"); + AddPerson(personId: 2, "staff01", "Sam", "Staffly", "530-555-2000"); + _context.SaveChanges(); + } + + private void AddPerson(int personId, string iamId, string firstName, string lastName, string phone) + { + _context.ViperPerson.Add(new ViperPerson + { + PersonId = personId, + IamId = iamId, + FirstName = firstName, + LastName = lastName, + FullName = $"{firstName} {lastName}", + CurrentEmployee = true, + }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = iamId, Phone = phone }); + } + + public void Dispose() => _context.Dispose(); + + private void AddUnitPerson(int unitPersonId, string personIam, string posType, bool isActive = true) + { + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = unitPersonId, + UnitId = 1, + PersonIam = personIam, + PosType = posType, + IsActive = isActive, + }); + _context.SaveChanges(); + } + + private static SVMUnitDataRequest Request() => new() + { + Fax = "530-555-3000", + Location = "Room 100", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + }; + + private async Task FindUnitPerson(int unitPersonId) => + await _context.SVMUnitPerson.FindAsync(new object?[] { unitPersonId }, TestContext.Current.CancellationToken); + + [Fact] + public async Task GetUnits_ReturnsOk_WithActivePeopleOnly() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + AddUnitPerson(unitPersonId: 2, "staff01", "Staff", isActive: false); + + var result = await _controller.GetUnits(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + var units = Assert.IsAssignableFrom>(okResult.Value); + var unit = Assert.Single(units); + Assert.Equal("dean01", Assert.Single(unit.UnitPersons).PersonIam); + } + + [Fact] + public async Task GetUnits_ReturnsOk_WithAnEmptyListWhenThereAreNoUnits() + { + // An empty SVM list is a legitimate state, not a 404: the page still renders its sections. + _context.SVMUnit.RemoveRange(_context.SVMUnit); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var result = await _controller.GetUnits(TestContext.Current.CancellationToken); + + var okResult = Assert.IsType(result.Result); + Assert.Empty(Assert.IsAssignableFrom>(okResult.Value)); + } + + [Fact] + public async Task AddUnitData_ReturnsBadRequest_ForAnUnknownUnit() + { + var result = await _controller.AddUnitData(999, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + Assert.Empty(await _context.SVMUnitPerson.ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddUnitData_ReturnsOk_AndAddsTheLeader() + { + var result = await _controller.AddUnitData(1, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + var added = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("dean01", added.PersonIam); + Assert.Equal("Dean", added.PosType); + } + + [Fact] + public async Task UpdateUnitData_ReturnsBadRequest_ForAnUnknownUnit() + { + var result = await _controller.UpdateUnitData(999, Request(), TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task UpdateUnitData_ReturnsOk_AndReplacesTheNamedRow() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + var request = Request(); + request.DeanUnitPerson = 1; + + var result = await _controller.UpdateUnitData(1, request, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var replaced = await FindUnitPerson(1); + Assert.NotNull(replaced); + Assert.False(replaced.IsActive); + Assert.Equal("Room 100", Assert.Single(await _context.SVMUnitPerson + .Where(p => p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)).Office); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsBadRequest_WhenNotFound() + { + var result = await _controller.DeleteUnitRow(999, TestContext.Current.CancellationToken); + + Assert.IsType(result); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsBadRequest_WhenTheRowWasAlreadyRemoved() + { + // The realistic way to miss through the UI: two maintainers on the same list. + AddUnitPerson(unitPersonId: 1, "dean01", "Dean", isActive: false); + + var result = await _controller.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var badRequest = Assert.IsType(result); + Assert.Equal("That record has already been removed.", badRequest.Value); + } + + [Fact] + public async Task DeleteUnitRow_ReturnsOk_AndSoftDeletes_WhenFound() + { + AddUnitPerson(unitPersonId: 1, "dean01", "Dean"); + + var result = await _controller.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + Assert.IsType(result); + var stillExists = await FindUnitPerson(1); + Assert.NotNull(stillExists); + Assert.False(stillExists.IsActive); + } +} diff --git a/test/Personnel/PhoneSVMUnitServiceTests.cs b/test/Personnel/PhoneSVMUnitServiceTests.cs new file mode 100644 index 000000000..3a87ad664 --- /dev/null +++ b/test/Personnel/PhoneSVMUnitServiceTests.cs @@ -0,0 +1,516 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using NSubstitute; +using Viper.Areas.Personnel; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Models.AAUD; + +namespace Viper.test.Personnel; + +/// +/// Unit tests for PhoneSVMUnitService, covering the two places its row handling is asymmetric. +/// DeleteUnitRow: a row is a leader plus the unit-wide admin staff, so deleting it removes the +/// leader and then the staff only once no other row still lists them - in one transaction, since +/// as separate per-record requests the pair could half-apply. +/// AddOrUpdateUnitData: one method serves both POST and PUT, so add and edit are distinguished +/// only by DeanUnitPerson/StaffUnitPerson - unset (-1) means "add another person to this unit" +/// and leaves existing rows alone, while a real id means "replace the person on that row" and +/// must deactivate it even though the incoming DeanIam/StaffIam no longer names its occupant. +/// +public sealed class PhoneSVMUnitServiceTests : IDisposable +{ + private readonly PhonesDbContext _context; + private readonly PhoneSVMUnitService _service; + + private const string CallerIam = "caller01"; + + public PhoneSVMUnitServiceTests() + { + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)) + .Options; + _context = new PhonesDbContext(options); + + var userHelper = Substitute.For(); + userHelper.GetCurrentUser().Returns(new AaudUser + { + ClientId = "ucd.edu", + MothraId = CallerIam, + LastName = "Caller", + FirstName = "Test", + DisplayLastName = "Caller", + DisplayFirstName = "Test", + DisplayFullName = "Test Caller", + IamId = CallerIam, + }); + + _service = new PhoneSVMUnitService(_context, userHelper); + } + + public void Dispose() => _context.Dispose(); + + private void SeedUnit() + { + _context.SVMUnit.Add(new SVMUnit { UnitId = 1, SectionId = 1, Name = "Dean's Office" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "dean01", Phone = "530-555-1000" }); + _context.PhonePerson.Add(new PhonePerson { PersonIam = "staff01", Phone = "530-555-2000" }); + _context.SaveChanges(); + } + + + [Fact] + public async Task DeleteUnitRow_SoftDeletesTheLeader_AndTheStaffItWasTheLastRowFor() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // One call, not one per underlying record: the caller names the row, the service decides + // which records that covers. + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + Assert.Empty(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive) + .ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task DeleteUnitRow_KeepsTheStaff_WhenAnotherLeaderRowStillListsThem() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "dean02", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 3, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var staffRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 3 }, TestContext.Current.CancellationToken); + Assert.NotNull(staffRow); + Assert.True(staffRow.IsActive); + + var survivingLeader = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(survivingLeader); + Assert.True(survivingLeader.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_RemovesTheStaff_WhenNamedForAStaffOnlyRow() + { + SeedUnit(); + // A unit with staff but no active leader renders one row keyed by the staff record, so + // that id is what the delete arrives with. + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var staffRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(staffRow); + Assert.False(staffRow.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_LeavesOtherUnitsAlone() + { + SeedUnit(); + _context.SVMUnit.Add(new SVMUnit { UnitId = 2, SectionId = 1, Name = "Another Unit" }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 2, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + var otherUnitStaff = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(otherUnitStaff); + Assert.True(otherUnitStaff.IsActive); + } + + [Fact] + public async Task DeleteUnitRow_Throws_WhenNotFound() + { + await Assert.ThrowsAsync( + () => _service.DeleteUnitRow(999, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddOrUpdateUnitData_Throws_WhenUnitNotFound() + { + var request = new SVMUnitDataRequest { DeanIam = "dean01", DeanPhone = "530-555-1000" }; + + await Assert.ThrowsAsync( + () => _service.AddOrUpdateUnitData(999, request, TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesPreviousUnitPeople_AndAddsNewActiveRows() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Fax = " 530-555-9999 ", + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1111", + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var oldRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(oldRow); + Assert.False(oldRow.IsActive); + + var newRow = await _context.SVMUnitPerson + .SingleAsync(p => p.IsActive && p.PersonIam == "dean01", TestContext.Current.CancellationToken); + Assert.Equal("Dean", newRow.PosType); + + var unit = await _context.SVMUnit.FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.Equal("530-555-9999", unit!.Fax); + } + + [Fact] + public async Task GetSVMUnits_AlwaysBlanksDirectPhone() + { + SeedUnit(); + var phonePerson = await _context.PhonePerson + .SingleAsync(p => p.PersonIam == "dean01", TestContext.Current.CancellationToken); + phonePerson.DirectPhone = "530-555-4000"; + _context.ViperPerson.Add(new ViperPerson + { + PersonId = 1, + IamId = "dean01", + FirstName = "Dean", + LastName = "Person", + FullName = "Dean Person", + CurrentEmployee = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var units = await _service.GetSVMUnits(TestContext.Current.CancellationToken); + + var person = Assert.Single(Assert.Single(units).UnitPersons); + Assert.Equal("", person.Person.DirectPhone); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesTheEditedRow_WhenTheDeanIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // Editing the row for dean01 and choosing dean02 instead. The outgoing person is + // identified only by DeanUnitPerson, since DeanIam now names the incoming person. + var request = new SVMUnitDataRequest + { + Fax = "530-555-9999", + Location = "Room 500", + DeanIam = "dean02", + DeanPhone = "530-555-1112", + DeanUnitPerson = 1, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var replacedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(replacedRow); + Assert.False(replacedRow.IsActive); + + var activeLeader = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("dean02", activeLeader.PersonIam); + } + + [Fact] + public async Task AddOrUpdateUnitData_DeactivatesTheEditedRow_WhenTheStaffIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + DeanUnitPerson = 1, + StaffIam = "staff02", + StaffPhone = "530-555-2002", + StaffUnitPerson = 2, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var replacedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(replacedRow); + Assert.False(replacedRow.IsActive); + + var activeStaff = Assert.Single(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType == "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + Assert.Equal("staff02", activeStaff.PersonIam); + } + + [Fact] + public async Task AddOrUpdateUnitData_LeavesOtherLeaderRowsActive_WhenOneLeaderIsReplaced() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "dean02", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // A unit legitimately has several leader rows; replacing one must not disturb the rest. + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean03", + DeanPhone = "530-555-1113", + DeanUnitPerson = 1, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var untouchedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(untouchedRow); + Assert.True(untouchedRow.IsActive); + + var activeLeaders = await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Equal(2, activeLeaders.Count); + Assert.Contains(activeLeaders, p => p.PersonIam == "dean02"); + Assert.Contains(activeLeaders, p => p.PersonIam == "dean03"); + } + + [Fact] + public async Task AddOrUpdateUnitData_KeepsExistingLeaders_WhenUnitPersonIdsAreUnset() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + // The add path leaves DeanUnitPerson/StaffUnitPerson at their -1 default, which is what + // separates "add another leader to this unit" from "replace the person on this row". + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean02", + DeanPhone = "530-555-1112", + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var existingRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 1 }, TestContext.Current.CancellationToken); + Assert.NotNull(existingRow); + Assert.True(existingRow.IsActive); + + var activeLeaders = await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType != "Staff") + .ToListAsync(TestContext.Current.CancellationToken); + Assert.Equal(2, activeLeaders.Count); + } + + [Fact] + public async Task AddOrUpdateUnitData_RemovesStaff_WhenClearedFromTheEditedRow() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + + var request = new SVMUnitDataRequest + { + Location = "Room 500", + DeanIam = "dean01", + DeanPhone = "530-555-1000", + DeanUnitPerson = 1, + StaffIam = "", + StaffUnitPerson = 2, + }; + + await _service.AddOrUpdateUnitData(1, request, TestContext.Current.CancellationToken); + + var clearedRow = await _context.SVMUnitPerson + .FindAsync(new object?[] { 2 }, TestContext.Current.CancellationToken); + Assert.NotNull(clearedRow); + Assert.False(clearedRow.IsActive); + + Assert.Empty(await _context.SVMUnitPerson + .Where(p => p.UnitId == 1 && p.IsActive && p.PosType == "Staff") + .ToListAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task DeleteUnitRow_ReportsAnAlreadyDeletedRow_AsRemoved() + { + SeedUnit(); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 1, + UnitId = 1, + PersonIam = "dean01", + PosType = "Dean", + IsActive = true, + }); + _context.SVMUnitPerson.Add(new SVMUnitPerson + { + UnitPersonId = 2, + UnitId = 1, + PersonIam = "staff01", + PosType = "Staff", + IsActive = true, + }); + await _context.SaveChangesAsync(TestContext.Current.CancellationToken); + await _service.DeleteUnitRow(1, TestContext.Current.CancellationToken); + + // A maintainer whose page predates someone else's delete. Deleting again must say so + // rather than silently repeating the cascade over rows that are already gone. + var ex = await Assert.ThrowsAsync( + () => _service.DeleteUnitRow(1, TestContext.Current.CancellationToken)); + Assert.Equal("That record has already been removed.", ex.Message); + } +} diff --git a/web/Areas/CMS/Controllers/CMSOptionsController.cs b/web/Areas/CMS/Controllers/CMSOptionsController.cs index 1a7419353..549f059a6 100644 --- a/web/Areas/CMS/Controllers/CMSOptionsController.cs +++ b/web/Areas/CMS/Controllers/CMSOptionsController.cs @@ -4,6 +4,8 @@ using Viper.Areas.RAPS.Services; using Viper.Classes; using Viper.Classes.SQLContext; +using Viper.Classes.Utilities; +using Viper.Models.AAUD; using Web.Authorization; namespace Viper.Areas.CMS.Controllers @@ -65,22 +67,23 @@ public async Task>> GetPermissions(CancellationToken c [HttpGet("people")] public async Task>> SearchPeople(string search, CancellationToken ct = default) { - if (string.IsNullOrWhiteSpace(search) || search.Trim().Length < 2) + var normalizedSearch = PersonSearchHelper.Normalize(search); + if (normalizedSearch == null) { return new List(); } - search = search.Trim(); - return await _aaudContext.AaudUsers + var namePredicate = PersonSearchHelper + .NameMatches(u => u.DisplayLastName, u => u.DisplayFirstName, normalizedSearch) + .Or(u => u.LoginId != null && u.LoginId.Contains(normalizedSearch)) + .Or(u => u.MailId != null && u.MailId.Contains(normalizedSearch)); + + var query = _aaudContext.AaudUsers .AsNoTracking() .Where(u => u.Current != 0 && u.IamId != null) - .Where(u => (u.DisplayLastName + ", " + u.DisplayFirstName).Contains(search) - || (u.DisplayFirstName + " " + u.DisplayLastName).Contains(search) - || (u.LoginId != null && u.LoginId.Contains(search)) - || (u.MailId != null && u.MailId.Contains(search))) - .OrderBy(u => u.DisplayLastName) - .ThenBy(u => u.DisplayFirstName) - .Take(25) + .Where(namePredicate); + + return await PersonSearchHelper.OrderAndCap(query, u => u.DisplayLastName, u => u.DisplayFirstName) .Select(u => new CmsPersonOption { IamId = u.IamId!, diff --git a/web/Areas/Personnel/Controllers/PhoneListController.cs b/web/Areas/Personnel/Controllers/PhoneListController.cs new file mode 100644 index 000000000..c657ad635 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListController.cs @@ -0,0 +1,48 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/phonelist")] + [Permission(Allow = "SVMSecure")] + public class PhoneListController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService, + PhonePermissionsService phonePermissionsService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + private readonly PhonePermissionsService _phonePermissionsService = phonePermissionsService; + + /// + /// Everything a client needs before it fetches rows: + /// Returns the list's display name plus this caller's permissions. + /// Returned together to reduce API calls on the front end. + /// The backend continues to enforce permissions, but the front end + /// knows what data to expect and display based on these results. + /// + [HttpGet("{code}")] + public async Task> GetListInfo(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + return Ok(new PhoneListInfo + { + PhoneListId = list.PhoneListId, + Code = list.Code, + Name = list.Name, + CanMaintain = _phonePermissionsService.CanMaintainList(list), + CanViewDirectPhone = await _phoneListUnitService.CanViewDirectPhone(list, ct), + }); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs b/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs new file mode 100644 index 000000000..a0ee9926a --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListModifiedDateController.cs @@ -0,0 +1,36 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/phonelist/{code}/modifiedDate")] + [Permission(Allow = "SVMSecure")] + public class PhoneListModifiedDateController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + + /// + /// Returns the latest modification date of a UnitPerson in this list. + /// Includes deleted rows. + /// + [HttpGet] + public async Task> GetLastModifiedDate(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + var unitPersonDate = await _phoneListUnitService.GetUnitPersonModifiedDate(list.PhoneListId, ct); + return Ok(unitPersonDate); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneListUnitController.cs b/web/Areas/Personnel/Controllers/PhoneListUnitController.cs new file mode 100644 index 000000000..f7bb1a398 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneListUnitController.cs @@ -0,0 +1,132 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + /// + /// Unit and unit-person endpoints for a phone list, addressed by the list's stable Code. + /// Write access is the role named by that list's MaintainRole column, so each list + /// can have separate permissions. + /// + [Route("/api/phones/phonelist/{code}")] + [Permission(Allow = "SVMSecure")] + public class PhoneListUnitController( + PhoneListService phoneListService, + PhoneListUnitService phoneListUnitService, + PhonePermissionsService phonePermissionsService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhoneListUnitService _phoneListUnitService = phoneListUnitService; + private readonly PhonePermissionsService _phonePermissionsService = phonePermissionsService; + + /// + /// Resolves the list named in the route and confirms the caller may edit it. Returns the + /// list id on success, or the ActionResult to return to the caller on failure. + /// + private async Task<(int ListId, ActionResult? Failure)> ResolveListForMaintain(string code, CancellationToken ct) + { + PhoneList list; + try + { + list = await _phoneListService.GetListByCode(code, ct); + } + catch (InvalidOperationException ex) + { + return (0, NotFound(ex.Message)); + } + if (!_phonePermissionsService.CanMaintainList(list)) + { + return (0, Forbid()); + } + return (list.PhoneListId, null); + } + + /// + /// Retrieves the PhoneListUnits associated with a given list code, including the PhoneListUnitPersons + /// in that unit. + /// + [HttpGet("units")] + public async Task>> GetUnits(string code, CancellationToken ct = default) + { + try + { + var list = await _phoneListService.GetListByCode(code, ct); + var results = await _phoneListUnitService.GetPhoneListUnits(list, ct); + return Ok(results); + } + catch (InvalidOperationException ex) + { + return NotFound(ex.Message); + } + } + + /// + /// Adds a unit person to a given list, provided the user has appropriate permissions. + /// + [HttpPost("unitPerson")] + public async Task AddUnitPersonData(string code, PhoneListUnitDataRequest request, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.AddUnitPersonData(listId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates a unit person in a given list, provided the user has appropriate permissions. + /// + [HttpPut("unitPerson/{unitPersonId}")] + public async Task UpdateUnitPersonData(string code, int unitPersonId, PhoneListUnitDataRequest request, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.UpdateUnitPersonData(listId, unitPersonId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes a unit person from a given list, provided the user has appropriate permissions. + /// + [HttpDelete("unitPerson/{unitPersonId}")] + public async Task DeleteUnitPersonData(string code, int unitPersonId, CancellationToken ct = default) + { + var (listId, failure) = await ResolveListForMaintain(code, ct); + if (failure != null) + { + return failure; + } + try + { + await _phoneListUnitService.DeleteUnitPersonData(listId, unitPersonId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhonePersonController.cs b/web/Areas/Personnel/Controllers/PhonePersonController.cs new file mode 100644 index 000000000..efa54a533 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhonePersonController.cs @@ -0,0 +1,59 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/people")] + [Permission(Allow = "SVMSecure")] + public class PhonePersonController( + PhoneListService phoneListService, + PhonePersonLookupService phonePersonService) : ApiController + { + private readonly PhoneListService _phoneListService = phoneListService; + private readonly PhonePersonLookupService _phonePersonService = phonePersonService; + + /// + /// Person picker for the phone-record dialogs. Only returns direct numbers if the user + /// can edit the current list (and so has access to the data). + /// + [HttpGet] + public async Task>> GetCurrentEmployees(string search, string? listCode = null, CancellationToken ct = default) + { + PhoneList? list = null; + if (!string.IsNullOrWhiteSpace(listCode)) + { + try + { + list = await _phoneListService.GetListByCode(listCode, ct); + } + catch (InvalidOperationException) + { + list = null; + } + } + + List viperResults = await _phonePersonService.GetViperCurrentEmployees(search, ct); + List iamIds = []; + foreach (ViperPerson result in viperResults) + { + iamIds.Add(result.IamId); + } + List phoneResults = await _phonePersonService.GetPhonePeople(iamIds, list, ct); + Dictionary mergedResultsDict = []; + foreach (ViperPerson result in viperResults) + { + mergedResultsDict[result.IamId] = PersonnelMapper.ToAugmentedViperPerson(result); + } + List matchingResults = [.. phoneResults.Where(x => mergedResultsDict.ContainsKey(x.PersonIam))]; + + foreach (PhonePerson result in matchingResults) + { + mergedResultsDict[result.PersonIam].AddPhoneData(result); + } + return Ok(mergedResultsDict.Values.ToList()); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs b/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs new file mode 100644 index 000000000..94aa79f84 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMFrequentNumberController.cs @@ -0,0 +1,79 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/frequentnumbers")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMFrequentNumberController(PhoneSVMFrequentNumberService phoneSVMFrequentNumberService) : ApiController + { + private readonly PhoneSVMFrequentNumberService _phoneSVMFrequentNumberService = phoneSVMFrequentNumberService; + + /// + /// Gets the list of frequently called numbers for the SVM Phone List. + /// + [HttpGet] + public async Task>> GetFrequentNumbers(CancellationToken ct = default) + { + var results = await _phoneSVMFrequentNumberService.GetSVMFrequentNumbers(ct); + return Ok(results); + } + + /// + /// Adds a frequently called number to the SVM Phone List. + /// + [HttpPost] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task AddFrequentNumber(SVMFrequentNumberRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.AddFrequentNumber(request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates a frequently called number in the SVM Phone List. + /// + [HttpPut("{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task UpdateFrequentNumber(int entryId, SVMFrequentNumberRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.UpdateFrequentNumber(entryId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes a frequently called number from the SVM Phone List. + /// + [HttpDelete("{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task DeleteFrequentNumber(int entryId, CancellationToken ct = default) + { + try + { + await _phoneSVMFrequentNumberService.DeleteFrequentNumber(entryId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs b/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs new file mode 100644 index 000000000..28407ab24 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMModifiedDateController.cs @@ -0,0 +1,32 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/modifiedDate")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMModifiedDateController( + PhoneSVMFrequentNumberService phoneSVMFrequentNumberService, + PhoneSVMUnitService phoneSVMUnitService) : ApiController + { + private readonly PhoneSVMFrequentNumberService _phoneSVMFrequentNumberService = phoneSVMFrequentNumberService; + private readonly PhoneSVMUnitService _phoneSVMUnitService = phoneSVMUnitService; + + /// + /// Identfies when frequent numbers were last modified. + /// + [HttpGet] + public async Task> GetLastModifiedDate(CancellationToken ct = default) + { + var frequentNumberDate = await _phoneSVMFrequentNumberService.GetSVMFrequentNumbersModifiedDate(ct); + var unitPersonDate = await _phoneSVMUnitService.GetSVMUnitPersonModifiedDate(ct); + if (frequentNumberDate == null || unitPersonDate != null && unitPersonDate > frequentNumberDate) + { + return Ok(unitPersonDate); + } + return Ok(frequentNumberDate); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs b/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs new file mode 100644 index 000000000..ceb19ce64 --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMSectionController.cs @@ -0,0 +1,29 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm/sections")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMSectionController(PhoneSVMSectionService phoneSVMSectionService) : ApiController + { + private readonly PhoneSVMSectionService _phoneSVMSectionService = phoneSVMSectionService; + + /// + /// Gets the sections to include in the SVM Phone List. + /// + [HttpGet] + public async Task>> GetSections(CancellationToken ct = default) + { + var results = await _phoneSVMSectionService.GetSVMSections(ct); + if (results.Count == 0) + { + return NotFound("No sections for the SVM Phone List were found."); + } + return Ok(results); + } + } +} diff --git a/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs b/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs new file mode 100644 index 000000000..759e7a2ba --- /dev/null +++ b/web/Areas/Personnel/Controllers/PhoneSVMUnitController.cs @@ -0,0 +1,84 @@ +using Microsoft.AspNetCore.Mvc; +using Viper.Areas.Personnel.Models; +using Viper.Areas.Personnel.Services; +using Viper.Classes; +using Web.Authorization; + +namespace Viper.Areas.Personnel.Controllers +{ + [Route("/api/phones/svm")] + [Permission(Allow = "SVMSecure")] + public class PhoneSVMUnitController(PhoneSVMUnitService phoneSVMUnitService) : ApiController + { + private readonly PhoneSVMUnitService _phoneSVMUnitService = phoneSVMUnitService; + + /// + /// Gets all units for every section in the SVM Phone List. + /// + [HttpGet("units")] + public async Task>> GetUnits(CancellationToken ct = default) + { + var results = await _phoneSVMUnitService.GetSVMUnits(ct); + return Ok(results); + } + + /// + /// Adds data to a unit for the SVM Phone List. + /// This affects both SVMUnit and SVMUnitPerson. + /// + [HttpPost("units/{unitId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task AddUnitData(int unitId, SVMUnitDataRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.AddOrUpdateUnitData(unitId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Updates data in a unit for the SVM Phone List. + /// This affects both SVMUnit and SVMUnitPerson. + /// + [HttpPut("units/{unitId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task UpdateUnitData(int unitId, SVMUnitDataRequest request, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.AddOrUpdateUnitData(unitId, request, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + + /// + /// Deletes one row of the SVM list, identified by the row key the list renders. + /// This may delete multiple SVMUnitPerson. + /// Handled this way to match the end user experience and wrap multiple + /// deletions in a transaction. + /// + [HttpDelete("rows/{entryId}")] + [Permission(Allow = "SVMSecure.PhoneLists.SVMMaintain")] + public async Task DeleteUnitRow(int entryId, CancellationToken ct = default) + { + try + { + await _phoneSVMUnitService.DeleteUnitRow(entryId, ct); + return Ok(true); + } + catch (InvalidOperationException ex) + { + return BadRequest(ex.Message); + } + } + } +} diff --git a/web/Areas/Personnel/Models/AugmentedViperPerson.cs b/web/Areas/Personnel/Models/AugmentedViperPerson.cs new file mode 100644 index 000000000..a7725fdee --- /dev/null +++ b/web/Areas/Personnel/Models/AugmentedViperPerson.cs @@ -0,0 +1,22 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for combining ViperPerson and PhonePerson results for name searches. + /// + public class AugmentedViperPerson + { + public int PersonId { get; set; } + public string FirstName { get; set; } = string.Empty; + public string LastName { get; set; } = string.Empty; + public string FullName { get; set; } = string.Empty; + public string IamId { get; set; } = string.Empty; + public required bool CurrentEmployee { get; set; } + public string MailId { get; set; } = string.Empty; + public PhonePerson? PhoneData { get; set; } + + public void AddPhoneData(PhonePerson phonePerson) + { + this.PhoneData = phonePerson; + } + } +} diff --git a/web/Areas/Personnel/Models/PersonnelMapper.cs b/web/Areas/Personnel/Models/PersonnelMapper.cs new file mode 100644 index 000000000..71797c45b --- /dev/null +++ b/web/Areas/Personnel/Models/PersonnelMapper.cs @@ -0,0 +1,13 @@ +using Riok.Mapperly.Abstractions; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Mapperly mapper to create an AugmentedViperPerson from a ViperPerson. + /// + [Mapper(RequiredMappingStrategy = RequiredMappingStrategy.None)] + public static partial class PersonnelMapper + { + public static partial AugmentedViperPerson ToAugmentedViperPerson(ViperPerson source); + } +} diff --git a/web/Areas/Personnel/Models/PhoneList.cs b/web/Areas/Personnel/Models/PhoneList.cs new file mode 100644 index 000000000..f56a35a8f --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneList.cs @@ -0,0 +1,24 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneList, + /// a (typically unit/department-level) grouping for phone numbers. + /// + public class PhoneList + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListId { get; set; } + + /** + * Stable lookup key used in routes and API paths (e.g. "VMDO"). + * Allows changing Name without breaking links. + */ + public required string Code { get; set; } + public required string Name { get; set; } + public required string MaintainRole { get; set; } + + public virtual ICollection PhoneListUnits { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/PhoneListInfo.cs b/web/Areas/Personnel/Models/PhoneListInfo.cs new file mode 100644 index 000000000..18b30abad --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListInfo.cs @@ -0,0 +1,16 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// What a client needs to render a phone list before it fetches any rows: the display name + /// plus the caller's own capabilities. Allows the client to render correctly + /// based on the permissions that will be enforced on the back end. + /// + public class PhoneListInfo + { + public int PhoneListId { get; set; } + public required string Code { get; set; } + public required string Name { get; set; } + public bool CanMaintain { get; set; } + public bool CanViewDirectPhone { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnit.cs b/web/Areas/Personnel/Models/PhoneListUnit.cs new file mode 100644 index 000000000..ff0b73b9f --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnit.cs @@ -0,0 +1,20 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneListUnit, + /// a grouping within a phone list. + /// + public class PhoneListUnit + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListUnitId { get; set; } + public required int PhoneListId { get; set; } + public required string Name { get; set; } + public int? SortOrder { get; set; } + + public virtual PhoneList PhoneList { get; set; } = null!; + public virtual ICollection PhoneListUnitPersons { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs b/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs new file mode 100644 index 000000000..1ac8a0fd6 --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnitDataRequests.cs @@ -0,0 +1,15 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in unit-specific phone list tables. + /// + public class PhoneListUnitDataRequest + { + public required int UnitId { get; set; } + public string Office { get; set; } = ""; + public required string EmployeeIam { get; set; } + public string Phone { get; set; } = ""; + public string DirectPhone { get; set; } = ""; + public bool ListFirst { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhoneListUnitPerson.cs b/web/Areas/Personnel/Models/PhoneListUnitPerson.cs new file mode 100644 index 000000000..133b30d00 --- /dev/null +++ b/web/Areas/Personnel/Models/PhoneListUnitPerson.cs @@ -0,0 +1,24 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.PhoneListUnitPerson, + /// connecting people to a given unit for a phone list. + /// + public class PhoneListUnitPerson + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int PhoneListUnitPersonId { get; set; } + public required int PhoneListUnitId { get; set; } + public required string PersonIam { get; set; } + public required bool ListFirst { get; set; } + public required bool IsActive { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + + public virtual PhoneListUnit PhoneListUnit { get; set; } = null!; + public virtual PhonePerson Person { get; set; } = null!; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/PhonePerson.cs b/web/Areas/Personnel/Models/PhonePerson.cs new file mode 100644 index 000000000..73c182cc4 --- /dev/null +++ b/web/Areas/Personnel/Models/PhonePerson.cs @@ -0,0 +1,21 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents data from phones.Person. + /// Ties a person to phone number and office data. + /// + public class PhonePerson + { + public required string PersonIam { get; set; } + public string? Phone { get; set; } + public string? DirectPhone { get; set; } + public string? Office { get; set; } + public DateTime? ModifiedDate { get; set; } + public string? ModifiedBy { get; set; } + + public virtual ICollection UnitPersons { get; set; } = []; + public virtual ICollection PhoneListUnitPersons { get; set; } = []; + public virtual ViperPerson? ViperPerson { get; set; } + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMFrequentNumber.cs b/web/Areas/Personnel/Models/SVMFrequentNumber.cs new file mode 100644 index 000000000..0e1da9e46 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMFrequentNumber.cs @@ -0,0 +1,22 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents data from phones.SVMFrequentNumber. + /// Provides a spot for additional important phone + /// numbers not tied to a specific person. + /// + public class SVMFrequentNumber + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int NumberId { get; set; } + public required string Label { get; set; } + public required string Phone { get; set; } + public int? SortOrder { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + public bool IsActive { get; set; } + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs b/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs new file mode 100644 index 000000000..89a365e84 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMFrequentNumberRequests.cs @@ -0,0 +1,11 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in the SVM frequently called numbers table. + /// + public class SVMFrequentNumberRequest + { + public required string Label { get; set; } = ""; + public required string Phone { get; set; } = ""; + } +} diff --git a/web/Areas/Personnel/Models/SVMSection.cs b/web/Areas/Personnel/Models/SVMSection.cs new file mode 100644 index 000000000..4901b625b --- /dev/null +++ b/web/Areas/Personnel/Models/SVMSection.cs @@ -0,0 +1,18 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMSection, + /// a grouping for the SVM Phone List. + /// + public class SVMSection + { + public required int SectionId { get; set; } + public string? Name { get; set; } + public bool? IncludeAbbrv { get; set; } + public string? UnitName { get; set; } + public string? DirectorTitle { get; set; } + public int? SortOrder { get; set; } + + public virtual ICollection Units { get; set; } = []; + } +} diff --git a/web/Areas/Personnel/Models/SVMUnit.cs b/web/Areas/Personnel/Models/SVMUnit.cs new file mode 100644 index 000000000..77459a484 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnit.cs @@ -0,0 +1,22 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMUnit, + /// a department, unit, or dean's office. + /// + public class SVMUnit + { + public required int UnitId { get; set; } + public required int SectionId { get; set; } + public string? Name { get; set; } + public string? Abbrv { get; set; } + public int? SortOrder { get; set; } + public string? Fax { get; set; } + public string? ModifiedBy { get; set; } + public DateTime? ModifiedDate { get; set; } + + public virtual SVMSection Section { get; set; } = null!; + public virtual ICollection UnitPersons { get; set; } = []; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/SVMUnitDataRequests.cs b/web/Areas/Personnel/Models/SVMUnitDataRequests.cs new file mode 100644 index 000000000..d6e64cf08 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnitDataRequests.cs @@ -0,0 +1,19 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Class for form data to create or edit a row in the SVM table. + /// + public class SVMUnitDataRequest + { + public string Fax { get; set; } = ""; + public string Location { get; set; } = ""; + public string DeanIam { get; set; } = ""; + public string DeanPhone { get; set; } = ""; + public string DeanInterim { get; set; } = ""; + public int DeanUnitPerson { get; set; } = -1; + public string StaffIam { get; set; } = ""; + public string StaffPhone { get; set; } = ""; + public string StaffInterim { get; set; } = ""; + public int StaffUnitPerson { get; set; } = -1; + } +} diff --git a/web/Areas/Personnel/Models/SVMUnitPerson.cs b/web/Areas/Personnel/Models/SVMUnitPerson.cs new file mode 100644 index 000000000..fa5c08863 --- /dev/null +++ b/web/Areas/Personnel/Models/SVMUnitPerson.cs @@ -0,0 +1,27 @@ +using System.ComponentModel.DataAnnotations.Schema; + +namespace Viper.Areas.Personnel.Models +{ + /// + /// Represents an entry from phones.SVMUnitPerson, + /// connecting people in leadership and admin roles to a + /// given unit. + /// + public class SVMUnitPerson + { + [DatabaseGenerated(DatabaseGeneratedOption.Identity)] + public int UnitPersonId { get; set; } + public required int UnitId { get; set; } + public required string PersonIam { get; set; } + public string? Office { get; set; } + public string? PosType { get; set; } + public string? Interim { get; set; } + public DateTime? ModifiedDate { get; set; } + public string? ModifiedBy { get; set; } + public bool IsActive { get; set; } + + public virtual SVMUnit Unit { get; set; } = null!; + public virtual PhonePerson Person { get; set; } = null!; + public virtual ViperPerson? ViperModPerson { get; set; } + } +} diff --git a/web/Areas/Personnel/Models/ViperPerson.cs b/web/Areas/Personnel/Models/ViperPerson.cs new file mode 100644 index 000000000..39c11f64a --- /dev/null +++ b/web/Areas/Personnel/Models/ViperPerson.cs @@ -0,0 +1,17 @@ +namespace Viper.Areas.Personnel.Models +{ + /// + /// Read-only entity for accessing users.Person table within PhonesDbContext. + /// Used for joining to get employee names without cross-context queries. + /// + public class ViperPerson + { + public int PersonId { get; set; } + public string FirstName { get; set; } = string.Empty; + public string LastName { get; set; } = string.Empty; + public string FullName { get; set; } = string.Empty; + public required string IamId { get; set; } + public required bool CurrentEmployee { get; set; } + public string MailId { get; set; } = string.Empty; + } +} diff --git a/web/Areas/Personnel/PhonesDbContext.cs b/web/Areas/Personnel/PhonesDbContext.cs new file mode 100644 index 000000000..ee695b077 --- /dev/null +++ b/web/Areas/Personnel/PhonesDbContext.cs @@ -0,0 +1,216 @@ +using Microsoft.EntityFrameworkCore; +using Viper.Areas.Personnel.Models; + +namespace Viper.Areas.Personnel; + +/// +/// Entity Framework DbContext for the Personnel phone numbers system. +/// All tables are in the [phones] schema in the VIPER database. +/// +public class PhonesDbContext : DbContext +{ + public PhonesDbContext(DbContextOptions options) : base(options) + { + } + + // Core data tables + public virtual DbSet PhonePerson { get; set; } + public virtual DbSet SVMSection { get; set; } + public virtual DbSet SVMUnit { get; set; } + public virtual DbSet SVMUnitPerson { get; set; } + public virtual DbSet SVMFrequentNumber { get; set; } + public virtual DbSet PhoneList { get; set; } + public virtual DbSet PhoneListUnit { get; set; } + public virtual DbSet PhoneListUnitPerson { get; set; } + + // Read-only cross-schema reference (users schema in same database) + public virtual DbSet ViperPerson { get; set; } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + base.OnModelCreating(modelBuilder); + + // PhonePerson (phones.Person) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.PersonIam); + entity.ToTable("Person", schema: "phones"); + + entity.Property(e => e.PersonIam).HasColumnName("PersonIam"); + entity.Property(e => e.Phone).HasColumnName("Phone").HasMaxLength(25); + entity.Property(e => e.DirectPhone).HasColumnName("DirectPhone").HasMaxLength(25); + entity.Property(e => e.Office).HasColumnName("Office").HasMaxLength(100); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy"); + + // Cross-schema FK to users.Person + entity.HasOne(e => e.ViperPerson) + .WithMany() + .HasForeignKey(e => e.PersonIam) + .HasPrincipalKey(e => e.IamId) + .IsRequired(); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMSection (phones.SVMSection) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.SectionId); + entity.ToTable("SVMSection", schema: "phones"); + + entity.Property(e => e.SectionId).HasColumnName("SectionId"); + entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(100); + entity.Property(e => e.IncludeAbbrv).HasColumnName("IncludeAbbrv"); + entity.Property(e => e.UnitName).HasColumnName("UnitName").HasMaxLength(50); + entity.Property(e => e.DirectorTitle).HasColumnName("DirectorTitle").HasMaxLength(50); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + }); + + // SVMUnit (phones.SVMUnit) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.UnitId); + entity.ToTable("SVMUnit", schema: "phones"); + + entity.Property(e => e.UnitId).HasColumnName("UnitId"); + entity.Property(e => e.SectionId).HasColumnName("SectionId"); + entity.Property(e => e.Name).HasColumnName("Name").HasMaxLength(100); + entity.Property(e => e.Fax).HasColumnName("Fax").HasMaxLength(25); + entity.Property(e => e.Abbrv).HasColumnName("Abbrv").HasMaxLength(20); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + + entity.HasOne(e => e.Section) + .WithMany(s => s.Units) + .HasForeignKey(e => e.SectionId); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMUnitPerson (phones.SVMUnitPerson) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.UnitPersonId); + entity.ToTable("SVMUnitPerson", schema: "phones"); + + entity.Property(e => e.UnitPersonId).HasColumnName("UnitPersonId"); + entity.Property(e => e.UnitId).HasColumnName("UnitId"); + entity.Property(e => e.PersonIam).HasColumnName("PersonIam").HasMaxLength(10); + entity.Property(e => e.Office).HasColumnName("Office").HasMaxLength(50); + entity.Property(e => e.PosType).HasColumnName("PosType").HasMaxLength(25); + entity.Property(e => e.Interim).HasColumnName("Interim").HasMaxLength(10); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + entity.Property(e => e.IsActive).HasColumnName("IsActive"); + + entity.HasOne(e => e.Unit) + .WithMany(s => s.UnitPersons) + .HasForeignKey(e => e.UnitId); + + entity.HasOne(e => e.Person) + .WithMany(s => s.UnitPersons) + .HasForeignKey(e => e.PersonIam); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // SVMFrequentNumber (phones.SVMFrequentNumber) + modelBuilder.Entity(entity => + { + entity.HasKey(e => e.NumberId); + entity.ToTable("SVMFrequentNumber", schema: "phones"); + + entity.Property(e => e.NumberId).HasColumnName("NumberId"); + entity.Property(e => e.Label).HasColumnName("Label").HasMaxLength(100); + entity.Property(e => e.Phone).HasColumnName("Phone").HasMaxLength(25); + entity.Property(e => e.SortOrder).HasColumnName("SortOrder"); + entity.Property(e => e.ModifiedDate).HasColumnName("ModifiedDate"); + entity.Property(e => e.ModifiedBy).HasColumnName("ModifiedBy").HasMaxLength(10); + entity.Property(e => e.IsActive).HasColumnName("IsActive"); + + entity.HasOne(e => e.ViperModPerson) + .WithMany() + .HasForeignKey(e => e.ModifiedBy) + .HasPrincipalKey(e => e.IamId); + }); + + // PhoneList (phones.PhoneList) + modelBuilder.Entity