public TargetDTO Map(Target target)
{
if (target == null) return null;
return Mapper.Map<Target, TargetDTO>(target);
}
private MasterEntity GetTargetEntity(MasterBaseDTO masterBase)
{
TargetDTO dto = masterBase as TargetDTO;
Target entity = new Target(masterBase.MasterId, masterBase.DateCreated, masterBase.DateLastUpdated, (EntityStatus)masterBase.StatusId);
entity.CostCentre = _outletRepository.GetById(dto.CostCentreId);
entity.TargetValue = dto.TargetValue;
entity.TargetPeriod = _targetPeriodRepository.GetById(dto.TargetPeriodMasterId);
entity.IsQuantityTarget = dto.IsQuantityTarget;
return entity;
}
void CreateNewTarget()
{
TargetId = Guid.NewGuid();
target = new Target(TargetId);
target._SetDateCreated(now);
}
public void ClearViewModel()
{
AddingNew = false;
IsEditing = false;
target = null;
TargetId = Guid.Empty;
Target = 0m;
SelectedOutlet = new Outlet(Guid.Empty) { Name = "---Select Outlet---" };
}
public void LoadTarget()
{
LoadTargetPeriods();
now = DateTime.Now;
if (TargetId == Guid.Empty)
{
CreateNewTarget();
}
else
{
using (StructureMap.IContainer c = NestedContainer)
{
target = Using<ITargetRepository>(c).GetById(TargetId);
Target = target.TargetValue;
SetAsQty = target.IsQuantityTarget;
SelectedTargetPeriod = TargetPeriods.FirstOrDefault(n => n.Id == target.TargetPeriod.Id);
SelectedOutlet = RouteOutlets.FirstOrDefault(n => n.Id == target.CostCentre.Id);
SelectedRoute = Routes.FirstOrDefault(n => n.Id == SelectedOutlet.Route.Id);
MapPeriod();
}
}
}
void LoadTargetFromGrid()
{
using (StructureMap.IContainer c = NestedContainer)
{
target = Using<ITargetRepository>(c).GetById(TargetId, true);
}
Target = target.TargetValue;
SetAsQty = target.IsQuantityTarget;
SelectedTargetPeriod = TargetPeriods.FirstOrDefault(n => n.Id == target.TargetPeriod.Id);
MapPeriod();
CreateTargetSummary();
}
protected Guid AddTarget(Guid DistributorId, Guid Product, Guid TargetPeriod, decimal TargetAmount, bool IsQuantityTarget)
{
Target target = new Target(Guid.NewGuid())
{
CostCentre = _distributorrepository.GetById(DistributorId),
// product=_productRepository.GetById(Product ),
TargetPeriod = _targetPeriodRepository.GetById(TargetPeriod),
TargetValue = TargetAmount,
IsQuantityTarget = IsQuantityTarget,
};
target._SetStatus(EntityStatus.Active);
return _targetRepository.Save(target);
}
protected TargetViewModel Map(Target target)
{
TargetViewModel targetViewModel = new TargetViewModel();
if (target.CostCentre != null)
{
targetViewModel.CostCentreId = _costCentreRepository.GetById(target.CostCentre.Id).Id;
}
targetViewModel.Id = target.Id;
if (target._Status == EntityStatus.Active)
targetViewModel.isActive =true;
targetViewModel.Period = _targetPeriodRepository.GetById(target.TargetPeriod.Id).Id;
targetViewModel.PeriodName = _targetPeriodRepository.GetById(target.TargetPeriod.Id).Name;
targetViewModel.TargetValue = target.TargetValue;
targetViewModel.IsQuantityTarget = target.IsQuantityTarget;
targetViewModel.CostCentreName = _costCentreRepository.GetById(target.CostCentre.Id).Name;
targetViewModel.CostCentreType = _costCentreRepository.GetById(target.CostCentre.Id).CostCentreType;
return targetViewModel;
}
public void Save(TargetViewModel trgViewModel)
{
Target trg = new Target(trgViewModel.Id,DateTime.Now,DateTime.Now,EntityStatus.Active)
{
TargetPeriod=_targetPeriodRepository.GetById(trgViewModel.Period),
CostCentre=_costCentreRepository.GetById(trgViewModel.CostCentreId),
TargetValue=trgViewModel.TargetValue,
IsQuantityTarget=trgViewModel.IsQuantityTarget
};
_targeteRepository.Save(trg );
}
private void AssertTarget(Target targetPeriod, Target savedTargetPeriod)
{
Assert.AreEqual(targetPeriod.CostCentre.CostCentreCode, savedTargetPeriod.CostCentre.CostCentreCode);
Assert.AreEqual(targetPeriod.TargetPeriod.Name, savedTargetPeriod.TargetPeriod.Name);
Assert.AreEqual(targetPeriod.IsQuantityTarget, savedTargetPeriod.IsQuantityTarget);
Assert.AreEqual(targetPeriod.TargetValue, savedTargetPeriod.TargetValue);
Assert.AreEqual(targetPeriod._Status, EntityStatus.Active);
}
public HttpResponseMessage TargetAdd(CostCentreTargetItem targetItem)
{
var response = new ResponseBool { Success = false };
Target target = null;
TargetPeriod targetPeriod = null;
CostCentre costCentre = null;
try
{
targetPeriod = _targetPeriodRepository.GetById(targetItem.TargetPeriodMasterId);
costCentre = _costCentreRepository.GetById(targetItem.CostCentreMasterId);
target = new Target(targetItem.MasterId)
{
CostCentre = costCentre,
TargetPeriod = targetPeriod,
TargetValue = targetItem.TargetValue,
IsQuantityTarget = targetItem.IsQuantityTarget,
};
_targetRepository.Save(target);
response.Success = true;
response.ErrorInfo = "Successfully added target for " + target.CostCentre.Name;
}
catch (DomainValidationException dve)
{
string errorMsg = dve.ValidationResults.Results.Aggregate("Error: Invalid target fields.\n",
(current, msg) =>
current + ("\t- " + msg.ErrorMessage + "\n"));
response.ErrorInfo = errorMsg;
_log.Error(errorMsg, dve);
}
catch (Exception e)
{
response.ErrorInfo = "Error: An error occured when saving the target.";
_log.Error("Error: An error occured when saving the target.\n", e);
}
return Request.CreateResponse(HttpStatusCode.OK, response);
}
