private void StartBackGroundRefresh(ISupplierData supplierData)
{
ProvinceDto1 = supplierData.ProvinceDtos;
CountryDto1 = supplierData.CountryDtos;
ProvinceDto2 = supplierData.ProvinceDtos;
CountryDto2 = supplierData.CountryDtos;
ProvinceDto3 = supplierData.ProvinceDtos;
CountryDto3 = supplierData.CountryDtos;
CountryDto1 = supplierData.CountryDtos;
CityDto3 = supplierData.CityDtos;
CityDto1 = supplierData.CityDtos;
CityDto2 = supplierData.CityDtos;
PaymentDtos = supplierData.PaymentDtos;
MonthsDtos = supplierData.MonthsDtos;
MonthsDtos2 = supplierData.MonthsDtos;
BanksDtos = supplierData.BanksDtos;
LanguageDtos = supplierData.LanguageDtos;
CurrencyDtos = supplierData.CurrencyDtos;
Account1Dtos = supplierData.AccountDtos;
Account2Dtos = supplierData.AccountDtos;
Account3Dtos = supplierData.AccountDtos;
Account4Dtos = supplierData.AccountDtos;
Account5Dtos = supplierData.AccountDtos;
Account6Dtos = supplierData.AccountDtos;
Account7Dtos = supplierData.AccountDtos;
Account8Dtos = supplierData.AccountDtos;
}
public override async Task <ISupplierData> CreateSupplierAsync(SupplierDto dto)
{
ISupplierData data = await _services.GetSupplierDataServices().GetAsyncSupplierDo(dto.NUM_PROVEE).ConfigureAwait(false);
data.Value = dto;
return(data);
}
public override async Task <ISupplierData> CreateSupplierAsync(SupplierViewObject viewObject)
{
ISupplierData data = await _services.GetSupplierDataServices().GetAsyncSupplierDo(viewObject.NUM_PROVEE).ConfigureAwait(false);
data.Value = viewObject;
return(data);
}
private void InitializationDataObjectOnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (sender is ISupplierData)
{
ISupplierData supplierData = (ISupplierData)sender;
DataObject = supplierData;
}
}
private void StartRefresh(ISupplierData supplierData)
{
SupplierTypeDto1 = supplierData.Type;
ProvinceDto = supplierData.ProvinceDtos;
CityDto = supplierData.CityDtos;
OfficeDtos = supplierData.OfficeDtos;
CompanyDtos = supplierData.CompanyDtos;
}
public ProductController(
IProductData productData,
ICategoryData categoryData,
ISupplierData supplierData)
{
_productData = productData;
_categoryData = categoryData;
_supplierData = supplierData;
}
public ProductControllerTests()
{
_productList = new List <ProductDto>
{
new ProductDto {
ProductId = 1, ProductName = "Frutella", CategoryId = 1, SupplierId = 1
},
new ProductDto {
ProductId = 2, ProductName = "Mars", CategoryId = 2, SupplierId = 2
},
new ProductDto {
ProductId = 3, ProductName = "Onion", CategoryId = 3, SupplierId = 3
}
};
var mockProduct = new Mock <IProductData>();
mockProduct
.Setup(service => service.GetAllAsync())
.ReturnsAsync(_productList);
mockProduct
.Setup(service => service.AddAsync(It.IsAny <ProductDto>()))
.Callback((ProductDto product) => _productList.Add(product))
.Returns((ProductDto product) => Task.FromResult(product));
mockProduct
.Setup(service => service.GetAsync(It.IsAny <int>()))
.Returns((int id) => Task.FromResult(_productList.Find(p => p.ProductId == id)));
mockProduct
.Setup(service => service.UpdateAsync(It.IsAny <ProductDto>()))
.Returns((ProductDto product) =>
{
var productToUpdate = _productList.Find(p => p.ProductId == product.ProductId);
productToUpdate.ProductName = product.ProductName;
return(Task.FromResult(productToUpdate));
});
_productService = mockProduct.Object;
var mockSupplier = new Mock <ISupplierData>();
mockSupplier.Setup(service => service.GetAllAsync())
.ReturnsAsync(new List <SupplierDto>());
_supplierService = mockSupplier.Object;
var mockCategory = new Mock <ICategoryData>();
mockCategory.Setup(service => service.GetAllAsync())
.ReturnsAsync(new List <CategoryDto>());
_categoryService = mockCategory.Object;
}
public async Task <bool> DeleteAsyncSupplierDo(ISupplierData data)
{
var retValue = false;
var supplierId = data.Value.NUM_PROVEE;
if (!string.IsNullOrEmpty(supplierId))
{
retValue = await data.DeleteAsyncData();
}
return(retValue);
}
public async Task Should_Insert_And_Save_A_Supplier()
{
string id = _supplierDataServices.GetNewId();
ISupplierData data = _supplierDataServices.GetNewSupplierDo(id);
SupplierViewObject viewObject = data.Value;
viewObject.NOMBRE = "GenericSupplier";
data.Value = viewObject;
bool value = await _supplierDataServices.Save(data);
Assert.True(value);
}
/// <summary>
/// This adds a primary and a payload
/// </summary>
/// <param name="primaryKeyValue">PrimaryKey</param>
/// <param name="payload">Data payload to be loaded</param>
/// <param name="insertable">Is an insert operation</param>
private void Init(string primaryKeyValue, DataPayLoad payload, bool insertable)
{
if (payload.HasDataObject)
{
Logger.Info("ProviderInfoViewModel has received payload type " + payload.PayloadType.ToString());
_supplierData = payload.DataObject as ISupplierData;
DataObject = _supplierData;
if (_supplierData != null)
{
StartRefresh(_supplierData);
StartBackGroundRefresh(_supplierData);
}
// EventManager.SendMessage(UpperBarViewSupplierViewModel.Name, payload);
Logger.Info("ProviderInfoViewModel has activated the provider subsystem as current with directive " + payload.PayloadType.ToString());
ActiveSubSystem();
}
}
protected override async Task <DataPayLoad> HandleSaveOrUpdate(DataPayLoad payLoad)
{
bool result = false;
bool isInsert = false;
ISupplierData supplierData = (ISupplierData)payLoad.DataObject;
if (DataServices == null)
{
DataPayLoad nullDataPayLoad = new NullDataPayload();
return(nullDataPayLoad);
}
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.Update:
{
result = await DataServices.GetSupplierDataServices().SaveChanges(supplierData)
.ConfigureAwait(false);
break;
}
case DataPayLoad.Type.Insert:
{
isInsert = true;
result = await DataServices.GetSupplierDataServices().Save(supplierData).ConfigureAwait(true);
break;
}
}
if (result)
{
payLoad.Sender = ToolBarModule.NAME;
payLoad.PayloadType = DataPayLoad.Type.UpdateView;
CurrentPayload = payLoad;
}
else
{
string message = isInsert ? "Error during the insert" : "Error during the update";
OnErrorExecuting?.Invoke(message);
}
return(payLoad);
}
/// <summary>
/// This program loads the data from the data values.
/// </summary>
/// <param name="primaryKeyValue">Primary Key.</param>
/// <param name="isInsertion">Inserted key.</param>
/// <returns></returns>
private async Task <ISupplierData> LoadDataValue(string primaryKeyValue, bool isInsertion)
{
ISupplierData supplier = null;
if (isInsertion)
{
supplier = DataServices.GetSupplierDataServices().GetNewSupplierDo(PrimaryKeyValue);
if (supplier != null)
{
DataObject = supplier;
}
}
else
{
supplier = await DataServices.GetSupplierDataServices().GetAsyncSupplierDo(primaryKeyValue);
DataObject = supplier;
}
return(supplier);
}
/// <summary>
/// Incoming payload . Refactor to the upper master layer.
/// </summary>
/// <param name="dataPayLoad">Payload to be used.</param>
public override void IncomingPayload(DataPayLoad dataPayLoad)
{
DataPayLoad payload = dataPayLoad;
ISupplierData pay = payload.DataObject as ISupplierData;
if (pay == null)
{
return;
} // precondition not null
if (dataPayLoad == null)
{
return;
}
// ignore double insert
if ((dataPayLoad.PayloadType == DataPayLoad.Type.Insert) &&
(PrimaryKeyValue == dataPayLoad.PrimaryKeyValue))
{
return;
}
if (payload != null)
{
if (PrimaryKeyValue.Length == 0)
{
PrimaryKeyValue = payload.PrimaryKeyValue;
_mailBoxName = "Providers." + PrimaryKeyValue + "." + _uniqueCounter;
RegisterMailBox(_mailBoxName);
}
if (PrimaryKeyValue.Length > 0)
{
// check if the message if for me.
if (pay.Value.NUM_PROVEE != PrimaryKeyValue)
{
return;
}
}
// here i can fix the primary key. Consider to move up to the master module.
switch (payload.PayloadType)
{
case DataPayLoad.Type.UpdateData:
{
if (payload.HasDataObject)
{
DataObject = null;
DataObject = payload.DataObject as ISupplierData;
_supplierData = DataObject as ISupplierData;
}
break;
}
case DataPayLoad.Type.UpdateView:
case DataPayLoad.Type.Show:
{
if (!string.IsNullOrEmpty(PrimaryKeyValue))
{
Init(PrimaryKeyValue, payload, false);
// StartAndNotify();
CurrentOperationalState = DataPayLoad.Type.Show;
}
break;
}
case DataPayLoad.Type.Insert:
{
CurrentOperationalState = DataPayLoad.Type.Insert;
if (string.IsNullOrEmpty(PrimaryKeyValue))
{
PrimaryKeyValue =
DataServices.GetSupplierDataServices().GetNewId();
}
Init(PrimaryKeyValue, payload, true);
break;
}
case DataPayLoad.Type.Delete:
{
if (payload.PrimaryKeyValue == PrimaryKeyValue)
{
DeleteEventCleanup(payload.PrimaryKeyValue, PrimaryKeyValue, DataSubSystem.SupplierSubsystem, MasterModuleConstants.ProviderSubsystemName);
DeleteRegion(payload.PrimaryKeyValue);
PrimaryKeyValue = "";
}
break;
}
}
}
}
/// <summary>
/// Create a domain wrapper for the supplier data transfer object.
/// </summary>
/// <param name="viewObject">Data Transfer object</param>
/// <returns></returns>
public virtual async Task <ISupplierData> CreateSupplierAsync(SupplierViewObject viewObject)
{
ISupplierData data = await _services.GetSupplierDataServices().GetAsyncSupplierDo(viewObject.NUM_PROVEE);
return(data);
}
public SuppliersController(ISupplierData repo, IMapper mapper)
{
_repo = repo;
_mapper = mapper;
}
/// <summary>
/// Create a domain wrapper for the supplier data transfer object.
/// </summary>
/// <param name="dto">Data Transfer object</param>
/// <returns></returns>
public virtual async Task <ISupplierData> CreateSupplierAsync(SupplierDto dto)
{
ISupplierData data = await _services.GetSupplierDataServices().GetAsyncSupplierDo(dto.NUM_PROVEE);
return(data);
}
public async Task <bool> SaveChanges(ISupplierData supplierData)
{
var ret = await supplierData.SaveChanges().ConfigureAwait(false);
return(ret);
}
public Task <bool> Save(ISupplierData data)
{
throw new NotImplementedException();
}
protected override async Task <DataPayLoad> HandleSaveOrUpdate(DataPayLoad payLoad)
{
bool result = false;
bool isInsert = false;
ISupplierData supplierData = payLoad.DataObject as ISupplierData;
if (supplierData == null)
{
string message = (payLoad.PayloadType == DataPayLoad.Type.Insert) ? "Error during the insert" : "Error during the update";
OnErrorExecuting?.Invoke(message);
return(new DataPayLoad());
}
if (DataServices == null)
{
DataPayLoad nullDataPayLoad = new NullDataPayload();
return(nullDataPayLoad);
}
var checkedSupplierData = await DataServices.GetSupplierDataServices().GetAsyncSupplierDo(supplierData.Value.NUM_PROVEE);
if (checkedSupplierData.Value == null)
{
payLoad.PayloadType = DataPayLoad.Type.Insert;
}
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.Update:
{
result = await DataServices.GetSupplierDataServices().SaveChanges(supplierData)
.ConfigureAwait(false);
break;
}
case DataPayLoad.Type.Insert:
{
isInsert = true;
result = await DataServices.GetSupplierDataServices().Save(supplierData).ConfigureAwait(true);
break;
}
case DataPayLoad.Type.UpdateInsertGrid:
{
result = true;
if (payLoad.RelatedObject is IEnumerable <BranchesViewObject> )
{
await UpdateGridAsync <BranchesViewObject, ProDelega>(payLoad);
}
else
{
await UpdateGridAsync <ContactsViewObject, ProContactos>(payLoad);
}
break;
}
case DataPayLoad.Type.DeleteGrid:
{
if (payLoad.RelatedObject is IEnumerable <BranchesViewObject> branches)
{
foreach (var branch in branches)
{
if (branch.IsDeleted)
{
// a delete bulk.
result = await DataServices.GetHelperDataServices().ExecuteAsyncDelete <BranchesViewObject, ProDelega>(branch);
}
}
}
ContactsViewObject contactsViewObject = payLoad.RelatedObject as ContactsViewObject;
if (contactsViewObject != null)
{
result = await DataServices.GetHelperDataServices().ExecuteAsyncDelete <ContactsViewObject, ProContactos>(contactsViewObject);
}
break;
}
}
if (result)
{
payLoad.Sender = ToolBarModule.NAME;
payLoad.PayloadType = DataPayLoad.Type.UpdateView;
CurrentPayload = new DataPayLoad();
CurrentPayload.PayloadType = DataPayLoad.Type.UpdateView;
CurrentPayload.DataObject = supplierData;
CurrentPayload.Sender = ToolBarModule.NAME;
CurrentPayload.HasDataObject = true;
CurrentPayload.Subsystem = payLoad.Subsystem;
}
else
{
string message = isInsert ? "Error during the insert" : "Error during the update";
OnErrorExecuting?.Invoke(message);
}
return(payLoad);
}
public Task <bool> SaveChanges(ISupplierData supplierData)
{
throw new NotImplementedException();
}
/// <summary>
/// Save a supplier data.
/// </summary>
/// <param name="data">Data to be saved.</param>
/// <returns></returns>
public async Task <bool> Save(ISupplierData data)
{
bool ret = await data.Save();
return(ret);
}
public Task <bool> DeleteAsyncSupplierDo(ISupplierData data)
{
throw new NotImplementedException();
}
public async Task <bool> SaveChanges(ISupplierData supplierData)
{
bool ret = await supplierData.SaveChanges();
return(ret);
}
