private object[] WithItemCategoryAndManufacturer()
{
IStore store = storeFixture.CreateValid();
var list = GetShoppingListContainingOneItem(store.Id, store.Sections.First().Id);
IManufacturer manufacturer = manufaturerFixture.Create();
IItemCategory itemCategory = itemCategoryFixture.GetItemCategory();
var avavilabilityDef = new StoreItemAvailabilityDefinition
{
StoreId = store.Id,
DefaultSectionId = store.Sections.First().Id
};
var availability = storeItemAvailabilityFixture.Create(avavilabilityDef);
var itemDef = new StoreItemDefinition
{
Id = list.Sections.First().Items.First().Id,
ItemCategoryId = itemCategory.Id,
ManufacturerId = manufacturer.Id,
Availabilities = availability.ToMonoList()
};
IStoreItem item = storeItemFixture.Create(itemDef);
var listReadModel = ToSimpleReadModel(list, store, item, itemCategory, manufacturer);
return(new object[]
{
list,
store,
item.ToMonoList(),
itemCategory.ToMonoList(),
manufacturer.ToMonoList(),
listReadModel
});
}
public async Task <StoreItemReadModel> ConvertAsync(IStoreItem item, CancellationToken cancellationToken)
{
if (item is null)
{
throw new System.ArgumentNullException(nameof(item));
}
IItemCategory itemCategory = null;
IManufacturer manufacturer = null;
if (item.ItemCategoryId != null)
{
itemCategory = await itemCategoryRepository.FindByAsync(item.ItemCategoryId, cancellationToken);
if (itemCategory == null)
{
throw new DomainException(new ItemCategoryNotFoundReason(item.ItemCategoryId));
}
}
if (item.ManufacturerId != null)
{
manufacturer = await manufacturerRepository.FindByAsync(item.ManufacturerId, cancellationToken);
if (manufacturer == null)
{
throw new DomainException(new ManufacturerNotFoundReason(item.ManufacturerId));
}
}
var storeIds = item.Availabilities.Select(av => av.StoreId);
var storeDict = (await storeRepository.FindByAsync(storeIds, cancellationToken))
.ToDictionary(store => store.Id);
return(ToReadModel(item, itemCategory, manufacturer, storeDict));
}
public StoreItemReadModel ToReadModel(IStoreItem model, IItemCategory itemCategory,
IManufacturer manufacturer, Dictionary <StoreId, IStore> stores)
{
var availabilityReadModels = new List <StoreItemAvailabilityReadModel>();
foreach (var av in model.Availabilities)
{
var store = stores[av.StoreId];
var section = store.Sections.First(s => s.Id == av.DefaultSectionId);
availabilityReadModels.Add(av.ToReadModel(store, section));
}
return(new StoreItemReadModel(
model.Id,
model.Name,
model.IsDeleted,
model.Comment,
model.IsTemporary,
model.QuantityType.ToReadModel(),
model.QuantityInPacket,
model.QuantityTypeInPacket.ToReadModel(),
itemCategory?.ToReadModel(),
manufacturer?.ToReadModel(),
availabilityReadModels));
}
public void VerifyStoreAsyncOnce(IItemCategory itemCategory)
{
mock.
Verify(i => i.StoreAsync(
It.Is <IItemCategory>(cat => cat == itemCategory),
It.IsAny <CancellationToken>()),
Times.Once);
}
public void SetupFindByAsync(ItemCategoryId itemCategoryId, IItemCategory returnValue)
{
mock
.Setup(i => i.FindByAsync(
It.Is <ItemCategoryId>(id => id == itemCategoryId),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(returnValue));
}
public StoreItemReadModel ToSimpleReadModel(IStoreItem item, IItemCategory itemCategory,
IManufacturer manufacturer, IStore store)
{
var manufacturerReadModel = manufacturer == null
? null
: new ManufacturerReadModel(
manufacturer.Id,
manufacturer.Name,
manufacturer.IsDeleted);
var itemCategoryReadModel = itemCategory == null
? null
: new ItemCategoryReadModel(
itemCategory.Id,
itemCategory.Name,
itemCategory.IsDeleted);
var section = store.Sections.First();
var storeSectionReadModel = new StoreSectionReadModel(
section.Id,
section.Name,
section.SortingIndex,
section.IsDefaultSection);
var storeReadModel = new StoreItemStoreReadModel(
store.Id,
store.Name,
storeSectionReadModel.ToMonoList());
var availability = item.Availabilities.First();
var availabilityReadModel = new StoreItemAvailabilityReadModel(
storeReadModel,
availability.Price,
storeSectionReadModel);
return(new StoreItemReadModel(
item.Id,
item.Name,
item.IsDeleted,
item.Comment,
item.IsTemporary,
new QuantityTypeReadModel(
(int)item.QuantityType,
item.QuantityType.ToString(),
item.QuantityType.GetAttribute <DefaultQuantityAttribute>().DefaultQuantity,
item.QuantityType.GetAttribute <PriceLabelAttribute>().PriceLabel,
item.QuantityType.GetAttribute <QuantityLabelAttribute>().QuantityLabel,
item.QuantityType.GetAttribute <QuantityNormalizerAttribute>().Value),
item.QuantityInPacket,
new QuantityTypeInPacketReadModel(
(int)item.QuantityTypeInPacket,
item.QuantityTypeInPacket.ToString(),
item.QuantityTypeInPacket.GetAttribute <QuantityLabelAttribute>().QuantityLabel),
itemCategoryReadModel,
manufacturerReadModel,
availabilityReadModel.ToMonoList()));
}
public async Task ValidateAsync(ItemCategoryId itemCategoryId, CancellationToken cancellationToken)
{
if (itemCategoryId is null)
{
throw new ArgumentNullException(nameof(itemCategoryId));
}
IItemCategory itemCategory = await itemCategoryRepository
.FindByAsync(itemCategoryId, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
if (itemCategory == null)
{
throw new DomainException(new ItemCategoryNotFoundReason(itemCategoryId));
}
}
public async Task <IItemCategory> StoreAsync(IItemCategory model,
CancellationToken cancellationToken)
{
var entity = toEntityConverter.ToEntity(model);
if (entity.Id <= 0)
{
dbContext.Entry(entity).State = EntityState.Added;
}
else
{
dbContext.Entry(entity).State = EntityState.Modified;
}
cancellationToken.ThrowIfCancellationRequested();
await dbContext.SaveChangesAsync();
return(toModelConverter.ToDomain(entity));
}
/// <summary>
/// This method get the list of Item Category .
/// </summary>
/// <returns>returns list of category.</returns>
public List <IItemCategory> GetCategoryList()
{
SqlConnection objSQLConn = null;
SqlCommand objSQLCommand = null;
List <IItemCategory> lstCategory = new List <IItemCategory>();
try
{
objSQLConn = new SqlConnection(strConnectionString);
objSQLConn.Open();
objSQLCommand = new SqlCommand("usp_getitemcategory", objSQLConn);
objSQLCommand.CommandType = System.Data.CommandType.StoredProcedure;
SqlDataReader objSQLReader = objSQLCommand.ExecuteReader();
while (objSQLReader.Read())
{
IItemCategory objCategory = ItemCategotyBOFactory.CreateItemCategoryObject();
objCategory.CategoryId = Convert.ToInt32(objSQLReader["CategoryID"]);
objCategory.CategoryName = Convert.ToString(objSQLReader["CategoryName"]);
lstCategory.Add(objCategory);
}
objSQLReader.Close();
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (objSQLConn != null && objSQLConn.State != System.Data.ConnectionState.Closed)
{
objSQLConn.Close();
}
}
return(lstCategory);
}
public async Task <IEnumerable <ItemSearchReadModel> > ConvertAsync(IEnumerable <IStoreItem> items,
IStore store, CancellationToken cancellationToken)
{
var itemCategoryIds = items
.Where(i => i.ItemCategoryId != null)
.Select(i => i.ItemCategoryId)
.Distinct();
var itemCategoryDict = (await itemCategoryRepository.FindByAsync(itemCategoryIds, cancellationToken))
.ToDictionary(i => i.Id);
var manufacturerIds = items
.Where(i => i.ManufacturerId != null)
.Select(i => i.ManufacturerId)
.Distinct();
var manufaturerDict = (await manufacturerRepository.FindByAsync(manufacturerIds, cancellationToken))
.ToDictionary(m => m.Id);
return(items
.Select(item =>
{
IManufacturer manufacturer = item.ManufacturerId == null ? null : manufaturerDict[item.ManufacturerId];
IItemCategory itemCategory = item.ItemCategoryId == null ? null : itemCategoryDict[item.ItemCategoryId];
IStoreItemAvailability storeAvailability = item.Availabilities
.Single(av => av.StoreId == store.Id);
var section = store.Sections.Single(s => s.Id == storeAvailability.DefaultSectionId);
return new ItemSearchReadModel(
item.Id,
item.Name,
item.QuantityType.GetAttribute <DefaultQuantityAttribute>().DefaultQuantity,
storeAvailability.Price,
manufacturer?.ToReadModel(),
itemCategory?.ToReadModel(),
section.ToReadModel());
}));
}
public static ItemCategoryReadModel ToReadModel(this IItemCategory model)
{
return(new ItemCategoryReadModel(model.Id, model.Name, model.IsDeleted));
}
public ItemController(IItem _IItem, IItemCategory _IItemCategory)
{
_Item = _IItem;
_ItemCategory = _IItemCategory;
}
public List <IItem> GenerateInventoryReport(IItemCategory objCategory)
{
List <IItem> itemList = new List <IItem>();
return(itemList);
}
public List<IItem> GenerateInventoryReport(IItemCategory objCategory)
{
List<IItem> itemList = new List<IItem>();
return itemList;
}
public ItemCategoryController(IItemCategory _IItemCategory)
{
_ItemCategory = _IItemCategory;
}
public ItemCategoryViewModel(IItemCategory itemCategory, Action <ItemCategoryViewModel> onDelete)
{
ItemCategory = itemCategory;
Name = itemCategory.CategoryName.Value;
OnDelete = onDelete;
}
private ShoppingListReadModel ToSimpleReadModel(IShoppingList list, IStore store, IStoreItem item,
IItemCategory itemCategory, IManufacturer manufacturer)
{
var manufacturerReadModel = manufacturer == null
? null
: new ManufacturerReadModel(
manufacturer.Id,
manufacturer.Name,
manufacturer.IsDeleted);
var itemCategoryReadModel = itemCategory == null
? null
: new ItemCategoryReadModel(
itemCategory.Id,
itemCategory.Name,
itemCategory.IsDeleted);
var sectionReadModels = list.Sections.Any()
? new ShoppingListSectionReadModel(
list.Sections.First().Id,
store.Sections.First().Name,
store.Sections.First().SortingIndex,
store.Sections.First().IsDefaultSection,
new List <ShoppingListItemReadModel>
{
new ShoppingListItemReadModel(
item.Id,
item.Name,
item.IsDeleted,
item.Comment,
item.IsTemporary,
item.Availabilities.First().Price,
new QuantityTypeReadModel(
(int)item.QuantityType,
item.QuantityType.ToString(),
item.QuantityType.GetAttribute <DefaultQuantityAttribute>().DefaultQuantity,
item.QuantityType.GetAttribute <PriceLabelAttribute>().PriceLabel,
item.QuantityType.GetAttribute <QuantityLabelAttribute>().QuantityLabel,
item.QuantityType.GetAttribute <QuantityNormalizerAttribute>().Value),
item.QuantityInPacket,
new QuantityTypeInPacketReadModel(
(int)item.QuantityTypeInPacket,
item.QuantityTypeInPacket.ToString(),
item.QuantityTypeInPacket.GetAttribute <QuantityLabelAttribute>().QuantityLabel),
itemCategoryReadModel,
manufacturerReadModel,
list.Sections.First().Items.First().IsInBasket,
list.Sections.First().Items.First().Quantity)
})
: null;
return(new ShoppingListReadModel(
list.Id,
list.CompletionDate,
new ShoppingListStoreReadModel(
store.Id,
store.Name),
sectionReadModels != null
? sectionReadModels.ToMonoList()
: Enumerable.Empty <ShoppingListSectionReadModel>()));
}
public List<IItem> GenerateInventoryReport(IItemCategory objCategory)
{
IInventoryManagerDAL objDAL = InventoryManagerDALFactory.CreateInventoryManagerDALObject();
return objDAL.GenerateInventoryReport(objCategory);
}
protected void Page_Load(object sender, EventArgs e)
{
IInventoryManagerBLL objBLL = InventoryManagerBLLFactory.CreateInventoryManagerBLLObject();
IItemCategory objcategory1 = ItemCategotyBOFactory.CreateItemCategoryObject();
//List<IVendor> vendorList = objBLL.GetVendorDetails();
List <IItemCategory> cateogies = new List <IItemCategory>();
int vendorid = Convert.ToInt32(Request.QueryString["VendorID"]);
if (!IsPostBack)
{
cateogies = objBLL.GetItemCategory();
chkVendorItemCategory.DataSource = cateogies;
chkVendorItemCategory.DataTextField = "CategoryName";
chkVendorItemCategory.DataValueField = "CategoryID";
chkVendorItemCategory.DataBind();
if (vendorid != 0)//update
{
IVendor objVendor = VendorBOFactory.CreateVendorObject();
objVendor = objBLL.GetVendorByVendorId(vendorid);
lblMessage2.Text = "Vendor Id is:" + objVendor.VendorId;
vendorid = Convert.ToInt32(Request.QueryString["VendorID"]);
objVendor.VendorId = vendorid;
txtOrganization.Text = Convert.ToString(objVendor.NameOfOrganisation);
objVendor.CategoryList = objBLL.getVendorCategoryList(objVendor.VendorId);
for (int i = 0; i < chkVendorItemCategory.Items.Count; i++)
{
int categoryId = objVendor.CategoryList.Find(delegate(int cID) { return(cID == Convert.ToInt32(chkVendorItemCategory.Items[i].Value)); });
if (categoryId != 0)
{
chkVendorItemCategory.Items[i].Selected = true;
}
}
chkVendorItemCategory.SelectedValue = Convert.ToString(objVendor.CategoryList);
txtName.Text = Convert.ToString(objVendor.NameOfContactPerson);
txtAddress.Text = Convert.ToString(objVendor.Address);
txtEmail.Text = Convert.ToString(objVendor.EmailId);
ddlState.SelectedItem.Text = Convert.ToString(objVendor.State);
ddlState_SelectedIndexChanged(sender, e);
ddlCity.SelectedItem.Text = Convert.ToString(objVendor.City);
txtContact.Text = Convert.ToString(objVendor.ContactNumber);
ddlType.SelectedItem.Text = Convert.ToString(objVendor.VendorType);
}
else//add
{
chkVendorItemCategory.SelectedValue = Convert.ToString(objVendor.CategoryList);
txtOrganization.Text = Convert.ToString(objVendor.NameOfOrganisation);
txtName.Text = Convert.ToString(objVendor.NameOfContactPerson);
txtAddress.Text = Convert.ToString(objVendor.Address);
txtEmail.Text = Convert.ToString(objVendor.EmailId);
ddlState.SelectedValue = Convert.ToString(objVendor.State);
ddlCity.SelectedValue = Convert.ToString(objVendor.City);
txtContact.Text = Convert.ToString(objVendor.ContactNumber);
ddlType.SelectedValue = Convert.ToString(objVendor.VendorType);
}
}
}
public List <IItem> GenerateInventoryReport(IItemCategory objCategory)
{
IInventoryManagerDAL objDAL = InventoryManagerDALFactory.CreateInventoryManagerDALObject();
return(objDAL.GenerateInventoryReport(objCategory));
}
