public void GetTaskCountTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db, testCompany);
// Now create a task and try to search for it
int expected = taskManagerService.GetTaskCount(); // Start count
for (int i = 0; i < 10; i++)
{
int rand = RandomInt(5, 20);
for (int j = 0; j < rand; j++)
{
var testTask = createTestTask(testCompany, testUser);
var error = taskManagerService.InsertOrUpdateTask(testTask, "");
Assert.IsTrue(!error.IsError, error.Message);
}
expected += rand;
int actual = taskManagerService.GetTaskCount();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected ");
}
}
public void MapToModelTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db, testCompany);
// Create a task
var testTask = new TaskModel {
CompanyId = testCompany.Id,
CreatedDate = DateTimeOffset.Now,
TaskTypeId = db.FindLOVItemByValue1(null, LOVName.TaskType, ((int)TaskType.MSQChangeNotification).ToString()).Id,
BusinessUnitId = db.FindLOVItems(testCompany.Id, db.FindLOV(LOVName.BusinessUnit).Id)
.FirstOrDefault()
.Id,
UserId = testUser.Id,
Title = RandomString(),
Description = RandomString(),
StatusId = db.FindLOVItems(testCompany.Id,
db.FindLOV(LOVName.TaskStatus).Id)
.FirstOrDefault()
.Id,
Enabled = true
};
var model = taskManagerService.MapToModel(testTask);
AreEqual(testTask, model);
}
public void AddUserDetailsTest()
{
var testUser = GetTestUser(true, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
int expected = 0,
actual = dict.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db);
taskManagerService.AddUserDetails(testUser, dict);
expected = 2;
actual = dict.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
string keyName = "USERNAME";
try {
var test = dict[keyName].ToString();
Assert.IsTrue(testUser.FullName == test, $"Error: {test} was returned when {testUser.FullName} was expected");
} catch {
Assert.Fail($"Error: Item '{keyName}' was not found in the dictionary");
}
keyName = "EMAIL";
try {
var test = dict[keyName].ToString();
Assert.IsTrue(testUser.EMail == test, $"Error: {test} was returned when {testUser.EMail} was expected");
} catch {
Assert.Fail($"Error: Item '{keyName}' was not found in the dictionary");
}
}
public void LockTaskTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db, testCompany);
// Create a task
var model = createTestTask(testCompany, testUser);
var error = taskManagerService.InsertOrUpdateTask(model, "");
Assert.IsTrue(!error.IsError, error.Message);
// Get the current Lock
string lockGuid = taskManagerService.LockTask(model);
Assert.IsTrue(!string.IsNullOrEmpty(lockGuid), "Error: Lock record was not found");
// Simulate another user updating the record
var otherUser = GetTestUser();
error = taskManagerService.InsertOrUpdateTask(model, lockGuid);
Assert.IsTrue(!error.IsError, error.Message);
// Now get the first user to update the record
error = taskManagerService.InsertOrUpdateTask(model, lockGuid);
Assert.IsTrue(error.IsError, "Error: The lock should have caused an error as it has changed");
// Try to update with the new lock
lockGuid = taskManagerService.LockTask(model);
error = taskManagerService.InsertOrUpdateTask(model, lockGuid);
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
}
public void SendMSQOverrideEMailTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var testCustomer = GetTestCustomer(testCompany, testUser);
var soh = GetTestSalesOrderHeader(testCompany, testCustomer, testUser, RandomInt(5, 50));
EMailService.EMailService EMailService = GetEMailService(testCompany);
TaskManagerService.TaskManagerService TaskManagerService = GetTaskManagerService(testCompany);
int emailQBefore = EMailService.GetQueueCount(),
notificationsBefore = TaskManagerService.GetTaskCount();
var testUser2 = GetTestUser();
var error = SalesService.SendMSQOverrideEMail(testCompany, testUser, testUser2, soh);
int emailQAfter = EMailService.GetQueueCount(),
notificationsAfter = TaskManagerService.GetTaskCount();
int actual = emailQAfter - emailQBefore,
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} EMail items were returned when {expected} were expected");
actual = notificationsAfter - notificationsBefore;
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} Notifications were returned when {expected} were expected");
}
protected TaskManagerService.TaskManagerService GetTaskManagerService(CompanyModel company)
{
if (_taskManagerService == null)
{
_taskManagerService = new TaskManagerService.TaskManagerService(db, company);
}
return(_taskManagerService);
}
public void FindTaskListModelTest()
{
// Get a test user and test company
int tz = 600;
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db, testCompany);
// Now create an notification and try to search for it
string subject = RandomString(),
message = LorumIpsum();
var result = taskManagerService.SendTask(subject,
message,
TaskType.Default,
LookupService.FindLOVItemsModel(testCompany, LOVName.BusinessUnit).FirstOrDefault(),
testUser,
null,
null);
Assert.IsTrue(!result.IsError, result.Message);
// Perform a global test which should bring back the first page
var notificationList = taskManagerService.FindTaskListModel(testCompany, testUser, 0, 1, PageSize,
0,
0,
0,
0,
0,
"",
tz);
int actual = notificationList.Items
.Where(n => n.Title == subject)
.Count();
int expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} was expected");
// Delete and check again
taskManagerService.DeleteTask(result.Id);
notificationList = taskManagerService.FindTaskListModel(testCompany, testUser, 0, 1, PageSize,
0,
0,
0,
0,
0,
"",
tz);
actual = notificationList.Items
.Where(n => n.Title == subject)
.Count();
expected = 0;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} was expected");
}
public void FindTaskModelTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
TaskManagerService.TaskManagerService taskManagerService = new TaskManagerService.TaskManagerService(db, testCompany);
// Now create a task and try to search for it
var testTask = createTestTask(testCompany, testUser);
var error = taskManagerService.InsertOrUpdateTask(testTask, "");
Assert.IsTrue(!error.IsError, error.Message);
var result = taskManagerService.FindTaskModel(testTask.Id, testCompany, testUser, false);
Assert.IsTrue(result != null, $"Error: 0 records were returned when 1 was expected");
Assert.IsTrue(result.Id == testTask.Id, $"Error: Supplier {result.Id} was returned when {testTask.Id} was expected");
AreEqual(testTask, result);
}
public Error CreatePicks(CompanyModel company, UserModel currentUser, string sohIds, bool bCombine)
{
var error = validateSingleOrder(company, sohIds);
if (!error.IsError)
{
// TBD: Validate the document creation so that we don't have a rollback scenario
// All sales validate, so drop them as individual drops
List <PickHeaderModel> picks = new List <PickHeaderModel>();
error = PickService.CreatePicks(company, sohList, bCombine, picks);
// The returned list contains the names of the pick CSV temp files.
// Now create the corresponding support PDF document when
// the location configuration specifies that it should be created.
if (!error.IsError)
{
error = createDocuments(company, picks);
}
// Now drop the files to the warehouse
if (!error.IsError)
{
var sohIdList = new List <int>();
foreach (var pick in picks)
{
error = FilePackagerService.SendPickToWarehouse(pick);
if (error.IsError)
{
break;
}
else
{
// Pick successfully sent, so:
foreach (var detail in pick.PickDetails)
{
var sod = FindSalesOrderDetailModel(detail.SalesOrderDetailId);
if (sod != null)
{
// Change all the line items to 'sent for picking'
sod.LineStatusId = (int)SalesOrderLineStatus.SentForPicking;
InsertOrUpdateSalesOrderDetail(sod, "");
// Remove allocations from sale
AllocationService.DeleteAllocationsForPurchaseLine(company, sod.Id);
if (sohIdList.Where(l => l == sod.SalesOrderHeaderId).Count() == 0)
{
sohIdList.Add(sod.SalesOrderHeaderId);
}
}
}
// Set 'sent to warehouse date' on pick header
PickService.SetPickSentToWarehouseDate(pick, DateTimeOffset.Now);
}
}
// Attach notes to SOH's to indicate pick sent to W/House
TaskManagerService.TaskManagerService tm = new TaskManagerService.TaskManagerService(db, company);
foreach (var sohId in sohIdList)
{
var soh = FindSalesOrderHeaderModel(sohId, company, false);
if (soh != null)
{
var subject = "Order Sent to Warehouse";
var message = "Order sent to Warehouse for picking";
NoteService.AttachNoteToSalesOrder(soh, currentUser, subject, message);
}
}
}
// Cleanup all the temp pick files
foreach (var pick in picks)
{
foreach (var pickFile in pick.PickFiles)
{
FileManagerService.FileManagerService.DeleteFile(pickFile);
}
}
if (!error.IsError)
{
error.SetInfo(EvolutionResources.infPicksSuccessfullyCreated);
}
}
return(error);
}
