1948 lines
73 KiB
C#
1948 lines
73 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
|
|
using LCU.Library.Internal.IncentiveApiModels.Entities;
|
|
using LCU.Library.Internal.IncentiveApiModels.Enums;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using LCU.Library.Internal.IncentiveApiModels.Common;
|
|
|
|
namespace Application.UnitTests.Repository
|
|
{
|
|
public class ActivityRepositoryTest
|
|
{
|
|
private ApplicationDbContext _context;
|
|
private ActivityRepository _repository;
|
|
private ActivityChangeRepository _repositoryActivityChange;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
var mockDateTime = new DateTimeService();
|
|
var mockCurrentUserService = Mock.Of<ICurrentUserService>();
|
|
Mock.Get(mockCurrentUserService).Setup(s => s.GetCurrentUser()).Returns(new ApplicationUser
|
|
{
|
|
Email = "[email protected]",
|
|
});
|
|
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
|
|
.UseInMemoryDatabase(Guid.NewGuid().ToString())
|
|
.EnableSensitiveDataLogging()
|
|
.Options;
|
|
_context = new ApplicationDbContext(options, mockCurrentUserService, mockDateTime);
|
|
_repository = new ActivityRepository(_context);
|
|
_repositoryActivityChange = new ActivityChangeRepository(_context);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Basic_Flow_Test()
|
|
{
|
|
var saved = await _repository.GetActivitiesAsync();
|
|
Assert.NotNull(saved);
|
|
Assert.IsEmpty(saved);
|
|
|
|
await _repository.SaveActivityAsync(new Activity
|
|
{
|
|
EmployeeId = "1254",
|
|
DepartmentId = 5,
|
|
Product = Product.CheckCard,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "Tester 1",
|
|
AgreementNumber = "234",
|
|
SubjectPersonNbr = "34"
|
|
}
|
|
});
|
|
await _context.SaveChangesAsync();
|
|
|
|
saved = await _repository.GetActivitiesAsync();
|
|
Assert.NotNull(saved);
|
|
Assert.IsNotEmpty(saved);
|
|
var first = saved.First();
|
|
// Make sure our Auditable is working.
|
|
Assert.NotNull(first.CreatedBy);
|
|
Assert.NotNull(first.Created);
|
|
Assert.NotNull(first.LastUpdatedBy);
|
|
Assert.NotNull(first.LastUpdated);
|
|
|
|
var savedActivity = await _repository.GetActivityById(saved.First().Id);
|
|
Assert.AreSame(saved.First(), savedActivity);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Basic_RangeFlow_Test()
|
|
{
|
|
var saved = await _repository.GetActivitiesAsync();
|
|
Assert.NotNull(saved);
|
|
Assert.IsEmpty(saved);
|
|
|
|
var activities = new List<Activity>
|
|
{
|
|
new Activity
|
|
{
|
|
EmployeeId = "1254",
|
|
DepartmentId = 5,
|
|
Product = Product.CheckCard,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "Tester 1",
|
|
AgreementNumber = "234",
|
|
SubjectPersonNbr = "34"
|
|
}
|
|
},
|
|
new Activity
|
|
{
|
|
EmployeeId = "2134",
|
|
DepartmentId = 5,
|
|
Product = Product.CheckCard,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "Tester 2",
|
|
AgreementNumber = "234",
|
|
SubjectPersonNbr = "34"
|
|
}
|
|
}
|
|
};
|
|
await _repository.SaveActivityRangeAsync(activities);
|
|
await _context.SaveChangesAsync();
|
|
|
|
saved = await _repository.GetActivitiesAsync();
|
|
Assert.NotNull(saved);
|
|
Assert.IsNotEmpty(saved);
|
|
Assert.AreEqual(2, saved.Count());
|
|
var first = saved.First();
|
|
// Make sure our Auditable is working.
|
|
Assert.NotNull(first.CreatedBy);
|
|
Assert.NotNull(first.Created);
|
|
Assert.NotNull(first.LastUpdatedBy);
|
|
Assert.NotNull(first.LastUpdated);
|
|
|
|
var savedActivity = await _repository.GetActivityById(saved.First().Id);
|
|
Assert.AreSame(saved.First(), savedActivity);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMonthlyPersonnelActivity_None()
|
|
{
|
|
var department = new Department
|
|
{
|
|
DepartmentName = "Dept1",
|
|
Id = 55,
|
|
State = DepartmentState.Active
|
|
};
|
|
var user = new AppUser
|
|
{
|
|
AdEmail = "[email protected]",
|
|
BaseRole = "Tester",
|
|
EmployeeId = "11771",
|
|
FullName = "Test McTester",
|
|
HomeDepartment = "HOME",
|
|
PersonId = 565,
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
var assignment = new UserDepartment
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
Employee = user,
|
|
Role = Role.Admin,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
};
|
|
user.Departments.Add(assignment);
|
|
|
|
var range = new MonthRange(2021, 1, 2021, 2);
|
|
var found = await _repository.FindEmployeeActivityByMonthRange(user, range);
|
|
Assert.NotNull(found);
|
|
Assert.IsEmpty(found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMonthlyPersonnelActivity_Basic()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11771",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "1"
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "11771",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "2"
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11772",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3"
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11772",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMonths(2),
|
|
SourceId = "4"
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
|
|
await _context.SaveChangesAsync();
|
|
|
|
var department = new Department
|
|
{
|
|
Id = 55,
|
|
State = DepartmentState.Active,
|
|
DepartmentName = "Test",
|
|
BusinessLineCode = BusinessLine.Operations.Code
|
|
};
|
|
var user = new AppUser
|
|
{
|
|
AdEmail = "[email protected]",
|
|
BaseRole = "Tester",
|
|
EmployeeId = "11771",
|
|
FullName = "Test McTester",
|
|
HomeDepartment = "HOME",
|
|
PersonId = 11771,
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
var assignment = new UserDepartment
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
DepartmentId = 55,
|
|
Employee = user,
|
|
Role = Role.Admin,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
};
|
|
user.Departments.Add(assignment);
|
|
|
|
var range = new MonthRange(
|
|
DateTime.Today.Year,
|
|
DateTime.Today.Month,
|
|
DateTime.Today.Year,
|
|
DateTime.Today.Month
|
|
);
|
|
|
|
var found = await _repository.FindEmployeeActivityByMonthRange(user, range);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found);
|
|
Assert.AreEqual(2, found.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesAsync_Paginated_OK()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Created = DateTime.Today.Subtract(TimeSpan.FromDays(7))
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Created = DateTime.Today.Subtract(TimeSpan.FromDays(6))
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Created = DateTime.Today.Subtract(TimeSpan.FromDays(6))
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Created,
|
|
Created = DateTime.Today.Subtract(TimeSpan.FromDays(5))
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.GetActivitiesAsync(1, 3);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(3, found.Items.Count());
|
|
Assert.AreEqual(4, found.Total);
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "1"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "2"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "3"));
|
|
|
|
found = await _repository.GetActivitiesAsync(2, 3);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(4, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "4"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
|
|
found = await _repository.GetActivitiesAsync(100, 3);
|
|
Assert.AreEqual(4, found.Total);
|
|
Assert.IsEmpty(found.Items);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByActivityProductAsync_OK()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 4)
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 3)
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
LastUpdated = new DateTime(2021, 1, 2)
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 1)
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
Product = new List<Product> { Product.CheckCard }
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(1, found.Total);
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByActivityTypeAsync_OK()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 4)
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 3)
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
LastUpdated = new DateTime(2021, 1, 2)
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.NewChecking,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 1)
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
Type = new List<ActivityType> { ActivityType.Sale }
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(1, found.Total);
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByStateAsync_OK()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 4)
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 3)
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
LastUpdated = new DateTime(2021, 1, 2)
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
LastUpdated = new DateTime(2021, 1, 1)
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
State = new List<ActivityState> { ActivityState.Accepted }
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(2, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "2"));
|
|
|
|
filter.Page = 2;
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "4"));
|
|
|
|
var filter2 = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 100,
|
|
State = new List<ActivityState> { ActivityState.ManualReview }
|
|
};
|
|
found = await _repository.GetPagedFilteredActivities(filter2);
|
|
Assert.AreEqual(0, found.Total);
|
|
Assert.IsEmpty(found.Items);
|
|
|
|
filter2.Page = 20;
|
|
found = await _repository.GetPagedFilteredActivities(filter2);
|
|
Assert.AreEqual(0, found.Total);
|
|
Assert.IsEmpty(found.Items);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByFilter_More()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "1Jane3Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
Query = "DoE"
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(2, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "2"));
|
|
|
|
filter.Page = 2;
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "4"));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByFilter_Employee_Department()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "1Jane3Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
DepartmentId = 55
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(2, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
|
|
|
|
filter.EmployeeId = "4";
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.AreEqual(1, found.Items.Count());
|
|
Assert.AreEqual(1, found.Total);
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
|
|
Assert.False(found.Items.Any(x => x.EmployeeId == "1"));
|
|
Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
|
|
|
|
filter.DepartmentId = 99;
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.AreEqual(0, found.Items.Count());
|
|
Assert.AreEqual(0, found.Total);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByFilter_LowDate_Accepted()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddDays(-1),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "1Jane3Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
DateLow = DateTime.Today
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(2, found.Items.Count());
|
|
Assert.AreEqual(2, found.Total);
|
|
Assert.True(found.Items.Any(x => x.Accepted == DateTime.Today));
|
|
Assert.False(found.Items.Any(x => x.Accepted != DateTime.Today)); // not on this page
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivitiesByFilter_Sort()
|
|
{
|
|
// You can't set last updated. So you'll get these back in reverse order you saved them.
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "1Jane3Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var filter = new ActivityFilter
|
|
{
|
|
Page = 1,
|
|
Limit = 99,
|
|
DepartmentId = 55,
|
|
SortBy = "EmployeeId"
|
|
};
|
|
var found = await _repository.GetPagedFilteredActivities(filter);
|
|
var expected = new[] { "1", "2", "3" };
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(3, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());
|
|
|
|
filter.SortDescending = true;
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
expected = new[] { "3", "2", "1" };
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(3, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());
|
|
|
|
filter.SortDescending = false;
|
|
filter.SortBy = null;
|
|
found = await _repository.GetPagedFilteredActivities(filter);
|
|
expected = new[] { "1", "3", "2" };
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found.Items);
|
|
Assert.AreEqual(3, found.Items.Count());
|
|
Assert.AreEqual(3, found.Total);
|
|
Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindUnmatchedReferrals_Basic()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-3),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe"
|
|
},
|
|
MetaData = new List<ActivityMetaData> { new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone } }
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-2),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "1Jane3Doe"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.AddMinutes(-1),
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234"
|
|
},
|
|
MetaData = new List<ActivityMetaData> { new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone } }
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedReferrals();
|
|
Assert.NotNull(found);
|
|
Assert.IsNotEmpty(found);
|
|
Assert.AreEqual(1, found.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMatchedSaleForReferral_Basic()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
SourceCreated = DateTime.Today,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234565",
|
|
SubjectPersonNbr = "1223423",
|
|
SubjectOrgNbr = "122343"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35",
|
|
SubjectPersonNbr = "123234245",
|
|
SubjectOrgNbr = "122223"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedSaleForReferral(activity1);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(activity2, found);
|
|
}
|
|
|
|
[TestCase("1234567", MetaDataType.Phone)]
|
|
[TestCase("[email protected]", MetaDataType.Email)]
|
|
[Test]
|
|
public async Task FindMatchedSaleForReferral_MatchOnMetaData_Basic(string metaDataValue, MetaDataType metaDataType)
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.FirstMortgageReferral,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "", // null or empty personNbr and orgNbr trigger match on metadata
|
|
SubjectOrgNbr = ""
|
|
},
|
|
MetaData = new List<ActivityMetaData>
|
|
{
|
|
new ActivityMetaData()
|
|
{
|
|
Id = 1,
|
|
MetaData = metaDataValue,
|
|
MetaDataType = metaDataType
|
|
}
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.FirstMortgageReferral,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "",
|
|
SubjectOrgNbr = ""
|
|
},
|
|
MetaData = new List<ActivityMetaData>
|
|
{
|
|
new ActivityMetaData()
|
|
{
|
|
Id = 2,
|
|
MetaData = metaDataValue,
|
|
MetaDataType = metaDataType
|
|
}
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.FirstMortgageReferral,
|
|
SourceCreated = DateTime.Today,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Rejected, // rejected state excludes activity from potentially matching
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234565",
|
|
SubjectPersonNbr = null,
|
|
SubjectOrgNbr = null
|
|
},
|
|
MetaData = new List<ActivityMetaData>()
|
|
{
|
|
new ActivityMetaData()
|
|
{
|
|
Id = 3,
|
|
MetaData = "[email protected]",
|
|
MetaDataType = MetaDataType.Email
|
|
}
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.FirstMortgageReferral,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35",
|
|
SubjectPersonNbr = null,
|
|
SubjectOrgNbr = null
|
|
},
|
|
MetaData = new List<ActivityMetaData>() { }
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedSaleForReferral(activity1);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(activity2, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMatchedSaleForReferral_AllSalesAlreadyAssociatedToStateChange_NoReturn()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
|
|
await _repository.SaveActivityAsync(activity1);
|
|
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity2);
|
|
var change2 = new ActivityStateChange
|
|
{
|
|
ActivityId = 2,
|
|
State = ActivityState.Accepted,
|
|
ActivityMatchId = activity2.Id
|
|
};
|
|
await _repositoryActivityChange.SaveActivityStateChange(change2);
|
|
var activity3 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
SourceCreated = DateTime.Today,
|
|
Accepted = DateTime.Today,
|
|
SourceId = "3",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "1234565",
|
|
SubjectPersonNbr = "1223423",
|
|
SubjectOrgNbr = "122343"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity3);
|
|
var change3 = new ActivityStateChange
|
|
{
|
|
ActivityId = 3,
|
|
State = ActivityState.Accepted,
|
|
ActivityMatchId = activity3.Id
|
|
};
|
|
await _repositoryActivityChange.SaveActivityStateChange(change3);
|
|
var activity4 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "4",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today,
|
|
SourceId = "4",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "12DOE35",
|
|
SubjectPersonNbr = "123234245",
|
|
SubjectOrgNbr = "122223"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity4);
|
|
var change4 = new ActivityStateChange
|
|
{
|
|
ActivityId = 4,
|
|
State = ActivityState.Accepted,
|
|
ActivityMatchId = activity4.Id
|
|
};
|
|
await _repositoryActivityChange.SaveActivityStateChange(change4);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedSaleForReferral(activity1);
|
|
Assert.IsNull(found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMatchedSaleForReferral_NoUnmatchedActivities_ReturnNull()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
},
|
|
MetaData = new List<ActivityMetaData>
|
|
{
|
|
new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone },
|
|
new ActivityMetaData { MetaData = "[email protected]", MetaDataType = MetaDataType.Email }
|
|
}
|
|
};
|
|
|
|
await _repository.SaveActivityAsync(activity1);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedSaleForReferral(activity1);
|
|
Assert.IsNull(found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindMatchedSaleForReferral_SameDay_NotSameTime()
|
|
{
|
|
var referral = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
|
|
var sale = new Activity
|
|
{
|
|
DepartmentId = 56,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today,
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
|
|
// Just make sure that the referral can happen after the sale, but the same day.
|
|
referral.SourceCreated = referral.SourceCreated.AddHours(12);
|
|
sale.SourceCreated = sale.SourceCreated.AddHours(2);
|
|
Assert.AreNotEqual(referral.SourceCreated, sale.SourceCreated);
|
|
Assert.AreEqual(referral.SourceCreated.Date, sale.SourceCreated.Date);
|
|
Assert.True(referral.SourceCreated > sale.SourceCreated);
|
|
await _repository.SaveActivityAsync(referral);
|
|
await _repository.SaveActivityAsync(sale);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.FindUnmatchedSaleForReferral(referral);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(sale, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Duplicate_Detection_Basic_Sale_Product_Default()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
await _context.SaveChangesAsync();
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
|
|
// They are complete duplicates.
|
|
var found = await _repository.FindDuplicateSaleAsync(activity2);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(activity1, found);
|
|
|
|
// Change only source ID
|
|
Random r = new Random();
|
|
activity2.SourceId = r.Next(10000, 50000) + "_SCID";
|
|
activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
|
|
activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
|
|
found = await _repository.FindDuplicateSaleAsync(activity2);
|
|
Assert.Null(found);
|
|
|
|
// Change SubjectPersonNbr Only.
|
|
activity2.SourceId = null;
|
|
activity2.Detail.SubjectPersonNbr = "12234333";
|
|
activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
|
|
found = await _repository.FindDuplicateSaleAsync(activity2);
|
|
Assert.Null(found);
|
|
|
|
// Change SubjectOrgNbr Only.
|
|
activity2.SourceId = null;
|
|
activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
|
|
activity2.Detail.SubjectOrgNbr = "3112333";
|
|
found = await _repository.FindDuplicateSaleAsync(activity2);
|
|
Assert.Null(found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindActivityForStateUpdate_Default()
|
|
{
|
|
var existingActivity = new Activity
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(existingActivity);
|
|
await _context.SaveChangesAsync();
|
|
var updateStateActivity = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10"
|
|
}
|
|
};
|
|
|
|
// They are complete duplicates.
|
|
var found = await _repository.FindActivityForStateUpdate(updateStateActivity);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(existingActivity, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindActivityForDetailUpdate_Default()
|
|
{
|
|
var existingActivity = new Activity
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(existingActivity);
|
|
await _context.SaveChangesAsync();
|
|
var queryActivity = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309"
|
|
}
|
|
};
|
|
|
|
var found = await _repository.FindActivityForDetailUpdate(queryActivity);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(existingActivity, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindActivityForDetailUpdate_FallsBackToNotMatchOnSubAccountNumberAfterFindingNothing()
|
|
{
|
|
var existingActivity = new Activity
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(existingActivity);
|
|
await _context.SaveChangesAsync();
|
|
var queryActivity = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
State = ActivityState.Rejected,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309"
|
|
}
|
|
};
|
|
|
|
var found = await _repository.FindActivityForDetailUpdate(queryActivity);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(existingActivity, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Duplicate_Detection_Basic_Referral_Product_Default()
|
|
{
|
|
var activity1 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceId = "1",
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
await _repository.SaveActivityAsync(activity1);
|
|
await _context.SaveChangesAsync();
|
|
var activity2 = new Activity
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Referral,
|
|
Product = Product.CheckCard,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
State = ActivityState.PendingReferral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
MemberName = "John Doe",
|
|
SubjectPersonNbr = "12345",
|
|
SubjectOrgNbr = "123"
|
|
}
|
|
};
|
|
|
|
// They are complete duplicates.
|
|
var found = await _repository.FindDuplicateReferralAsync(activity2);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(activity1, found);
|
|
|
|
// Change only source ID, Referrals do not care
|
|
Random r = new Random();
|
|
activity2.SourceId = r.Next(10000, 50000) + "_SCID";
|
|
activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
|
|
activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
|
|
found = await _repository.FindDuplicateReferralAsync(activity2);
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(activity1, found);
|
|
|
|
// Change SubjectPersonNbr Only.
|
|
activity2.SourceId = null;
|
|
activity2.Detail.SubjectPersonNbr = "12234333";
|
|
activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
|
|
found = await _repository.FindDuplicateReferralAsync(activity2);
|
|
Assert.Null(found);
|
|
|
|
// Change SubjectOrgNbr Only.
|
|
activity2.SourceId = null;
|
|
activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
|
|
activity2.Detail.SubjectOrgNbr = "3112333";
|
|
found = await _repository.FindDuplicateReferralAsync(activity2);
|
|
Assert.Null(found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindDepartmentActivityByMonthRange_Basic()
|
|
{
|
|
var activityInRange = new Activity
|
|
{
|
|
DepartmentId = 1,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = new DateTime(2021, 7, 3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted
|
|
};
|
|
await _repository.SaveActivityAsync(activityInRange);
|
|
var activityNotInRange = new Activity
|
|
{
|
|
DepartmentId = 1,
|
|
EmployeeId = "2",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = new DateTime(2021, 6, 3),
|
|
SourceId = "2",
|
|
State = ActivityState.Accepted
|
|
};
|
|
await _repository.SaveActivityAsync(activityNotInRange);
|
|
var activityForOtherDepartment = new Activity
|
|
{
|
|
DepartmentId = 2,
|
|
EmployeeId = "3",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = new DateTime(2021, 7, 3),
|
|
SourceId = "3",
|
|
State = ActivityState.Accepted
|
|
};
|
|
await _repository.SaveActivityAsync(activityForOtherDepartment);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var range = new MonthRange(2021, 7, 2021, 8);
|
|
var found = await _repository.FindDepartmentActivityByMonthRange(1, range);
|
|
|
|
Assert.AreEqual(1, found.Count());
|
|
Assert.AreEqual("1", found.First().EmployeeId);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivityIncludingPayouts_Basic()
|
|
{
|
|
var department = new Department()
|
|
{
|
|
DepartmentName = "Dept1",
|
|
Id = 55,
|
|
State = DepartmentState.Active
|
|
};
|
|
|
|
var user = new AppUser
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11771",
|
|
FullName = "Abraham TestAssociate1",
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
};
|
|
|
|
var activityWithPayouts = new Activity
|
|
{
|
|
Id = 11,
|
|
DepartmentId = 1,
|
|
EmployeeId = "1",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.CheckCard,
|
|
Accepted = new DateTime(2021, 7, 3),
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail { Id = 22 },
|
|
ActivityPayouts = new List<ActivityPayoutLineItem>
|
|
{
|
|
new ActivityPayoutLineItem
|
|
{
|
|
ActivityId = 11,
|
|
PayoutLineItemId = 33,
|
|
PayoutLineItem = new PayoutLineItem { Id = 33, EmployeeId = "1", Role = Role.BM }
|
|
}
|
|
}
|
|
};
|
|
|
|
await _repository.SaveActivityAsync(activityWithPayouts);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var found = await _repository.GetActivityIncludingPayouts(11);
|
|
|
|
Assert.NotNull(found);
|
|
Assert.AreEqual(11, found.Id);
|
|
Assert.AreEqual(22, found.Detail.Id);
|
|
Assert.AreEqual(11, found.ActivityPayouts.First().ActivityId);
|
|
Assert.AreEqual(33, found.ActivityPayouts.First().PayoutLineItemId);
|
|
Assert.AreEqual(33, found.ActivityPayouts.First().PayoutLineItem.Id);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindGapInsuranceEligible()
|
|
{
|
|
var sourceId = CreateId();
|
|
var accepted = DateTime.UtcNow;
|
|
|
|
var activities = new List<Activity>()
|
|
{
|
|
new() // Eligible
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
IsGapInsuranceEligible = true
|
|
}
|
|
},
|
|
new() // Detail is null
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted
|
|
},
|
|
new() // Accepted is not in range
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted.AddMonths(-1),
|
|
Detail = new ActivityDetail
|
|
{
|
|
IsGapInsuranceEligible = true
|
|
}
|
|
},
|
|
new() // Is not GAP insurance eligible
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted= accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
IsGapInsuranceEligible = false
|
|
}
|
|
}
|
|
};
|
|
|
|
await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
|
|
await _context.SaveChangesAsync();
|
|
var eligibles = await _repository.FindGapInsuranceEligible(new MonthRange(accepted, accepted));
|
|
Assert.AreEqual(1, eligibles.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task PropertyChangesIsGapEligible_VehicleProduct()
|
|
{
|
|
var sourceId = CreateId();
|
|
var accepted = DateTime.UtcNow;
|
|
|
|
var activities = new List<Activity>()
|
|
{
|
|
new() // Eligible
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
Id = 3,
|
|
IsGapInsuranceEligible = true
|
|
}
|
|
},
|
|
new() // Detail is null
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted
|
|
},
|
|
new() // Accepted is not in range
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted = accepted.AddMonths(-1),
|
|
Detail = new ActivityDetail
|
|
{
|
|
Id = 1,
|
|
IsGapInsuranceEligible = true
|
|
}
|
|
},
|
|
new() // Is not GAP insurance eligible
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId,
|
|
Accepted= accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
Id = 2,
|
|
IsGapInsuranceEligible = false
|
|
}
|
|
}
|
|
};
|
|
|
|
await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
|
|
await _context.SaveChangesAsync();
|
|
var eligibles = await _repository.FindGapInsuranceEligible(new MonthRange(accepted, accepted));
|
|
Assert.AreEqual(true, eligibles[0].Detail.IsGapInsuranceEligible);
|
|
Assert.AreEqual(1, eligibles.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindLatestBySourceId()
|
|
{
|
|
var sourceId1 = CreateId();
|
|
var sourceId2 = CreateId();
|
|
var created = DateTime.UtcNow;
|
|
|
|
var activities = new List<Activity>()
|
|
{
|
|
new() // Latest Source ID 1
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId1,
|
|
Created = created
|
|
},
|
|
new()
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId1,
|
|
Created = created.AddDays(-1)
|
|
},
|
|
new() // Latest Source ID 2
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId2,
|
|
Created = created
|
|
},
|
|
new()
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = sourceId2,
|
|
Created = created.AddDays(-1)
|
|
}
|
|
};
|
|
|
|
|
|
await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
|
|
await _context.SaveChangesAsync();
|
|
|
|
var latest = await _repository.FindLatestBySourceId(new List<string>
|
|
{
|
|
sourceId1,
|
|
sourceId2
|
|
});
|
|
|
|
Assert.AreEqual(2, latest.Count);
|
|
Assert.NotNull(latest.SingleOrDefault(activity => activity.EmployeeId == activities[0].EmployeeId));
|
|
Assert.NotNull(latest.SingleOrDefault(activity => activity.EmployeeId == activities[2].EmployeeId));
|
|
Assert.False((await _repository.FindLatestBySourceId(new List<string>())).Any());
|
|
}
|
|
|
|
[Test]
|
|
public async Task FindById()
|
|
{
|
|
var activities = new List<Activity>()
|
|
{
|
|
new()
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = CreateId()
|
|
},
|
|
new()
|
|
{
|
|
EmployeeId = CreateId(),
|
|
SourceId = CreateId()
|
|
}
|
|
};
|
|
|
|
|
|
await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
|
|
await _context.SaveChangesAsync();
|
|
|
|
var latest = await _repository.FindLatestBySourceId(new List<string>
|
|
{
|
|
activities[0].SourceId,
|
|
activities[1].SourceId
|
|
});
|
|
|
|
Assert.AreEqual(2, latest.Count);
|
|
var found = await _repository.FindById(latest.Select(activity => activity.Id).ToList());
|
|
Assert.AreEqual(2, found.Count);
|
|
Assert.NotNull(found.SingleOrDefault(activity => activity.Id == latest[0].Id));
|
|
Assert.NotNull(found.SingleOrDefault(activity => activity.Id == latest[1].Id));
|
|
Assert.False((await _repository.FindById(new List<int>())).Any());
|
|
}
|
|
|
|
private static string CreateId() => Guid.NewGuid().ToString("D");
|
|
}
|
|
}
|