void prepareEditModel(EditCustomerDefaultViewModel model)
{
PrepareViewModel(model, EvolutionResources.bnrAddEditCustomerDefaults);
model.CountryList = LookupService.FindCountriesListItemModel();
model.CountryList.Insert(0, new ListItemModel(EvolutionResources.lblNone, "0"));
model.CurrencyList = LookupService.FindCurrenciesListItemModel();
model.CustomerTypeList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.CustomerType);
model.CustomerTypeList.Insert(0, new ListItemModel(EvolutionResources.lblNone, "0"));
model.SalesPersonList = MembershipManagementService.FindUserListItemModel();
model.SalesPersonList.Insert(0, new ListItemModel(EvolutionResources.lblNone, "0"));
model.PaymentTermsList = LookupService.FindPaymentTermsListItemModel(CurrentCompany);
model.TaxCodeList = LookupService.FindTaxCodesListItemModel(CurrentCompany);
model.TaxCodeList.Insert(0, new ListItemModel(EvolutionResources.lblNone, "0"));
model.FreightCarrierList = LookupService.FindFreightCarriersListItemModel(model.CurrentCompany);
model.InvoiceTemplateList = new JavaScriptSerializer().Serialize(LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.Invoice));
model.PacklistTemplateList = new JavaScriptSerializer().Serialize(LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.Pickslip));
model.PriceLevelsList = LookupService.FindPriceLevelsListItemModel(CurrentCompany);
model.PriceLevelsList.Insert(0, new ListItemModel(EvolutionResources.lblNone, "0"));
}
Error sendUnpackSlipMessage(PurchaseOrderHeaderModel poh,
CompanyModel company, // Company of the file transfer
NoteModel note,
int poNumber,
List <UserModel> userList)
{
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.AddProperty("PURCHASEORDERNO", poNumber);
dict.AddProperty("COMPANYNAME", company.FriendlyName);
UserModel purchaser = MembershipManagementService.FindUserModel(poh.SalespersonId.Value);
dict.AddProperty("PURCHASER", (purchaser == null ? "" : (purchaser.FirstName + " " + purchaser.LastName).Trim()));
dict.AddProperty("SUPPLIER", poh.SupplierName);
var attachment = NoteService.FindNoteAttachmentsModel(note, MediaSize.Medium, 0, 0).FirstOrDefault();
string url = "";
if (attachment != null)
{
url = MediaService.GetMediaFileName(attachment.Media, true);
}
dict.AddProperty("URL", url);
return(SendMessage(company,
user,
MessageTemplateType.UnpackSlipNotification,
TaskType.Default,
userList,
dict));
}
public ActionResult Save(EditUserViewModel model, string command)
{
if (command.ToLower() == "save")
{
var modelError = MembershipManagementService.InsertOrUpdateUser(model.UserData, CurrentUser, model.LGS);
if (modelError.IsError)
{
prepareEditModel(model, model.UserData.Id);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"UserData_" + modelError.FieldName);
return(View("MyOptions", model));
}
else
{
// Return to dashboard
model.SetError(ErrorIcon.Information, EvolutionResources.infChangesSuccessfullySaved, null, null, null, null, true);
return(RedirectToAction("Index", "Home"));
}
}
else
{
// Return to dashboard
return(RedirectToAction("Index", "Home"));
}
}
void prepareEditModel(EditSalesOrderHeaderTempViewModel model, int id)
{
var soht = SalesService.FindSalesOrderHeaderTempModel(id, CurrentCompany, false);
PrepareViewModel(model, EvolutionResources.bnrAddEditSale + " - " + EvolutionResources.lblOrderNumber + ": " + model.SaleTemp.OrderNumber.ToString(), id, MakeMenuOptionFlags(0, 0, 0, soht.OriginalRowId) + MenuOptionFlag.RequiresNewSale);
model.ParentId = id;
model.LocationList = LookupService.FindLocationListItemModel(model.CurrentCompany);
model.ShippingTemplateList = LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.Invoice);
model.CountryList = LookupService.FindCountriesListItemModel();
model.OrderTypeList = LookupService.FindLOVItemsListItemModel(model.CurrentCompany, LOVName.OrderType);
model.BrandCategoryList = ProductService.FindBrandCategoryListItemModel(model.CurrentCompany);
model.SOStatusList = LookupService.FindSalesOrderHeaderStatusListItemModel();
model.UserList = MembershipManagementService.FindUserListItemModel();
model.PaymentTermsList = LookupService.FindPaymentTermsListItemModel(model.CurrentCompany);
if (model.SaleTemp.CustomerId != null)
{
model.CreditCardList = CustomerService.FindCreditCardsListItemModel(model.CurrentCompany, model.SaleTemp.CustomerId.Value);
}
model.FreightCarrierList = LookupService.FindFreightCarriersListItemModel(model.CurrentCompany);
model.FreightTermList = LookupService.FindLOVItemsListItemModel(model.CurrentCompany, LOVName.FreightTerm);
model.MethodSignedList = LookupService.FindMethodSignedListItemModel();
}
public void LockUserTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
// Create a record
var model = GetTestUser(true, false);
var error = MembershipManagementService.InsertOrUpdateUser(model, testUser, "");
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
// Get the current Lock
string lockGuid = MembershipManagementService.LockUser(model);
Assert.IsTrue(!string.IsNullOrEmpty(lockGuid), "Error: Lock record was not found");
// Simulate another user updating the record
var otherUser = GetTestUser();
error = MembershipManagementService.InsertOrUpdateUser(model, otherUser, lockGuid);
Assert.IsTrue(!error.IsError, error.Message);
// Now get the first user to update the record
error = MembershipManagementService.InsertOrUpdateUser(model, testUser, 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 = MembershipManagementService.LockUser(model);
error = MembershipManagementService.InsertOrUpdateUser(model, testUser, lockGuid);
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
}
public ActionResult GetUserList()
{
var items = MembershipManagementService.FindUserListItemModel();
items.Insert(0, new ListItemModel(EvolutionResources.strAll, "0"));
return(Json(items, JsonRequestBehavior.AllowGet));
}
public ActionResult SelectCompany(int id)
{
int errorCode = 0;
MembershipManagementService.SaveProperty(MMSProperty.CurrentCompany, id);
return(Json(errorCode, JsonRequestBehavior.AllowGet));
}
public void FindNoReplyMailSenderUserTest()
{
var user = MembershipManagementService.FindNoReplyMailSenderUser();
Assert.IsTrue(user != null, "Error: A NULL value was returned when an object was expected");
Assert.IsTrue(user.EMail.IsValidEMail(), $"Error: EMail '{user.EMail}' was returned when a valid EMail address was expected");
}
void prepareEditModel(EditPurchaseOrderHeaderTempViewModel model, int id)
{
var poht = PurchasingService.FindPurchaseOrderHeaderTempModel(id, CurrentCompany, false);
PrepareViewModel(model, EvolutionResources.bnrAddEditPurchase + " - " + EvolutionResources.lblOrderNumber + ": " + model.PurchaseTemp.OrderNumber.ToString(), id, MakeMenuOptionFlags(0, poht.OriginalRowId, 0) + MenuOptionFlag.RequiresNewPurchase);
model.ParentId = id;
// Get the landing date from the Shipment record
if (model.PurchaseTemp.OrderNumber != null)
{
var shipmentContent = ShipmentService.FindShipmentContentByPONoModel(CurrentCompany, model.PurchaseTemp.OrderNumber.Value);
if (shipmentContent != null && shipmentContent.ShipmentId != null)
{
var shipment = ShipmentService.FindShipmentModel(shipmentContent.ShipmentId.Value, CurrentCompany);
}
}
model.LocationList = LookupService.FindLocationListItemModel(model.CurrentCompany);
model.SupplierList = SupplierService.FindSupplierListItemModel(CurrentCompany);
model.POStatusList = LookupService.FindPurchaseOrderHeaderStatusListItemModel();
model.UserList = MembershipManagementService.FindUserListItemModel();
model.PaymentTermsList = LookupService.FindPaymentTermsListItemModel(model.CurrentCompany);
model.CommercialTermsList = LookupService.FindLOVItemsListItemModel(model.CurrentCompany, LOVName.CommercialTerms);
model.PortList = LookupService.FindPortsListItemModel();
model.ShipMethodList = LookupService.FindLOVItemsListItemModel(model.CurrentCompany, LOVName.ShippingMethod);
model.ContainerTypeList = LookupService.FindContainerTypeListItemModel();
model.FreightForwarderList = LookupService.FindFreightForwardersListItemModel(model.CurrentCompany);
model.CurrencyList = LookupService.FindCurrenciesListItemModel();
model.BrandCategoryList = ProductService.FindBrandCategoryListItemModel(model.CurrentCompany);
}
void prepareEditModel(EditProductViewModel model, int id)
{
PrepareViewModel(model, EvolutionResources.bnrAddEditProduct + (model.Product.Id > 0 ? " - " + model.Product.ItemName : ""), id, MakeMenuOptionFlags(0, 0, 0, 0, model.Product.Id) + MenuOptionFlag.RequiresNewProduct);
model.ProductAvailabilityList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.ProductAvailability);
model.MaterialList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.Material);
model.ABList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.AB);
model.UserList = MembershipManagementService.FindUserListItemModel();
model.ProductStatusList = new List <ListItemModel>();
foreach (var item in LookupService.FindLOVItemsModel(null, LOVName.ProductStatus))
{
model.ProductStatusList.Add(new ListItemModel {
Id = item.ItemValue1, Text = item.ItemText
});
}
model.WebCategoryList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.WebCategory);
model.WebSubCategoryList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.WebSubCategory);
model.MediaPath = MediaServices.GetProductImageFolder(true);
var bc = new Evolution.BarCodeService.BarCodeService(db);
model.Product.BarCodeFile1 = bc.GetBarCode(model.Product.BarCode, true);
model.Product.BarCodeFile2 = bc.GetBarCode(model.Product.InnerBarCode, true);
model.Product.BarCodeFile3 = bc.GetBarCode(model.Product.MasterBarCode, true);
}
private void prepareEditModel(EditTaskViewModel model)
{
model.BusinessUnitList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.BusinessUnit);
model.TaskTypeList = LookupService.FindLOVItemsListItemModel(null, LOVName.TaskType);
model.StatusList = LookupService.FindLOVItemsListItemModel(null, LOVName.TaskStatus);
model.UserList = MembershipManagementService.FindUserListItemModel();
}
protected void PrepareViewModel(ViewModelBase model,
string pageTitle, int currentItemId = 0, int objectFlags = 0)
{
model.PageTitle = pageTitle;
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.AddProperty("id", currentItemId);
UserModel user = MembershipManagementService.User;
if (user != null)
{
model.DisplayDateFormat = user.DateFormat;
model.JQDateFormat = user.DateFormat.ToLower().Replace("yyyy", "yy");
dict.AddProperty("USERNAME", user.Name.Replace(".", " ").WordCapitalise());
}
else
{
dict.AddProperty("USERNAME", "");
}
var tempAreaName = this.ControllerContext.RouteData.DataTokens["area"];
var areaName = (tempAreaName == null ? "" : tempAreaName.ToString() + ":");
var controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
// Object flags are:
// 1 Requires Customer
// 2 Requires Purchase
// 4
// 8
// 16 Requires Product
// 32 Requires no product
model.Menu = MenuService.GetMenu(0,
MembershipManagementService.IsLoggedIn,
MembershipManagementService.FindUserRoles(),
objectFlags,
areaName + controllerName,
dict);
// Get the company list
model.AvailableCompanies = CompanyService.FindCompaniesListItemModel();
int selectedCompanyId = MembershipManagementService.GetProperty(MMSProperty.CurrentCompany, -1);
if (selectedCompanyId == -1)
{
// No company selected, so use the first in the list
if (model.AvailableCompanies.Count() > 0)
{
selectedCompanyId = Convert.ToInt32(model.AvailableCompanies.First().Id);
}
}
if (selectedCompanyId > 0)
{
model.CurrentCompany = CompanyService.FindCompanyModel(selectedCompanyId);
model.MarginLogo = model.CurrentCompany.MarginLogo;
}
}
public ActionResult OverrideMSQ(int id)
{
// Provides the override MSQ dialog
var model = new OverrideMSQViewModel();
model.SalesOrderHeaderTempId = id;
model.UserList = MembershipManagementService.FindUsersInGroup("SuperUser");
return(View("OverrideMSQ", model));
}
public void UserIdTest()
{
// Test that the service returns the same value as that of a direct call
// to the thread current principal
string userId1 = Thread.CurrentPrincipal.Identity.Name;
string userId2 = MembershipManagementService.UserId(true);
Assert.IsTrue(userId1 == userId2, $"Error: {userId2} was returned when {userId1} was expected");
}
public List <UserModel> FindOrderPurchasers(PurchaseOrderHeaderModel poh,
CompanyModel company,
decimal poNumber,
ref string errorMsg)
{
// Given a PurchaseOrderHeader model, finds the sales person (purchaser)
// for the order and returns a list of all the users in the same user
// group as the sales person, including the sales person.
List <UserModel> users = null;
UserModel salesPerson = null;
if (poh.SalespersonId != null)
{
salesPerson = MembershipManagementService.FindUserModel(poh.SalespersonId.Value);
}
if (salesPerson != null)
{
// Found the sales person
BrandCategoryModel brandCat = null;
if (poh.BrandCategoryId != null)
{
brandCat = ProductService.FindBrandCategoryModel(poh.BrandCategoryId.Value, company, false);
}
if (brandCat != null)
{
string groupName = brandCat.CategoryName.ToLower() + " purchasing";
var userGroup = MembershipManagementService.FindGroupsForUser(salesPerson)
.Where(ug => ug.GroupName.ToLower().Contains(groupName))
.FirstOrDefault();
if (userGroup != null)
{
// Found the group, so get all the users in the group, including the sales person
users = MembershipManagementService.FindUsersInGroup(userGroup);
if (users.Count() == 0)
{
errorMsg = $"Error: Active Directory User Group '{groupName}' has no members!";
users = null;;
}
}
else
{
errorMsg = $"Error: Failed to find Active Directory Group '{groupName}' !";
}
}
else
{
errorMsg = $"Error: Failed to find a Brand Catgeory for Purchase Order Number {poNumber} !";
}
}
else
{
errorMsg = $"Error: Failed to find a Sales Person for Purchase Order Number {poNumber} !";
}
return(users);
}
public ActionResult MyOptions()
{
var model = new EditUserViewModel();
model.UserData = MembershipManagementService.User;
prepareEditModel(model, model.UserData.Id);
model.LGS = MembershipManagementService.LockUser(model.UserData);
return(View("MyOptions", model));
}
public void FindUserByAliasNameTest()
{
var testUser = GetTestUser();
// Create UserAlias & add it to the db (to be able to search by UserAlias.Name)
UserAliasModel model = createUserAlias(testUser);
MembershipManagementService.InsertOrUpdateUserAlias(model, testUser, "");
UserModel user = MembershipManagementService.FindUserByAliasName(model.Name);
AreEqual(testUser, user);
}
public void IsUserInRoleTest()
{
// This will be superceded with AD
bool result = MembershipManagementService.IsUserInRole("ABD,DEF,Dom");
Assert.IsFalse(result, "Error: True was returned when False was expected (1)");
result = MembershipManagementService.IsUserInRole(UserRole.Administrator);
Assert.IsTrue(result, "Error: False was returned when True was expected (2)");
result = MembershipManagementService.IsUserInRole(UserRole.SuperUser);
Assert.IsTrue(result, "Error: False was returned when True was expected (3)");
result = MembershipManagementService.IsUserInRole(UserRole.AllUsers);
Assert.IsTrue(result, "Error: False was returned when True was expected (4)");
}
public Error CheckCompanyForPassedUnpackDates(CompanyModel company)
{
var error = new Error();
foreach (var undeliveredOrder in PurchasingService.FindUndeliveredPurchaseOrders(company).Items)
{
string errorMsg = "";
var users = PurchasingService.FindOrderPurchasers(undeliveredOrder,
company,
undeliveredOrder.OrderNumber.Value,
ref errorMsg);
if (users == null)
{
WriteTaskLog(errorMsg, LogSeverity.Severe);
}
else
{
// Send an email
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.AddProperty("PURCHASEORDERNO", undeliveredOrder.OrderNumber.ToString());
dict.AddProperty("COMPANYNAME", company.FriendlyName);
var purchaser = MembershipManagementService.FindUserModel(undeliveredOrder.SalespersonId.Value);
dict.AddProperty("PURCHASER", (purchaser == null ? "" : purchaser.FullName));
dict.AddProperty("REALISTICETA", (undeliveredOrder.RealisticRequiredDate == null ?
"" :
undeliveredOrder.RealisticRequiredDate.Value.ToString(company.DateFormat)));
var supplier = SupplierService.FindSupplierModel(undeliveredOrder.SupplierId.Value);
dict.AddProperty("SUPPLIER", supplier.Name);
string url = GetConfigSetting("SiteHttp", "");
url += "/Purchasing/Purchasing/Edit?id=" + undeliveredOrder.Id.ToString();
dict.AddProperty("URL", url);
error = SendMessage(company,
MembershipManagementService.FindNoReplyMailSenderUser(),
MessageTemplateType.UndeliveredPurchaseNotification,
TaskType.Default,
users,
dict);
}
}
return(error);
}
void prepareEditModel(EditBrandCategorySalesPersonViewModel model, int id, int customerId)
{
var customer = CustomerService.FindCustomerModel(customerId, CurrentCompany);
string title = EvolutionResources.bnrAddEditCustomerAccountManager + (customer == null ? "" : " - " + customer.Name);
if (id <= 0)
{
title += " - " + EvolutionResources.lblNewAddress;
}
PrepareViewModel(model, title, customerId, MakeMenuOptionFlags(customerId, 0));
model.BrandCategoryList = ProductService.FindBrandCategoryListItemModel(model.CurrentCompany);
model.SalesPersonList = MembershipManagementService.FindUserListItemModel();
model.SalesPersonTypeList = LookupService.FindLOVItemsListItemModel(null, LOVName.SalesPersonType);
model.ParentId = customerId;
}
public void FindUserListItemModelTest()
{
// Warning: This test can fail if another test is creating users at the same time
// This occurs because users are global and not specific to an organisation,
// otherwise we segment users off into a separate test organisation.
var user = GetTestUser();
var testCompany = GetTestCompany(user);
var model = MembershipManagementService.FindUserListItemModel();
var dbData = db.FindUsers();
int expected = dbData.Count(),
actual = model.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
// Check that all the items match
foreach (var item in model)
{
var dbItem = dbData.Where(m => m.Id.ToString() == item.Id).FirstOrDefault();
Assert.IsTrue(dbItem != null, "Error: Model item not found in db item list");
var test = MembershipManagementService.MapToModel(dbItem);
AreEqual(item, test);
}
// Add another item a make sure it is found
var newItem = GetTestUser(true, false);
var error = MembershipManagementService.InsertOrUpdateUser(newItem, user, "");
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
model = MembershipManagementService.FindUserListItemModel();
var testItem = model.Where(i => i.Id.ToString() == newItem.Id.ToString()).FirstOrDefault();
Assert.IsTrue(testItem != null, "Error: A NULL value was returned when a non-NULL value was expected");
// Delete it and make sure it disappears
MembershipManagementService.DeleteUser(newItem.Id);
model = MembershipManagementService.FindUserListItemModel();
testItem = model.Where(i => i.Id == newItem.Id.ToString()).FirstOrDefault();
Assert.IsTrue(testItem == null, "Error: A non-NULL value was returned when a NULL value was expected");
}
public void DeleteUserTest()
{
var testUser = GetTestUser();
var dbUser = db.FindUser(testUser.Id);
Assert.IsTrue(dbUser != null, "Error: A NULL value was returned when a non-NULL value was expected (user not found)");
var checkUser = MembershipManagementService.FindUserModel(dbUser.Id);
Assert.IsTrue(checkUser != null, "Error: A NULL value was returned when a non-NULL value was expected (user not found)");
var dbUserModel = MembershipManagementService.MapToModel(dbUser);
AreEqual(checkUser, dbUserModel);
MembershipManagementService.DeleteUser(dbUser.Id);
checkUser = MembershipManagementService.FindUserModel(dbUser.Id);
Assert.IsTrue(checkUser == null, "Error: A non-NULL value was returned when a NULL value was expected (user not deleted)");
}
void prepareEditModel(EditCompanyViewModel model)
{
PrepareViewModel(model, EvolutionResources.bnrAddEditCompany);
model.LogoList = MediaServices.FindCompanyLogos();
model.WarehouseTemplateList = LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.PurchaseOrder, DocumentTemplateType.SendPOtoWarehouse);
model.SupplierTemplateList = LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.PurchaseOrder, DocumentTemplateType.SendPOtoSupplier);
model.FreightForwarderTemplateList = LookupService.FindDocumentTemplatesListItemModel(DocumentTemplateCategory.PurchaseOrder, DocumentTemplateType.SendPOtoFreightForwarder);
model.LocationList = LookupService.FindLocationListItemModel(model.Company);
model.CountryList = LookupService.FindCountriesListItemModel();
model.CurrencyList = LookupService.FindCurrenciesListItemModel();
model.DateFormatList = LookupService.FindDateFormatListItemModel();
model.UnitOfMeasureList = new List <ListItemModel>();
model.UnitOfMeasureList.Add(new ListItemModel(EvolutionResources.lblMetric, ((int)UnitOfMeasure.Metric).ToString()));
model.UnitOfMeasureList.Add(new ListItemModel(EvolutionResources.lblImperial, ((int)UnitOfMeasure.Imperial).ToString()));
model.UserList = MembershipManagementService.FindUserListItemModel();
}
public ActionResult Import(EditDataMappingViewModel model, string command)
{
if (command.ToLower() == "import")
{
var error = ProductService.ValidateProducts(CurrentCompany, CurrentUser, model.Data.Headings);
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
error = ProductService.ImportProducts(CurrentCompany,
CurrentUser,
model.Data.Headings,
MembershipManagementService.GetProperty("ProdImportZip", ""));
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
// Successfully imported, so redirect to purchase orders screen
MembershipManagementService.SaveProperty("ProdImportZip", "");
return(RedirectToAction("Products", "Products", new { Area = "Products" }));
}
}
}
else
{
return(RedirectToAction("Index"));
}
}
public void FindPurchasersListItemModelTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
int itemCount = RandomInt(5, 15);
var testOrder = GetTestPurchaseOrderHeader(testCompany, testUser, itemCount);
var brandCat = ProductService.FindBrandCategoryModel(testOrder.BrandCategoryId.Value, testCompany, false);
string errorMsg = "";
var purchasers = PurchasingService.FindOrderPurchasers(testOrder,
testCompany,
testOrder.OrderNumber.Value,
ref errorMsg);
int expected = 1,
actual = purchasers.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} Purchaser(s) were found when {expected} were expected");
// No add some more users to the same user group as the purchaser
var testPurchaser1 = GetTestUser();
MembershipManagementService.AddUserToGroup(brandCat.CategoryName + " Purchasing", testPurchaser1);
var testPurchaser2 = GetTestUser();
MembershipManagementService.AddUserToGroup(brandCat.CategoryName + " Purchasing", testPurchaser2);
purchasers = PurchasingService.FindOrderPurchasers(testOrder,
testCompany,
testOrder.OrderNumber.Value,
ref errorMsg);
expected = 3;
actual = purchasers.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} Purchaser(s) were found when {expected} were expected");
}
public void SavePropertyTest()
{
var user = GetTestUser();
MembershipManagementService.User = user; // So we save properties against this user
for (int i = 1; i < 50; i++)
{
string propName = "Prop" + i.ToString();
// Set a string value
string propValue1 = RandomString();
MembershipManagementService.SaveProperty(propName, propValue1);
string stringValue = MembershipManagementService.GetProperty(propName, "");
Assert.IsTrue(propValue1 == stringValue, $"Error: Property {propName} returned {stringValue} when {propValue1} was expected");
// Set an int value
int propValue2 = RandomInt();
MembershipManagementService.SaveProperty(propName, propValue2);
int intValue = MembershipManagementService.GetProperty(propName, 0);
Assert.IsTrue(propValue2 == intValue, $"Error: Property {propName} returned {intValue} when {propValue2} was expected");
// set a date-time value
DateTime propValue3 = RandomDateTime();
MembershipManagementService.SaveProperty(propName, propValue3);
DateTime dateTimeValue = MembershipManagementService.GetProperty(propName, new DateTime(1900, 1, 1, 0, 0, 0));
// We compare the strings because the date values are sub-millisecond different
Assert.IsTrue(propValue3.ToString() == dateTimeValue.ToString(), $"Error: Property {propName} returned {dateTimeValue} when {propValue3} was expected");
}
}
public void FindUndeliveredPurchaseOrders2Test()
{
// Tests the TaskProcessor/emails
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
// Get the current email queue count
db.EmptyEMailQueue();
int beforeCount = db.FindEMailQueues().Count();
var task = new NotificationTask(db);
task.StartTask();
int afterCount = db.FindEMailQueues().Count();
Assert.IsTrue(afterCount == beforeCount, $"Error: The EMail queue contains {afterCount} item(s) when {beforeCount} were expected (1)");
// Create some orders
var order1 = GetTestPurchaseOrderHeader(testCompany, testUser, 10);
var order2 = GetTestPurchaseOrderHeader(testCompany, testUser, 10);
task.CheckCompanyForPassedUnpackDates(testCompany);
// The orders are not overdue, so we should not have added any messages to the email queue
afterCount = db.FindEMailQueues().Count();
Assert.IsTrue(afterCount == beforeCount, $"Error: The EMail queue contains {afterCount} item(s) when {beforeCount} were expected (2)");
// Now move the RealisticRequiredDate back so that the orders are overdue
order1.RealisticRequiredDate = DateTimeOffset.Now.AddDays(RandomInt(1, 10) * -1);
string lockGuid = PurchasingService.LockPurchaseOrderHeader(order1);
PurchasingService.InsertOrUpdatePurchaseOrderHeader(order1, testUser, lockGuid);
beforeCount = db.FindEMailQueues().Count();
var error = task.CheckCompanyForPassedUnpackDates(testCompany);
Assert.IsTrue(!error.IsError, error.Message);
// We should have added a message to the email queue
afterCount = db.FindEMailQueues().Count();
int expected = 1 + beforeCount;
Assert.IsTrue(afterCount == expected, $"Error: The EMail queue contains {afterCount} item(s) when {expected} were expected (3)");
// Now move the other order back
order2.RealisticRequiredDate = DateTimeOffset.Now.AddDays(RandomInt(1, 10) * -1);
lockGuid = PurchasingService.LockPurchaseOrderHeader(order2);
PurchasingService.InsertOrUpdatePurchaseOrderHeader(order2, testUser, lockGuid);
beforeCount = db.FindEMailQueues().Count() - beforeCount;
task.CheckCompanyForPassedUnpackDates(testCompany);
// We should have added two messages
afterCount = db.FindEMailQueues().Count();
expected = 2 + beforeCount;
Assert.IsTrue(afterCount == expected, $"Error: The EMail queue contains {afterCount} item(s) when {expected} were expected (4)");
// Now add another sales person to the user groups of the orders.
// Note that each order could be a different brand category/group
var testUser2 = GetTestUser();
var brandCategory = ProductService.FindBrandCategoryModel(order1.BrandCategoryId.Value, testCompany, false);
MembershipManagementService.AddUserToGroup(brandCategory.CategoryName + " Purchasing", testUser2);
brandCategory = ProductService.FindBrandCategoryModel(order2.BrandCategoryId.Value, testCompany, false);
MembershipManagementService.AddUserToGroup(brandCategory.CategoryName + " Purchasing", testUser2);
beforeCount = db.FindEMailQueues().Count();
task.CheckCompanyForPassedUnpackDates(testCompany);
// We should have added another 4 messages
afterCount = db.FindEMailQueues().Count();
expected = 2 + beforeCount;
Assert.IsTrue(afterCount == expected, $"Error: The EMail queue contains {afterCount} item(s) when {expected} were expected (5)");
// Put the orders forward
order1.RealisticRequiredDate = DateTimeOffset.Now.AddDays(RandomInt(1, 10));
lockGuid = PurchasingService.LockPurchaseOrderHeader(order1);
PurchasingService.InsertOrUpdatePurchaseOrderHeader(order1, testUser, lockGuid);
order2.RealisticRequiredDate = DateTimeOffset.Now.AddDays(RandomInt(1, 10));
lockGuid = PurchasingService.LockPurchaseOrderHeader(order2);
PurchasingService.InsertOrUpdatePurchaseOrderHeader(order2, testUser, lockGuid);
beforeCount = db.FindEMailQueues().Count();
task.CheckCompanyForPassedUnpackDates(testCompany);
// We should not have added any more messages
afterCount = db.FindEMailQueues().Count();
expected = 0 + beforeCount;
Assert.IsTrue(afterCount == expected, $"Error: The EMail queue contains {afterCount} item(s) when {expected} were expected (6)");
task.EndTask(0);
}
private Error BuildRecipientLists(string selectedIds,
CustomerContactModel contact,
CompanyModel company, CustomerModel customer,
bool bSaveAsContact,
List <UserModel> toUsers, List <UserModel> ccUsers)
{
// SelectedIds is supplied as a comma separated list:
// To:123,CC:-345,To:OTH
// Where:
// A prefix of 'To' denotes a recipient
// A prefix of 'Cc' denotes a user to 'cc' to
// A positive number represents an id of a CustomerContact record
// A negative number represents the id of a User record (multiply it by -1 to get the positive value)
// OTH indicates that the details for 'Other User' should be retrieved from parameter: contact
// The method returns two lists of UserModels, one for 'To' and one for 'cc' recipients.
var error = new Error();
var selected = selectedIds.ToLower().Split(',');
foreach (var recipient in selected)
{
var pos = recipient.IndexOf(":");
if (pos != -1)
{
UserModel user = null;
var recType = recipient.Substring(0, pos).ToLower();
var recId = recipient.Substring(pos + 1).ToLower();
if (recId == "oth")
{
// New contact
if (bSaveAsContact)
{
contact.CompanyId = company.Id;
contact.Enabled = true;
error = CustomerService.InsertOrUpdateCustomerContact(contact, user, "");
}
else
{
error = CustomerService.ValidateContactModel(contact);
}
if (error.IsError)
{
break;
}
else
{
user = new UserModel {
FirstName = contact.ContactFirstname,
LastName = contact.ContactSurname,
EMail = contact.ContactEmail
};
}
}
else
{
var id = Convert.ToInt32(recId);
if (Convert.ToInt32(id) < 0)
{
// User
user = MembershipManagementService.FindUserModel(Math.Abs(id));
}
else
{
// Contact
var temp = CustomerService.FindCustomerContactModel(id, company, customer, false);
if (temp != null)
{
user = new UserModel {
FirstName = temp.ContactFirstname,
LastName = temp.ContactSurname,
EMail = temp.ContactEmail
}
}
;
}
}
if (user != null)
{
if (recType == "to")
{
toUsers.Add(user);
}
else
{
ccUsers.Add(user);
}
}
}
}
return(error);
}
}
private Error processPurchaseOrder(PurchaseOrderHeader poh,
FileTransferConfigurationModel template,
FileRecipient fileRecipient)
{
var error = new Error();
// Load the template configuration file
string configFile = getTemplateFileName(template),
tempFile = "",
zipFile = "";
XElement doc = XElement.Load(configFile);
var file = doc.Element("File");
error = createPurchaseOrderDataFile(poh, file, ref tempFile);
if (!error.IsError)
{
// Check if the file is compressed individually and sent
bool bCompress = file.Attribute("CompressFile").Value.ParseBool();
if (bCompress)
{
// File is to be compressed
zipFile = tempFile.ChangeExtension(".zip");
error = Zip.ZipFile(tempFile, zipFile);
if (error.IsError)
{
FileManagerService.FileManagerService.DeleteFile(zipFile);
}
else
{
tempFile = zipFile;
}
}
bool bDelTempFile = true;
if (!error.IsError)
{
if (file.Attribute("FTPFile").Value.ParseBool())
{
// Copy the file to the FTP pickup folder
error = moveFileToFTPFolder(tempFile, template.SourceFolder, poh.OrderNumber + (bCompress ? ".zip" : ".txt"));
}
if (!error.IsError && file.Attribute("EMailFile").Value.ParseBool())
{
// Queue the file to be sent as an email
var company = CompanyService.FindCompanyModel(poh.CompanyId);
var purchaser = MembershipManagementService.FindUserModel(poh.SalespersonId.Value);
string email = "";
if (fileRecipient == FileRecipient.FreightForwarder)
{
var fforwarder = LookupService.FindFreightForwarderModel(poh.FreightForwarderId.Value);
if (string.IsNullOrEmpty(fforwarder.Email))
{
error.SetError(EvolutionResources.errCantSendEMailToBlankFreightForwarderAddress);
}
else
{
email = fforwarder.Email;
}
}
else
{
error.SetError(EvolutionResources.errEMailingWarehouseNotSupported);
}
if (!error.IsError)
{
var recipient = new UserModel {
EMail = email
};
var message = new EMailMessage(purchaser, recipient, MessageTemplateType.PurchaseOrderNotificationFF);
EMailService(company).AddOrganisationDetails(message.Dict);
EMailService().AddUserDetails(purchaser, message.Dict);
message.AddProperty("PURCHASEORDERNO", poh.OrderNumber.Value);
message.AddAttachment(tempFile);
error = EMailService().SendEMail(message);
if (!error.IsError)
{
bDelTempFile = false;
}
}
}
}
if (bDelTempFile)
{
FileManagerService.FileManagerService.DeleteFile(tempFile);
}
}
return(error);
}
public ActionResult Save(EditSalesOrderHeaderTempViewModel model, string command)
{
switch (command.ToLower())
{
case "save":
// Save the screen data back to the temp tables, then copy to live tables and exit
if (ModelState.IsValid)
{
adjustDates(model.SaleTemp, model.TZ);
var modelError = new Error();
var items = SalesService.FindSalesOrderDetailTempsListModel(CurrentCompany.Id, model.SaleTemp.Id, 0, 1, 9999, "");
if (items.Items.Count() == 0)
{
prepareEditModel(model, model.SaleTemp.Id);
model.SetErrorOnField(ErrorIcon.Error,
EvolutionResources.errCantSaveSaleWithNoLines,
"SaleTemp_EndUserName");
return(View("Edit", model));
}
else
{
modelError = SalesService.InsertOrUpdateSalesOrderHeaderTemp(model.SaleTemp, CurrentUser, model.LGST, false);
if (modelError.IsError)
{
prepareEditModel(model, model.SaleTemp.Id);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"SaleTemp_" + modelError.FieldName);
return(View("Edit", model));
}
else
{
// Copy the temp tables back to the main tables
modelError = SalesService.CopyTempToSalesOrderHeader(model.SaleTemp.Id, CurrentUser, model.LGS);
if (modelError.IsError)
{
prepareEditModel(model, model.SaleTemp.Id);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"SaleTemp_" + modelError.FieldName);
}
else
{
if (model.SaleTemp.OverrideApproverId != null)
{
// Send override approbal notification
var sohm = SalesService.FindSalesOrderHeaderModel(modelError.Id, CurrentCompany, false);
SalesService.SendMSQOverrideEMail(CurrentCompany,
CurrentUser,
MembershipManagementService.FindUserModel(model.SaleTemp.OverrideApproverId.Value),
sohm);
// Update the temp record so that we don't send a second approval email
model.SaleTemp.OverrideApproverId = null;
SalesService.InsertOrUpdateSalesOrderHeaderTemp(model.SaleTemp, CurrentUser,
SalesService.LockSalesOrderHeaderTemp(model.SaleTemp),
false);
}
return(RedirectToAction("Sales"));
}
}
}
}
prepareEditModel(model, model.SaleTemp.Id);
return(View("Edit", model));
default:
return(RedirectToAction("Sales"));
}
}
