public IEnumerable <ProviderDTO> GetProvidersByCategory(int?categoryId)
{
var products = GetProductsByCategory(categoryId);
if (categoryId == null)
{
throw new ArgumentNullException();
}
if (products == null)
{
throw new ArgumentException();
}
else
{
List <Provider> providers = new List <Provider>();
foreach (ProductDTO product in products)
{
var provider = UnitOfWork.ProviderRepository.Get((pr => pr.Name == product.ProviderName)).FirstOrDefault();
if (provider != null && !providers.Contains(provider))
{
providers.Add(provider);
}
}
return(ProviderMapper.Map(providers));
}
}
public DBProvider(DBProvider srcData, Predicate <IDataRow> filter,
AggregationMode_t mode = AggregationMode_t.Rejected)
{
Assert(srcData != null);
Assert(filter != null);
m_src = srcData;
m_mapper = new ProviderMapper <IDataRow>(srcData, filter, mode);
}
public bool Update(ProviderModel providerModel)
{
return(LogIfOperationFailed(() =>
{
Provider provider = ProviderMapper.ConvertModelToEntity(providerModel);
_unitOfWork.ProviderRepository.InsertOrUpdate(provider);
_unitOfWork.Commit();
return true;
}, Resources.ExceptionUpdateProvider, providerModel.Name));
}
public ActionResult CreateAppointment()
{
var vm = new CreateAppointmentVM();
var input = new ProviderSearchInput();
var providers = providerService.Search(input);
vm.ProviderIDs = ProviderMapper.MapProviderSearchResult_ProviderIds(providers);
return(View(vm));
}
public void Arrange()
{
_translatorMock = new Mock <ITranslator>();
_translatorMock.Setup(t =>
t.TranslateEnumValue(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync("something");
_mapper = new ProviderMapper(_translatorMock.Object);
_cancellationToken = new CancellationToken();
}
public async Task <ActionResult <PublicApi.v1.DTO.Provider> > GetProvider(int id)
{
var provider = await _bll.Providers.FindAsync(id);
if (provider == null)
{
return(NotFound());
}
return(ProviderMapper.MapFromBLL(provider));
}
private void btnSave_Click(object sender, EventArgs e)
{
string message = String.Empty;
if (tabCtrlItems.SelectedIndex == 0)
{
Dessert dessert = DessertMapper.ReadValues(this.dgwRecipe, this.tbDessertName, true);
if (dessert != null)
{
this.tbDessertName.Clear();
this.dgwRecipe.Rows.Clear();
this.UpdateDataGrid();
message = String.Format("Изделието \"{0}\" е успешно добавено!", dessert.Name);
}
else
{
message = "Не сте попълнили задължителните полета!";
}
}
else if (tabCtrlItems.SelectedIndex == 1)
{
ProductDetail productDetail = ProductDetailMapper.ReadValues(this.tbProductName, this.tbProductUnit, true);
if (productDetail != null)
{
this.tbProductName.Clear();
this.tbProductUnit.Clear();
this.ReloadDataGrid();
message = String.Format("Продуктът \"{0}\" е успешно добавен!", productDetail.Name);
}
else
{
message = "Не сте попълнили задължителните полета!";
}
}
else if (tabCtrlItems.SelectedIndex == 2)
{
Provider provider = ProviderMapper.ReadValues(this.tbProviderName, true);
if (provider != null)
{
this.tbProviderName.Clear();
message = String.Format("Доставчикът \"{0}\" е успешно добавен!", provider.Name);
}
else
{
message = "Не сте попълнили задължителните полета!";
}
}
if (message != String.Empty)
{
MessageBox.Show(this, message, "", MessageBoxButtons.OK);
}
}
public ProviderDTO GetById(int?id)
{
if (id == null)
{
throw new ArgumentNullException();
}
else
{
var provider = UnitOfWork.ProviderRepository.GetById(id);
return(ProviderMapper.Map(provider));
}
}
public ProviderModel GetProvider(int id)
{
return(LogIfOperationFailed(() =>
{
var providerEntity = _unitOfWork.ProviderRepository.Find(id);
//ToDo:Need to implement Automapper
ProviderModel providerModel = ProviderMapper.ConvertEntityToModel(providerEntity);
return providerModel;
}, Resources.ExceptionGetProvider, id));
}
public List <ProviderModel> GetAllProviders()
{
return(LogIfOperationFailed(() =>
{
var providerEntity = _unitOfWork.ProviderRepository.GetAll;
var providerModelList = new List <ProviderModel>();
// ToDo:Need to implement Automapper
providerEntity
.ToList()
.ForEach(m => { providerModelList.Add(ProviderMapper.ConvertEntityToModel(m)); });
return providerModelList;
}, Resources.ExceptionGetForAllProviders));
}
public IEnumerable <ProviderDTO> GetProvidersWithFilter(IEnumerable <PropertyFilterDTO> propertyFilters)
{
if (propertyFilters == null)
{
throw new ArgumentNullException();
}
else
{
Filter <Provider> filter = new Filter <Provider>();
foreach (PropertyFilterDTO propertyFilter in propertyFilters)
{
if (propertyFilter.PropertyId == null)
{
throw new ArgumentNullException();
}
else if (propertyFilter.PropertyId.CompareTo("Id") != 0 && propertyFilter.PropertyId.CompareTo("Name") != 0)
{
throw new ArgumentException();
}
else
{
var type = (new Category()).GetType().GetProperty(propertyFilter.PropertyId).PropertyType;
if (propertyFilter.Value != null && propertyFilter.Value2 != null)
{
var value1 = Convert.ChangeType(propertyFilter.Value, type);
var value2 = Convert.ChangeType(propertyFilter.Value2, type);
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, value1,
value2, propertyFilter.Connector);
}
else if (propertyFilter.Value != null)
{
var value1 = Convert.ChangeType(propertyFilter.Value, type);
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, value1, null, propertyFilter.Connector);
}
else
{
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, propertyFilter.Connector);
}
}
}
var providers = UnitOfWork.ProviderRepository.Get(filter);
return(ProviderMapper.Map(providers));
}
}
// Get One basic table
// DEFAULT CRUD
public ProviderMapper GetProvider(int providerId)
{
var content = db.Providers.FirstOrDefault(p => p.providerId == providerId);
if (content == null)
{
return(null);
}
else
{
ProviderMapper provider = new ProviderMapper
{
ProviderId = content.providerId,
ContactId = content.contactId ?? 0,
CompanyName = content.companyName
};
return(provider);
}
}
public ProviderDTO Create(ProviderDTO dto)
{
if (dto == null)
{
throw new ArgumentNullException();
}
else if (UnitOfWork.ProviderRepository.Get(p => p.Name == dto.Name).FirstOrDefault() != null)
{
throw new ArgumentException("Entity already exist");
}
else
{
var entity = ProviderMapper.Map(dto);
UnitOfWork.ProviderRepository.Insert(entity);
UnitOfWork.Save();
var created = UnitOfWork.ProviderRepository.Get((c => c.Name == dto.Name)).FirstOrDefault();
return(ProviderMapper.Map(created));
}
}
// Get All basic tables
// DEFAULT CRUD
public IEnumerable <ProviderMapper> GetProviders()
{
var content = db.Providers.ToList();
if (content.Count() == 0)
{
return(null);
}
else
{
List <ProviderMapper> providers = new List <ProviderMapper>();
foreach (var item in content)
{
ProviderMapper provider = new ProviderMapper
{
ProviderId = item.providerId,
ContactId = item.contactId ?? 0,
CompanyName = item.companyName
};
providers.Add(provider);
}
return(providers);
}
}
public IServiceResult Search(IServiceInput input)
{
JToken providers = GetProviders();
return(ProviderMapper.MapJTokenToProviderSearchResult(providers));
}
public IEnumerable <ProviderDTO> GetAll()
{
var providers = UnitOfWork.ProviderRepository.Get();
return(ProviderMapper.Map(providers));
}
