public UpdateWasteCodeData Map(WasteTypes source)
{
return(new UpdateWasteCodeData()
{
Name = source.Name,
BaselOecdCode = CreateBaselCode(source.BaselCodeNotListed, source.SelectedBaselCode),
EwcCode = CreateEwcCode(source.SelectedEwcCodes),
YCode = CreateYCode(source.YCodeNotApplicable, source.SelectedYCodes),
HCode = CreateHCode(source.HCodeNotApplicable, source.SelectedHCodes),
UnClass = CreateUnClass(source.UnClassNotApplicable, source.SelectedUnClasses)
});
}
public WasteTypes Map(Domain.WasteType source, List <WasteCodeData> wasteCodeData)
{
if (source == null)
{
return(new WasteTypes());
}
var result = new WasteTypes(source.ImportNotificationId)
{
Name = source.Name,
BaselCodeNotListed = source.BaselOecdCodeNotListed,
HCodeNotApplicable = source.HCodeNotApplicable,
YCodeNotApplicable = source.YCodeNotApplicable,
UnClassNotApplicable = source.UnClassNotApplicable,
AllCodes = wasteCodeData
};
var wasteCodes = Task.Run(() => wasteCodeRepository
.GetWasteCodesByIds(source.WasteCodes.Select(x => x.WasteCodeId))).Result.ToList();
if (!source.BaselOecdCodeNotListed)
{
var baselOecdCode = wasteCodes
.Single(x =>
x.CodeType == CodeType.Basel ||
x.CodeType == CodeType.Oecd);
var selectedBaselCode = source.WasteCodes.SingleOrDefault(wc => wc.WasteCodeId == baselOecdCode.Id);
result.SelectedBaselCode = selectedBaselCode != null ? selectedBaselCode.WasteCodeId : (Guid?)null;
}
result.SelectedEwcCodes = wasteCodes.Where(x => x.CodeType == CodeType.Ewc).Select(code => code.Id).ToList();
if (!source.HCodeNotApplicable)
{
result.SelectedHCodes = wasteCodes.Where(x => x.CodeType == CodeType.H).Select(code => code.Id).ToList();
}
if (!source.YCodeNotApplicable)
{
result.SelectedYCodes = wasteCodes.Where(x => x.CodeType == CodeType.Y).Select(code => code.Id).ToList();
}
if (!source.UnClassNotApplicable)
{
result.SelectedUnClasses = wasteCodes.Where(x => x.CodeType == CodeType.Un).Select(code => code.Id).ToList();
}
return(result);
}
public UpdateWasteCodesViewModel(WasteTypes data)
{
Name = data.Name;
BaselCodeNotListed = data.BaselCodeNotListed;
SelectedBaselCode = data.SelectedBaselCode;
YCodeNotApplicable = data.YCodeNotApplicable;
HCodeNotApplicable = data.HCodeNotApplicable;
UnClassNotApplicable = data.UnClassNotApplicable;
SelectedEwcCodesDisplay = new List <WasteCodeViewModel>();
SelectedYCodesDisplay = new List <WasteCodeViewModel>();
SelectedHCodesDisplay = new List <WasteCodeViewModel>();
SelectedUnClassesDisplay = new List <WasteCodeViewModel>();
}
public UpdateWasteCodesViewModel Map(WasteTypes source)
{
var model = new UpdateWasteCodesViewModel(source)
{
ImportNotificationId = source.ImportNotificationId
};
if (source.SelectedEwcCodes != null)
{
model.SelectedEwcCodesJson = JsonConvert.SerializeObject(source.SelectedEwcCodes);
model.SelectedEwcCodesDisplay = mapper.Map <List <WasteCodeViewModel> >(source.AllCodes
.Where(p =>
source.SelectedEwcCodes.Contains(p.Id))
.ToList());
}
if (source.SelectedYCodes != null)
{
model.SelectedYCodesJson = JsonConvert.SerializeObject(source.SelectedYCodes);
model.SelectedYCodesDisplay = mapper.Map <List <WasteCodeViewModel> >(source.AllCodes
.Where(p =>
source.SelectedYCodes.Contains(p.Id))
.ToList());
}
if (source.SelectedHCodes != null)
{
model.SelectedHCodesJson = JsonConvert.SerializeObject(source.SelectedHCodes);
model.SelectedHCodesDisplay = mapper.Map <List <WasteCodeViewModel> >(source.AllCodes
.Where(p =>
source.SelectedHCodes.Contains(p.Id))
.ToList());
}
if (source.SelectedUnClasses != null)
{
model.SelectedUnClassesJson = JsonConvert.SerializeObject(source.SelectedUnClasses);
model.SelectedUnClassesDisplay = mapper.Map <List <WasteCodeViewModel> >(source.AllCodes
.Where(p =>
source.SelectedUnClasses.Contains(p.Id))
.ToList());
}
model.AllCodes = mapper.Map <List <WasteCodeViewModel> >(source.AllCodes);
return(model);
}
public WasteTypes Map(UpdateWasteCodesViewModel source)
{
var wasteType = new WasteTypes(source.ImportNotificationId)
{
Name = source.Name,
BaselCodeNotListed = source.BaselCodeNotListed,
YCodeNotApplicable = source.YCodeNotApplicable,
HCodeNotApplicable = source.HCodeNotApplicable,
UnClassNotApplicable = source.UnClassNotApplicable,
};
if (!source.BaselCodeNotListed)
{
wasteType.SelectedBaselCode = source.SelectedBaselCode;
}
if (source.SelectedEwcCodesJson != null)
{
wasteType.SelectedEwcCodes = JsonConvert.DeserializeObject <List <Guid> >(source.SelectedEwcCodesJson);
}
if (source.SelectedYCodesJson != null && !source.YCodeNotApplicable)
{
wasteType.SelectedYCodes = JsonConvert.DeserializeObject <List <Guid> >(source.SelectedYCodesJson);
}
if (source.SelectedHCodesJson != null && !source.HCodeNotApplicable)
{
wasteType.SelectedHCodes = JsonConvert.DeserializeObject <List <Guid> >(source.SelectedHCodesJson);
}
if (source.SelectedUnClassesJson != null && !source.UnClassNotApplicable)
{
wasteType.SelectedUnClasses = JsonConvert.DeserializeObject <List <Guid> >(source.SelectedUnClassesJson);
}
return(wasteType);
}
public UpdateImportNotificationWasteTypes(Guid importNotificationId, WasteTypes wasteTypes)
{
ImportNotificationId = importNotificationId;
WasteTypes = wasteTypes;
}
