public async Task <JsonResult> SaveUnitOfMeasurement(UnitOfMeasurementModel unitOfMeasurementModel)
{
JsonData <JsonStatus> data = new JsonData <JsonStatus>(new JsonStatus());
if (ModelState.IsValid)
{
if (unitOfMeasurementModel.UnitOfMeasurementId > 0)
{
// update record.
if (true == await _unitOfMeasurement.UpdateUnitOfMeasurement(unitOfMeasurementModel))
{
data.Result.Status = true;
}
}
else
{
// add new record.
if (await _unitOfMeasurement.CreateUnitOfMeasurement(unitOfMeasurementModel) > 0)
{
data.Result.Status = true;
}
}
}
return(Json(data));
}
public ProductSKUDto(ProductSKUModel product, UnitOfMeasurementModel uom, CategoryModel category)
{
Id = product.Id;
Code = product.Code;
Name = product.Name;
Description = product.Description;
LasModifiedUtc = product.LastModifiedUtc;
UOMId = uom.Id;
UOMUnit = uom.Unit;
UOM = new UnitOfMeasurementDto(uom);
Category = new CategoryDto(category);
}
private async Task <UnitOfMeasurementModel> AssignValueToModel(Unitofmeasurement unitOfMeasurement)
{
return(await Task.Run(() =>
{
UnitOfMeasurementModel unitOfMeasurementModel = new UnitOfMeasurementModel();
unitOfMeasurementModel.UnitOfMeasurementId = unitOfMeasurement.UnitOfMeasurementId;
unitOfMeasurementModel.UnitOfMeasurementName = unitOfMeasurement.UnitOfMeasurementName;
unitOfMeasurementModel.PreparedByName = null != unitOfMeasurement.PreparedByUser ? unitOfMeasurement.PreparedByUser.UserName : null;
return unitOfMeasurementModel;
}));
}
private void btnEdit_Click(object sender, EventArgs e)
{
if (Convert.ToInt32(lblID.Text) <= 0) return;
var model = new UnitOfMeasurementModel()
{
UnitOfMeasurementId = Convert.ToInt32(lblID.Text),
UnitName = lblName.Text,
Description = lblRemarks.Text
};
var frm = new FrmUnitEntry(model, this);
frm.ShowDialog(this);
}
public async Task <UnitOfMeasurementModel> GetUnitOfMeasurementById(int unitOfMeasurementId)
{
UnitOfMeasurementModel unitOfMeasurementModel = null;
IList <UnitOfMeasurementModel> unitOfMeasurementModelList = await GetUnitOfMeasurementList(unitOfMeasurementId);
if (null != unitOfMeasurementModelList && unitOfMeasurementModelList.Any())
{
unitOfMeasurementModel = unitOfMeasurementModelList.FirstOrDefault();
}
return(unitOfMeasurementModel); // returns.
}
public void Should_Success_Insert_Data()
{
var dbContext = GetDbContext(MethodBase.GetCurrentMethod().ReflectedType.FullName + MethodBase.GetCurrentMethod().Name);
var serviceProvider = GetServiceProviderMock().Object;
var unitOfWork = new UnitOfWork(dbContext, serviceProvider);
var model = new UnitOfMeasurementModel("MTR");
unitOfWork.UOMs.Insert(model);
unitOfWork.Commit();
Assert.True(unitOfWork.UOMs.Get().Count() > 0);
}
public async Task<ActionResult> Edit(UnitOfMeasurementModel unitofmeasurementmodel)
{
if (ModelState.IsValid)
{
await Task.Run(() =>
{
DataContext.Entry(unitofmeasurementmodel).State = EntityState.Modified;
unitofmeasurementmodel.UserID = base.GetCurrentUserID();
DataContext.SaveChanges();
});
return RedirectToAction("Index");
}
return View(unitofmeasurementmodel);
}
public async Task <int> CreateUnitOfMeasurement(UnitOfMeasurementModel unitOfMeasurementModel)
{
int unitOfMeasurementId = 0;
// assign values.
Unitofmeasurement unitOfMeasurement = new Unitofmeasurement();
unitOfMeasurement.UnitOfMeasurementName = unitOfMeasurementModel.UnitOfMeasurementName;
await Create(unitOfMeasurement);
unitOfMeasurementId = unitOfMeasurement.UnitOfMeasurementId;
return(unitOfMeasurementId); // returns.
}
private void btnAdd_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(txtUnitName.Text) || string.IsNullOrWhiteSpace(txtRemarks.Text))
{
ClsCommon.ShowErrorToolTip(txtUnitName, "Please Enter The Unit Name");
}
else
{
var model = new UnitOfMeasurementModel
{
UnitOfMeasurementId = _unitId,
UnitName = txtUnitName.Text,
Description = txtRemarks.Text
};
if (_isNewMode)
{
_unitId = _unitService.Save(model).UnitOfMeasurementId;
if (_unitId <= 0)
{
return;
}
MessageBox.Show(@"Data Saved Successfully", @"Save", MessageBoxButtons.OK,
MessageBoxIcon.Information);
var frm = (FrmUnit)_frmForm;
frm.grdData.Rows.Add(_unitId, model.UnitName, model.Description);
frm.grdData.Rows[frm.grdData.Rows.Count - 1].IsSelected = true;
txtUnitName.Focus();
txtUnitName.Text = "";
txtRemarks.Text = "";
Notify();
}
else
{
var success = _unitService.Update(model);
if (success == null)
{
return;
}
MessageBox.Show(@"Data Updated Successfully", @"Update", MessageBoxButtons.OK,
MessageBoxIcon.Information);
var frm = (FrmUnit)_frmForm;
frm.grdData.CurrentRow.Cells["UnitName"].Value = model.UnitName;
frm.grdData.CurrentRow.Cells["Description"].Value = model.Description;
Close();
Notify();
}
}
}
public async Task<ActionResult> Create(UnitOfMeasurementModel unitofmeasurementmodel)
{
if (ModelState.IsValid)
{
await Task.Run(() =>
{
unitofmeasurementmodel.UserID = base.GetCurrentUserID();
DataContext.UnitsOfMeasurement.Add(unitofmeasurementmodel);
DataContext.SaveChanges();
});
return RedirectToAction("Index");
}
return View(unitofmeasurementmodel);
}
public async Task <bool> UpdateUnitOfMeasurement(UnitOfMeasurementModel unitOfMeasurementModel)
{
bool isUpdated = false;
// get record.
Unitofmeasurement unitOfMeasurement = await GetByIdAsync(w => w.UnitOfMeasurementId == unitOfMeasurementModel.UnitOfMeasurementId);
if (null != unitOfMeasurement)
{
// assign values.
unitOfMeasurement.UnitOfMeasurementName = unitOfMeasurementModel.UnitOfMeasurementName;
isUpdated = await Update(unitOfMeasurement);
}
return(isUpdated); // returns.
}
public void shouldSuccessInstantiate()
{
ProductSKUModel product = new ProductSKUModel("Code", "Name", 1, 1, "Description")
{
Id = 1,
};
UnitOfMeasurementModel uom = new UnitOfMeasurementModel()
{
Id = 1
};
CategoryModel category = new CategoryModel("Name", "Code")
{
};
ProductSKUDto productSKUDto = new ProductSKUDto(product, uom, category)
{
Category = new CategoryDto(new CategoryModel("Name", "Code"))
};
ProductPackingModel productPackingModel = new ProductPackingModel(1, 1, 1, "Code", "Name", "description")
{
};
ProductSKUModel productSKUModel = new ProductSKUModel("Code", "Name", 1, 1, "Description")
{
};
UnitOfMeasurementModel uomModel = new UnitOfMeasurementModel("Unit")
{
};
UnitOfMeasurementModel skuUOM = new UnitOfMeasurementModel();
CategoryModel skuCategory = new CategoryModel();
ProductPackingDto productPackingDto = new ProductPackingDto(productPackingModel, productSKUModel, uomModel, skuUOM, skuCategory);
BarcodeInfo barcode = new BarcodeInfo(productSKUDto, productPackingDto);
Assert.NotNull(barcode);
Assert.Equal("Code", barcode.SKUCode);
Assert.Equal("Name", barcode.SKUName);
Assert.Equal("Code", barcode.PackingCode);
Assert.Equal(1, barcode.PackingSize);
Assert.Equal("Unit", barcode.PackingType);
}
public void Should_Success_Update_Data()
{
var dbContext = GetDbContext(MethodBase.GetCurrentMethod().ReflectedType.FullName + MethodBase.GetCurrentMethod().Name);
var serviceProvider = GetServiceProviderMock().Object;
var unitOfWork = new UnitOfWork(dbContext, serviceProvider);
var model = new UnitOfMeasurementModel("MTR");
unitOfWork.UOMs.Insert(model);
unitOfWork.Commit();
Assert.NotNull(unitOfWork.UOMs.GetByID(model.Id));
model.SetUnit("YDS");
unitOfWork.UOMs.Update(model);
Assert.NotNull(unitOfWork.UOMs.GetByID(model.Id));
}
public Task <int> Create(FormDto form)
{
if (_uomRepository.ReadAll().Any(entity => entity.Unit == form.Unit))
{
var errorResult = new List <ValidationResult>()
{
new ValidationResult("Unit tidak boleh duplikat", new List <string> {
"Unit"
})
};
var validationContext = new ValidationContext(form, _serviceProvider, null);
throw new ServiceValidationException(validationContext, errorResult);
}
var model = new UnitOfMeasurementModel(form.Unit);
return(_uomRepository.InsertAsync(model));
}
public FrmUnitEntry(UnitOfMeasurementModel model, Form frmForm)
{
InitializeComponent();
_frmForm = frmForm;
_unitService = new UnitService();
if (model != null)
{
_isNewMode = false;
_unitId = model.UnitOfMeasurementId;
txtUnitName.Text = model.UnitName;
txtRemarks.Text = model.Description;
btnAdd.Text = @"Update";
}
else
{
_isNewMode = true;
btnAdd.Text = @"Save";
}
}
public UnitOfMeasurementModel Save(UnitOfMeasurementModel model)
{
try
{
using (_context = new HSSNInventoryEntities())
{
var addmodel = new UnitOfMeasurement()
{
UnitName = model.UnitName,
Description = model.Description
};
_context.Entry(addmodel).State = EntityState.Added;
_context.SaveChanges();
model.UnitOfMeasurementId = addmodel.UnitOfMeasurementId;
return(model);
}
}
catch (Exception aException)
{
return(new UnitOfMeasurementModel());
}
}
public UnitOfMeasurementModel Update(UnitOfMeasurementModel model)
{
try
{
using (_context = new HSSNInventoryEntities())
{
var data = _context.UnitOfMeasurements.FirstOrDefault(a => a.UnitOfMeasurementId == model.UnitOfMeasurementId);
if (data != null)
{
data.UnitName = model.UnitName;
data.Description = model.Description;
}
_context.Entry(data).State = EntityState.Modified;
_context.SaveChanges();
return(model);
}
}
catch (Exception e)
{
return(null);
}
}
public DocumentItemDto(ProductSKUInventoryMovementModel item, ProductSKUModel product, UnitOfMeasurementModel uom, CategoryModel category)
{
Product = new ProductSKUDto(product, uom, category);
Quantity = item.Quantity;
Remark = item.Remark;
}
public UnitOfMeasurementDto(UnitOfMeasurementModel uom)
{
Id = uom.Id;
Unit = uom.Unit;
}
public UOMIndexInfo(UnitOfMeasurementModel entity)
{
LastModifiedUtc = entity.LastModifiedUtc;
Unit = entity.Unit;
Id = entity.Id;
}
public ProductPackingDto(ProductPackingModel productPacking, ProductSKUModel product, UnitOfMeasurementModel uom, UnitOfMeasurementModel skuUOM, CategoryModel skuCategory)
{
Id = productPacking.Id;
Code = productPacking.Code;
Name = productPacking.Name;
LasModifiedUtc = productPacking.LastModifiedUtc;
ProductSKU = new ProductSKUDto(product, skuUOM, skuCategory);
UOM = new UnitOfMeasurementDto(uom);
PackingSize = productPacking.PackingSize;
}
public async Task <PartialViewResult> EditUnitOfMeasurement(int unitOfMeasurementId)
{
UnitOfMeasurementModel unitOfMeasurementModel = await _unitOfMeasurement.GetUnitOfMeasurementById(unitOfMeasurementId);
return(PartialView("_AddUnitOfMeasurement", unitOfMeasurementModel));
}
public async Task GetIndex_Return_success()
{
var productPackingRepository = new Mock <IRepository <ProductPackingModel> >();
var productSKURepository = new Mock <IRepository <ProductSKUModel> >();
var unitOfMeasurementRepository = new Mock <IRepository <UnitOfMeasurementModel> >();
var categoryRepository = new Mock <IRepository <CategoryModel> >();
var productPackingModel = new ProductPackingModel(1, 1, 1, "Code", "Name", "description")
{
Id = 1,
Active = true,
};
productPackingRepository.Setup(s => s.ReadAll())
.Returns(new List <ProductPackingModel>()
{
productPackingModel
}.AsQueryable().BuildMock().Object);
var productSKUModel = new ProductSKUModel("Code", "Name", 1, 1, "Description")
{
Id = 1,
Active = true,
};
productSKURepository.Setup(s => s.ReadAll())
.Returns(new List <ProductSKUModel>()
{
productSKUModel
}.AsQueryable().BuildMock().Object);;
var unitOfMeasurementModel = new UnitOfMeasurementModel("Unit")
{
Id = 1,
Active = true
};
unitOfMeasurementRepository.Setup(s => s.ReadAll())
.Returns(new List <UnitOfMeasurementModel>()
{
unitOfMeasurementModel
}.AsQueryable().BuildMock().Object);
var service = GetService(GetServiceProvider(
productPackingRepository.Object,
productSKURepository.Object,
categoryRepository.Object,
unitOfMeasurementRepository.Object
).Object);
IndexQueryParam queryParam = new IndexQueryParam()
{
order = "",
page = 1,
size = 1,
keyword = "Name"
};
var result = await service.GetIndex(queryParam);
Assert.NotNull(result);
}
