public bool ValidUpdateObject(RollerBuilder rollerBuilder, IRollerBuilderService _rollerBuilderService, IMachineService _machineService, IUoMService _uomService,
IItemService _itemService, ICoreBuilderService _coreBuilderService, IRollerTypeService _rollerTypeService)
{
rollerBuilder.Errors.Clear();
VUpdateObject(rollerBuilder, _rollerBuilderService, _machineService, _uomService, _itemService, _coreBuilderService, _rollerTypeService);
return(isValid(rollerBuilder));
}
public RollerBuilder SoftDeleteObject(RollerBuilder rollerBuilder, IItemService _itemService, IRecoveryOrderDetailService _recoveryOrderDetailService,
ICoreBuilderService _coreBuilderService, IWarehouseItemService _warehouseItemService, IStockMutationService _stockMutationService,
IItemTypeService _itemTypeService)
{
Item RollerUsedCore = _itemService.GetObjectById(rollerBuilder.RollerUsedCoreItemId);
Item RollerNewCore = _itemService.GetObjectById(rollerBuilder.RollerNewCoreItemId);
if (_itemService.GetValidator().ValidDeleteLegacyObject(RollerUsedCore, _stockMutationService, _itemTypeService, _warehouseItemService) &&
_itemService.GetValidator().ValidDeleteLegacyObject(RollerUsedCore, _stockMutationService, _itemTypeService, _warehouseItemService))
{
if (_validator.ValidDeleteObject(rollerBuilder, _recoveryOrderDetailService))
{
_itemService.GetRepository().SoftDeleteObject(RollerUsedCore);
_itemService.GetRepository().SoftDeleteObject(RollerNewCore);
_repository.SoftDeleteObject(rollerBuilder);
}
}
else
{
if (RollerUsedCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerUsedCore.Errors.First().Key, RollerUsedCore.Errors.First().Value);
}
else if (RollerNewCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerNewCore.Errors.First().Key, RollerNewCore.Errors.First().Value);
}
else
{
rollerBuilder.Errors.Add("Generic", "Item tidak dapat di hapus");
}
}
return(rollerBuilder);
}
public RollerBuilder VNameNotEmpty(RollerBuilder rollerBuilder)
{
if (String.IsNullOrEmpty(rollerBuilder.Name) || rollerBuilder.Name.Trim() == "")
{
rollerBuilder.Errors.Add("Name", "Tidak boleh kosong");
}
return(rollerBuilder);
}
public RollerBuilder VHasCompound(RollerBuilder rollerBuilder, IItemService _itemService)
{
Item item = _itemService.GetObjectById(rollerBuilder.CompoundId);
if (item == null)
{
rollerBuilder.Errors.Add("CompoundId", "Tidak terasosiasi dengan compound");
}
return(rollerBuilder);
}
public RollerBuilder VHasCoreBuilder(RollerBuilder rollerBuilder, ICoreBuilderService _coreBuilderService)
{
CoreBuilder coreBuilder = _coreBuilderService.GetObjectById(rollerBuilder.CoreBuilderId);
if (coreBuilder == null)
{
rollerBuilder.Errors.Add("CoreBuilderId", "Tidak terasosiasi dengan coreBuilder");
}
return(rollerBuilder);
}
public RollerBuilder VHasRollerType(RollerBuilder rollerBuilder, IRollerTypeService _rollerTypeService)
{
RollerType rollerType = _rollerTypeService.GetObjectById(rollerBuilder.RollerTypeId);
if (rollerType == null)
{
rollerBuilder.Errors.Add("RollerTypeId", "Tidak terasosiasi dengan rollerType");
}
return(rollerBuilder);
}
public RollerBuilder VHasRollerNewCoreItem(RollerBuilder rollerBuilder, IItemService _itemService)
{
Item RollerNewCoreItem = _itemService.GetObjectById(rollerBuilder.RollerNewCoreItemId);
if (RollerNewCoreItem == null)
{
rollerBuilder.Errors.Add("RollerNewCoreItemId", "Tidak terasosiasi dengan Item");
}
return(rollerBuilder);
}
public RollerBuilder VIsInRecoveryOrderDetails(RollerBuilder rollerBuilder, IRecoveryOrderDetailService _recoveryOrderDetailService)
{
IList <RecoveryOrderDetail> details = _recoveryOrderDetailService.GetObjectsByRollerBuilderId(rollerBuilder.Id);
if (details.Any())
{
rollerBuilder.Errors.Add("Generic", "Tidak boleh memiliki asosiasi Recovery Order Detail");
}
return(rollerBuilder);
}
public RollerBuilder VHasUoM(RollerBuilder rollerBuilder, IUoMService _uomService)
{
UoM uom = _uomService.GetObjectById(rollerBuilder.UoMId);
if (uom == null)
{
rollerBuilder.Errors.Add("UoMId", "Tidak terasosiasi dengan unit of measurement");
}
return(rollerBuilder);
}
public RecoveryOrderDetail VHasRollerBuilder(RecoveryOrderDetail recoveryOrderDetail, IRollerBuilderService _rollerBuilderService)
{
RollerBuilder rollerBuilder = _rollerBuilderService.GetObjectById(recoveryOrderDetail.RollerBuilderId);
if (rollerBuilder == null)
{
recoveryOrderDetail.Errors.Add("RollerBuilderId", "Tidak terasosiasi dengan Roller Builder");
}
return(recoveryOrderDetail);
}
public RollerBuilder VHasMachine(RollerBuilder rollerBuilder, IMachineService _machineService)
{
Machine machine = _machineService.GetObjectById(rollerBuilder.MachineId);
if (machine == null)
{
rollerBuilder.Errors.Add("MachineId", "Tidak terasosiasi dengan machine");
}
return(rollerBuilder);
}
public RollerBuilder VHasUniqueBaseSku(RollerBuilder rollerBuilder, IRollerBuilderService _rollerBuilderService)
{
if (String.IsNullOrEmpty(rollerBuilder.BaseSku) || rollerBuilder.BaseSku.Trim() == "")
{
rollerBuilder.Errors.Add("BaseSku", "Tidak boleh kosong");
}
if (_rollerBuilderService.IsBaseSkuDuplicated(rollerBuilder))
{
rollerBuilder.Errors.Add("BaseSku", "Tidak boleh diduplikasi");
}
return(rollerBuilder);
}
public string PrintError(RollerBuilder obj)
{
string erroroutput = "";
KeyValuePair <string, string> first = obj.Errors.ElementAt(0);
erroroutput += first.Key + "," + first.Value;
foreach (KeyValuePair <string, string> pair in obj.Errors.Skip(1))
{
erroroutput += Environment.NewLine;
erroroutput += pair.Key + "," + pair.Value;
}
return(erroroutput);
}
public RollerBuilder VUpdateObject(RollerBuilder rollerBuilder, IRollerBuilderService _rollerBuilderService, IMachineService _machineService, IUoMService _uomService,
IItemService _itemService, ICoreBuilderService _coreBuilderService, IRollerTypeService _rollerTypeService)
{
VCreateObject(rollerBuilder, _rollerBuilderService, _machineService, _uomService, _itemService, _coreBuilderService, _rollerTypeService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasRollerUsedCoreItem(rollerBuilder, _itemService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasRollerNewCoreItem(rollerBuilder, _itemService);
return(rollerBuilder);
}
public dynamic Insert(RollerBuilder model)
{
try
{
model = _rollerBuilderService.CreateObject(model, _machineService, _uomService, _itemService, _itemTypeService, _coreBuilderService, _rollerTypeService, _warehouseItemService, _warehouseService);
}
catch (Exception ex)
{
LOG.Error("Insert Failed", ex);
model.Errors.Add("Generic", "Error : " + ex);
}
return(Json(new
{
model.Errors
}));
}
public dynamic Delete(RollerBuilder model)
{
try
{
var data = _rollerBuilderService.GetObjectById(model.Id);
model = _rollerBuilderService.SoftDeleteObject(data, _itemService, _recoveryOrderDetailService, _coreBuilderService, _warehouseItemService, _stockMutationService, _itemTypeService);
}
catch (Exception ex)
{
LOG.Error("Delete Failed", ex);
model.Errors.Add("Generic", "Error : " + ex);
}
return(Json(new
{
model.Errors
}));
}
public RollerBuilder UpdateObject(RollerBuilder rollerBuilder, IMachineService _machineService, IUoMService _uomService,
IItemService _itemService, IItemTypeService _itemTypeService, ICoreBuilderService _coreBuilderService,
IRollerTypeService _rollerTypeService, IWarehouseItemService _warehouseItemService, IWarehouseService _warehouseService,
IBarringService _barringService, IContactService _contactService, IPriceMutationService _priceMutationService,
IContactGroupService _contactGroupService)
{
Item RollerUsedCore = _itemService.GetObjectById(rollerBuilder.RollerUsedCoreItemId);
RollerUsedCore.Name = rollerBuilder.Name;
RollerUsedCore.Category = rollerBuilder.Category;
Item RollerNewCore = _itemService.GetObjectById(rollerBuilder.RollerNewCoreItemId);
RollerNewCore.Name = rollerBuilder.Name;
RollerNewCore.Category = rollerBuilder.Category;
if (_itemService.GetValidator().ValidUpdateLegacyObject(RollerUsedCore, _uomService, _itemService, _itemTypeService) &&
_itemService.GetValidator().ValidUpdateLegacyObject(RollerNewCore, _uomService, _itemService, _itemTypeService))
{
if (_validator.ValidUpdateObject(rollerBuilder, this, _machineService, _uomService, _itemService, _coreBuilderService, _rollerTypeService))
{
_itemService.UpdateLegacyObject(RollerUsedCore, _uomService, _itemTypeService, _warehouseItemService, _warehouseService, _barringService,
_contactService, _machineService, _priceMutationService, _contactGroupService);
_itemService.UpdateLegacyObject(RollerNewCore, _uomService, _itemTypeService, _warehouseItemService, _warehouseService, _barringService,
_contactService, _machineService, _priceMutationService, _contactGroupService);
rollerBuilder = _repository.UpdateObject(rollerBuilder);
}
}
else
{
if (RollerUsedCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerUsedCore.Errors.First().Key, RollerUsedCore.Errors.First().Value);
}
else if (RollerNewCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerNewCore.Errors.First().Key, RollerNewCore.Errors.First().Value);
}
else
{
rollerBuilder.Errors.Add("Generic", "Item tidak dapat di update");
}
}
return(rollerBuilder);
}
public RecoveryOrderDetail RejectObject(RecoveryOrderDetail recoveryOrderDetail, DateTime RejectedDate, ICoreIdentificationService _coreIdentificationService, ICoreIdentificationDetailService _coreIdentificationDetailService,
IRecoveryOrderService _recoveryOrderService, IRecoveryAccessoryDetailService _recoveryAccessoryDetailService, ICoreBuilderService _coreBuilderService, IRollerBuilderService _rollerBuilderService,
IItemService _itemService, IWarehouseItemService _warehouseItemService, IBarringService _barringService, IStockMutationService _stockMutationService)
{
recoveryOrderDetail.RejectedDate = RejectedDate;
if (_validator.ValidRejectObject(recoveryOrderDetail, _recoveryOrderService))
{
_repository.RejectObject(recoveryOrderDetail);
// add recovery order quantity reject
// if valid, complete recovery order = true
RecoveryOrder recoveryOrder = _recoveryOrderService.GetObjectById(recoveryOrderDetail.RecoveryOrderId);
recoveryOrder.QuantityRejected += 1;
_recoveryOrderService.AdjustQuantity(recoveryOrder);
if (_recoveryOrderService.GetValidator().ValidCompleteObject(recoveryOrder, this, _recoveryAccessoryDetailService))
{
_recoveryOrderService.CompleteObject(recoveryOrder, _coreIdentificationDetailService, this, _recoveryAccessoryDetailService);
}
bool CaseAddition = false;
// deduce compound
RollerBuilder rollerBuilder = _rollerBuilderService.GetObjectById(recoveryOrderDetail.RollerBuilderId);
Item compound = _itemService.GetObjectById(rollerBuilder.CompoundId);
WarehouseItem warehouseCompound = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, compound.Id);
StockMutation stockMutationCompound = _stockMutationService.CreateStockMutationForRecoveryOrderCompound(recoveryOrderDetail, warehouseCompound, CaseAddition);
_stockMutationService.StockMutateObject(stockMutationCompound, _itemService, _barringService, _warehouseItemService);
// deduce core
CoreIdentificationDetail coreIdentificationDetail = _coreIdentificationDetailService.GetObjectById(recoveryOrderDetail.CoreIdentificationDetailId);
_coreIdentificationDetailService.UnsetJobScheduled(coreIdentificationDetail, _recoveryOrderService, this);
CoreBuilder coreBuilder = _coreBuilderService.GetObjectById(coreIdentificationDetail.CoreBuilderId);
Item core = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_coreBuilderService.GetNewCore(coreBuilder.Id) : _coreBuilderService.GetUsedCore(coreBuilder.Id);
WarehouseItem warehouseCore = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, core.Id);
StockMutation stockMutationCore = _stockMutationService.CreateStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCore, CaseAddition);
_stockMutationService.StockMutateObject(stockMutationCore, _itemService, _barringService, _warehouseItemService);
// accesories uncounted
}
return(recoveryOrderDetail);
}
public dynamic Update(RollerBuilder model)
{
try
{
var data = _rollerBuilderService.GetObjectById(model.Id);
data.Name = model.Name;
model = _rollerBuilderService.UpdateObject(data, _machineService, _uomService, _itemService, _itemTypeService, _coreBuilderService, _rollerTypeService);
}
catch (Exception ex)
{
LOG.Error("Update Failed", ex);
model.Errors.Add("Generic", "Error : " + ex);
}
return(Json(new
{
model.Errors
}));
}
public RecoveryOrderDetail UndoRejectObject(RecoveryOrderDetail recoveryOrderDetail, ICoreIdentificationService _coreIdentificationService, ICoreIdentificationDetailService _coreIdentificationDetailService,
IRecoveryOrderService _recoveryOrderService, IRecoveryAccessoryDetailService _recoveryAccessoryDetailService, ICoreBuilderService _coreBuilderService, IRollerBuilderService _rollerBuilderService,
IItemService _itemService, IWarehouseItemService _warehouseItemService, IBarringService _barringService, IStockMutationService _stockMutationService)
{
if (_validator.ValidUndoRejectObject(recoveryOrderDetail, _recoveryOrderService))
{
_repository.UndoRejectObject(recoveryOrderDetail);
// add recovery order quantity reject
// if valid, complete recovery order = true
RecoveryOrder recoveryOrder = _recoveryOrderService.GetObjectById(recoveryOrderDetail.RecoveryOrderId);
recoveryOrder.QuantityRejected -= 1;
_recoveryOrderService.AdjustQuantity(recoveryOrder);
// reverse stock mutate compound
RollerBuilder rollerBuilder = _rollerBuilderService.GetObjectById(recoveryOrderDetail.RollerBuilderId);
Item compound = _itemService.GetObjectById(rollerBuilder.CompoundId);
WarehouseItem warehouseCompound = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, compound.Id);
IList <StockMutation> stockMutationCompounds = _stockMutationService.SoftDeleteStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCompound);
foreach (var stockMutationCompound in stockMutationCompounds)
{
_stockMutationService.ReverseStockMutateObject(stockMutationCompound, _itemService, _barringService, _warehouseItemService);
}
// reverse stock mutate core
CoreIdentificationDetail coreIdentificationDetail = _coreIdentificationDetailService.GetObjectById(recoveryOrderDetail.CoreIdentificationDetailId);
_coreIdentificationDetailService.SetJobScheduled(coreIdentificationDetail, _recoveryOrderService, this);
CoreBuilder coreBuilder = _coreBuilderService.GetObjectById(coreIdentificationDetail.CoreBuilderId);
Item core = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_coreBuilderService.GetNewCore(coreBuilder.Id) : _coreBuilderService.GetUsedCore(coreBuilder.Id);
WarehouseItem warehouseCore = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, core.Id);
IList <StockMutation> stockMutationCores = _stockMutationService.SoftDeleteStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCore);
foreach (var stockMutationCore in stockMutationCores)
{
_stockMutationService.ReverseStockMutateObject(stockMutationCore, _itemService, _barringService, _warehouseItemService);
}
// accesories uncounted
}
return(recoveryOrderDetail);
}
public dynamic GetInfo(int Id)
{
RollerBuilder model = new RollerBuilder();
try
{
model = _rollerBuilderService.GetObjectById(Id);
}
catch (Exception ex)
{
LOG.Error("GetInfo", ex);
model.Errors.Add("Generic", "Error : " + ex);
}
return(Json(new
{
model.Id,
model.Name,
model.Category,
model.UoMId,
UoM = _uomService.GetObjectById(model.UoMId).Name,
model.BaseSku,
model.SkuRollerUsedCore,
model.SkuRollerNewCore,
model.MachineId,
Machine = _machineService.GetObjectById(model.MachineId).Name,
model.RollerTypeId,
RollerType = _rollerTypeService.GetObjectById(model.RollerTypeId).Name,
model.CompoundId,
Compound = _itemTypeService.GetObjectById(model.CompoundId).Name,
model.CoreBuilderId,
CoreBuilder = _coreBuilderService.GetObjectById(model.CoreBuilderId).Name,
model.RD,
model.CD,
model.RL,
model.WL,
model.TL,
RollerUsedCoreQuantity = _itemService.GetObjectById(model.RollerUsedCoreItemId).Quantity,
RollerNewCoreQuantity = _itemService.GetObjectById(model.RollerNewCoreItemId).Quantity,
model.Errors
}, JsonRequestBehavior.AllowGet));
}
public RollerBuilder VCreateObject(RollerBuilder rollerBuilder, IRollerBuilderService _rollerBuilderService, IMachineService _machineService, IUoMService _uomService,
IItemService _itemService, ICoreBuilderService _coreBuilderService, IRollerTypeService _rollerTypeService)
{
VHasUniqueBaseSku(rollerBuilder, _rollerBuilderService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VNameNotEmpty(rollerBuilder);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasCompound(rollerBuilder, _itemService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasCoreBuilder(rollerBuilder, _coreBuilderService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasRollerType(rollerBuilder, _rollerTypeService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasMachine(rollerBuilder, _machineService);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasMeasurement(rollerBuilder);
if (!isValid(rollerBuilder))
{
return(rollerBuilder);
}
VHasUoM(rollerBuilder, _uomService);
return(rollerBuilder);
}
public RollerBuilder CreateObject(string BaseSku, string SkuRollerNewCore, string SkuRollerUsedCore, string Name, string Category,
int CD, int RD, int RL, int WL, int TL,
IMachineService _machineService, IUoMService _uomService, IItemService _itemService, IItemTypeService _itemTypeService,
ICoreBuilderService _coreBuilderService, IRollerTypeService _rollerTypeService,
IWarehouseItemService _warehouseItemService, IWarehouseService _warehouseService)
{
RollerBuilder rollerBuilder = new RollerBuilder
{
BaseSku = BaseSku,
SkuRollerNewCore = SkuRollerNewCore,
SkuRollerUsedCore = SkuRollerUsedCore,
Name = Name,
Category = Category,
CD = CD,
RD = RD,
RL = RL,
WL = WL,
TL = TL
};
return(this.CreateObject(rollerBuilder, _machineService, _uomService, _itemService, _itemTypeService, _coreBuilderService, _rollerTypeService,
_warehouseItemService, _warehouseService));
}
public RollerBuilder VHasMeasurement(RollerBuilder rollerBuilder)
{
if (rollerBuilder.CD <= 0)
{
rollerBuilder.Errors.Add("CD", "Tidak boleh 0 atau negatif"); return(rollerBuilder);
}
if (rollerBuilder.RD <= 0)
{
rollerBuilder.Errors.Add("RD", "Tidak boleh 0 atau negatif"); return(rollerBuilder);
}
if (rollerBuilder.RL <= 0)
{
rollerBuilder.Errors.Add("RL", "Tidak boleh 0 atau negatif"); return(rollerBuilder);
}
if (rollerBuilder.WL <= 0)
{
rollerBuilder.Errors.Add("WL", "Tidak boleh 0 atau negatif"); return(rollerBuilder);
}
if (rollerBuilder.TL <= 0)
{
rollerBuilder.Errors.Add("TL", "Tidak boleh 0 atau negatif"); return(rollerBuilder);
}
return(rollerBuilder);
}
public bool IsBaseSkuDuplicated(RollerBuilder rollerBuilder)
{
IQueryable <RollerBuilder> builders = _repository.FindAll(x => x.BaseSku == rollerBuilder.BaseSku && !x.IsDeleted && x.Id != rollerBuilder.Id);
return(builders.Count() > 0 ? true : false);
}
public RollerBuilder CreateObject(RollerBuilder rollerBuilder, IMachineService _machineService, IUoMService _uomService,
IItemService _itemService, IItemTypeService _itemTypeService, ICoreBuilderService _coreBuilderService,
IRollerTypeService _rollerTypeService, IWarehouseItemService _warehouseItemService, IWarehouseService _warehouseService)
{
rollerBuilder.Errors = new Dictionary <String, String>();
ItemType typeRoller = _itemTypeService.GetObjectByName(Core.Constants.Constant.ItemTypeCase.Roller);
if (typeRoller == null)
{
rollerBuilder.Errors.Add("Generic", "ItemType [Roller] Legacy harus dibuat terlebih dahulu");
}
Item RollerUsedCore = new Item()
{
Name = rollerBuilder.Name,
Category = rollerBuilder.Category,
UoMId = rollerBuilder.UoMId,
Quantity = 0,
ItemTypeId = _itemTypeService.GetObjectByName(Core.Constants.Constant.ItemTypeCase.Roller).Id,
Sku = rollerBuilder.SkuRollerUsedCore
};
RollerUsedCore.Errors = new Dictionary <string, string>();
Item RollerNewCore = new Item()
{
Name = rollerBuilder.Name,
Category = rollerBuilder.Category,
UoMId = rollerBuilder.UoMId,
Quantity = 0,
ItemTypeId = _itemTypeService.GetObjectByName(Core.Constants.Constant.ItemTypeCase.Roller).Id,
Sku = rollerBuilder.SkuRollerNewCore
};
RollerNewCore.Errors = new Dictionary <string, string>();
if (_itemService.GetValidator().ValidCreateLegacyObject(RollerUsedCore, _uomService, _itemService, _itemTypeService) &&
_itemService.GetValidator().ValidCreateLegacyObject(RollerNewCore, _uomService, _itemService, _itemTypeService))
{
if (_validator.ValidCreateObject(rollerBuilder, this, _machineService, _uomService, _itemService, _coreBuilderService, _rollerTypeService))
{
RollerUsedCore = _itemService.CreateLegacyObject(RollerUsedCore, _uomService, _itemTypeService, _warehouseItemService, _warehouseService);
RollerUsedCore.Id = RollerUsedCore.Id;
RollerNewCore = _itemService.CreateLegacyObject(RollerNewCore, _uomService, _itemTypeService, _warehouseItemService, _warehouseService);
RollerNewCore.Id = RollerNewCore.Id;
rollerBuilder.RollerUsedCoreItemId = RollerUsedCore.Id;
rollerBuilder.RollerNewCoreItemId = RollerNewCore.Id;
rollerBuilder = _repository.CreateObject(rollerBuilder);
}
}
else
{
if (RollerUsedCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerUsedCore.Errors.First().Key, RollerUsedCore.Errors.First().Value);
}
else if (RollerNewCore.Errors.Count() > 0)
{
rollerBuilder.Errors.Add(RollerNewCore.Errors.First().Key, RollerNewCore.Errors.First().Value);
}
else
{
rollerBuilder.Errors.Add("Generic", "Item tidak dapat di update");
}
}
return(rollerBuilder);
}
public RecoveryOrderDetail UnfinishObject(RecoveryOrderDetail recoveryOrderDetail, ICoreIdentificationService _coreIdentificationService, ICoreIdentificationDetailService _coreIdentificationDetailService,
IRecoveryOrderService _recoveryOrderService, IRecoveryAccessoryDetailService _recoveryAccessoryDetailService, ICoreBuilderService _coreBuilderService, IRollerBuilderService _rollerBuilderService,
IItemService _itemService, IWarehouseItemService _warehouseItemService, IBarringService _barringService, IStockMutationService _stockMutationService)
{
if (_validator.ValidUnfinishObject(recoveryOrderDetail, _recoveryOrderService, _recoveryAccessoryDetailService))
{
// unfinish object
_repository.UnfinishObject(recoveryOrderDetail);
// add recovery order quantity final
RecoveryOrder recoveryOrder = _recoveryOrderService.GetObjectById(recoveryOrderDetail.RecoveryOrderId);
recoveryOrder.QuantityFinal += 1;
_recoveryOrderService.AdjustQuantity(recoveryOrder);
// reverse stock mutate compound
RollerBuilder rollerBuilder = _rollerBuilderService.GetObjectById(recoveryOrderDetail.RollerBuilderId);
Item compound = _itemService.GetObjectById(rollerBuilder.CompoundId);
WarehouseItem warehouseCompound = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, compound.Id);
IList <StockMutation> stockMutationCompounds = _stockMutationService.SoftDeleteStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCompound);
foreach (var stockMutationCompound in stockMutationCompounds)
{
_stockMutationService.ReverseStockMutateObject(stockMutationCompound, _itemService, _barringService, _warehouseItemService);
}
// reverse stock mutate core
CoreIdentificationDetail coreIdentificationDetail = _coreIdentificationDetailService.GetObjectById(recoveryOrderDetail.CoreIdentificationDetailId);
_coreIdentificationDetailService.SetJobScheduled(coreIdentificationDetail, _recoveryOrderService, this);
CoreBuilder coreBuilder = _coreBuilderService.GetObjectById(coreIdentificationDetail.CoreBuilderId);
Item core = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_coreBuilderService.GetNewCore(coreBuilder.Id) : _coreBuilderService.GetUsedCore(coreBuilder.Id);
WarehouseItem warehouseCore = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, core.Id);
IList <StockMutation> stockMutationCores = _stockMutationService.SoftDeleteStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCore);
foreach (var stockMutationCore in stockMutationCores)
{
_stockMutationService.ReverseStockMutateObject(stockMutationCore, _itemService, _barringService, _warehouseItemService);
}
// reverse stock mutate roller
Item roller = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_rollerBuilderService.GetRollerNewCore(rollerBuilder.Id) : _rollerBuilderService.GetRollerUsedCore(rollerBuilder.Id);
WarehouseItem warehouseRoller = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, roller.Id);
IList <StockMutation> stockMutationRollers = _stockMutationService.SoftDeleteStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseRoller);
foreach (var stockMutationRoller in stockMutationRollers)
{
_stockMutationService.ReverseStockMutateObject(stockMutationRoller, _itemService, _barringService, _warehouseItemService);
}
// reverse stock mutate accessories
IList <RecoveryAccessoryDetail> recoveryAccessoryDetails = _recoveryAccessoryDetailService.GetObjectsByRecoveryOrderDetailId(recoveryOrderDetail.Id);
if (recoveryAccessoryDetails.Any())
{
foreach (var recoveryAccessoryDetail in recoveryAccessoryDetails)
{
Item accessory = _itemService.GetObjectById(recoveryAccessoryDetail.ItemId);
WarehouseItem warehouseAccessory = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, accessory.Id);
IList <StockMutation> stockMutationAccessories = _stockMutationService.SoftDeleteStockMutationForRecoveryAccessory(recoveryAccessoryDetail, warehouseAccessory);
foreach (var stockMutationAccessory in stockMutationAccessories)
{
_stockMutationService.ReverseStockMutateObject(stockMutationAccessory, _itemService, _barringService, _warehouseItemService);
}
}
}
}
return(recoveryOrderDetail);
}
public RecoveryOrderDetail FinishObject(RecoveryOrderDetail recoveryOrderDetail, DateTime FinishedDate, ICoreIdentificationService _coreIdentificationService, ICoreIdentificationDetailService _coreIdentificationDetailService,
IRecoveryOrderService _recoveryOrderService, IRecoveryAccessoryDetailService _recoveryAccessoryDetailService, ICoreBuilderService _coreBuilderService, IRollerBuilderService _rollerBuilderService,
IItemService _itemService, IWarehouseItemService _warehouseItemService, IBarringService _barringService, IStockMutationService _stockMutationService)
{
recoveryOrderDetail.FinishedDate = FinishedDate;
if (_validator.ValidFinishObject(recoveryOrderDetail, _recoveryOrderService, _recoveryAccessoryDetailService))
{
// set object to finish
_repository.FinishObject(recoveryOrderDetail);
// add recovery order quantity final
// if valid, complete recovery order = true
RecoveryOrder recoveryOrder = _recoveryOrderService.GetObjectById(recoveryOrderDetail.RecoveryOrderId);
recoveryOrder.QuantityFinal += 1;
_recoveryOrderService.AdjustQuantity(recoveryOrder);
if (_recoveryOrderService.GetValidator().ValidCompleteObject(recoveryOrder, this, _recoveryAccessoryDetailService))
{
_recoveryOrderService.CompleteObject(recoveryOrder, _coreIdentificationDetailService, this, _recoveryAccessoryDetailService);
}
bool CaseAdditionCompound = false;
bool CaseAdditionCore = false;
bool CaseAdditionRoller = true;
// deduce compound
RollerBuilder rollerBuilder = _rollerBuilderService.GetObjectById(recoveryOrderDetail.RollerBuilderId);
Item compound = _itemService.GetObjectById(rollerBuilder.CompoundId);
WarehouseItem warehouseCompound = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, compound.Id);
StockMutation stockMutationCompound = _stockMutationService.CreateStockMutationForRecoveryOrderCompound(recoveryOrderDetail, warehouseCompound, CaseAdditionCompound);
_stockMutationService.StockMutateObject(stockMutationCompound, _itemService, _barringService, _warehouseItemService);
CoreIdentificationDetail coreIdentificationDetail = _coreIdentificationDetailService.GetObjectById(recoveryOrderDetail.CoreIdentificationDetailId);
_coreIdentificationDetailService.UnsetJobScheduled(coreIdentificationDetail, _recoveryOrderService, this);
_coreIdentificationDetailService.BuildRoller(coreIdentificationDetail);
// deduce core
CoreBuilder coreBuilder = _coreBuilderService.GetObjectById(coreIdentificationDetail.CoreBuilderId);
Item core = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_coreBuilderService.GetNewCore(coreBuilder.Id) : _coreBuilderService.GetUsedCore(coreBuilder.Id);
WarehouseItem warehouseCore = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, core.Id);
StockMutation stockMutationCore = _stockMutationService.CreateStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseCore, CaseAdditionCore);
_stockMutationService.StockMutateObject(stockMutationCore, _itemService, _barringService, _warehouseItemService);
// add roller
Item roller = (coreIdentificationDetail.MaterialCase == Core.Constants.Constant.MaterialCase.New) ?
_rollerBuilderService.GetRollerNewCore(rollerBuilder.Id) : _rollerBuilderService.GetRollerUsedCore(rollerBuilder.Id);
WarehouseItem warehouseRoller = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, roller.Id);
StockMutation stockMutationRoller = _stockMutationService.CreateStockMutationForRecoveryOrder(recoveryOrderDetail, warehouseRoller, CaseAdditionRoller);
_stockMutationService.StockMutateObject(stockMutationRoller, _itemService, _barringService, _warehouseItemService);
// deduce accessories
IList <RecoveryAccessoryDetail> recoveryAccessoryDetails = _recoveryAccessoryDetailService.GetObjectsByRecoveryOrderDetailId(recoveryOrderDetail.Id);
if (recoveryAccessoryDetails.Any())
{
foreach (var recoveryAccessoryDetail in recoveryAccessoryDetails)
{
Item accessory = _itemService.GetObjectById(recoveryAccessoryDetail.ItemId);
WarehouseItem warehouseAccessory = _warehouseItemService.FindOrCreateObject(recoveryOrder.WarehouseId, accessory.Id);
StockMutation stockMutationAccessory = _stockMutationService.CreateStockMutationForRecoveryAccessory(recoveryAccessoryDetail, warehouseAccessory);
_stockMutationService.StockMutateObject(stockMutationAccessory, _itemService, _barringService, _warehouseItemService);
}
}
}
return(recoveryOrderDetail);
}
public bool ValidDeleteObject(RollerBuilder rollerBuilder, IRecoveryOrderDetailService _recoveryOrderDetailService)
{
rollerBuilder.Errors.Clear();
VDeleteObject(rollerBuilder, _recoveryOrderDetailService);
return(isValid(rollerBuilder));
}
public bool isValid(RollerBuilder obj)
{
bool isValid = !obj.Errors.Any();
return(isValid);
}
