public WasteType(Guid importNotificationId,
string name,
BaselOecdCode baselOecdCode,
EwcCode ewcCode,
YCode yCode,
HCode hCode,
UnClass unClass,
ChemicalComposition chemicalComposition)
{
Guard.ArgumentNotDefaultValue(() => importNotificationId, importNotificationId);
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotNull(() => baselOecdCode, baselOecdCode);
Guard.ArgumentNotNull(() => ewcCode, ewcCode);
Guard.ArgumentNotNull(() => yCode, yCode);
Guard.ArgumentNotNull(() => hCode, hCode);
Guard.ArgumentNotNull(() => unClass, unClass);
Guard.ArgumentNotDefaultValue(() => chemicalComposition, chemicalComposition);
ImportNotificationId = importNotificationId;
Name = name;
var wasteCodes = new List <WasteTypeWasteCode>();
WasteCodesCollection = new List <WasteTypeWasteCode>();
BaselOecdCodeNotListed = baselOecdCode.NotListed;
YCodeNotApplicable = yCode.NotApplicable;
HCodeNotApplicable = hCode.NotApplicable;
UnClassNotApplicable = unClass.NotApplicable;
ChemicalCompositionType = chemicalComposition;
wasteCodes.AddRange(ewcCode.Codes);
if (!BaselOecdCodeNotListed)
{
wasteCodes.Add(baselOecdCode.Code);
}
if (!YCodeNotApplicable)
{
wasteCodes.AddRange(yCode.Codes);
}
if (!HCodeNotApplicable)
{
wasteCodes.AddRange(hCode.Codes);
}
if (!UnClassNotApplicable)
{
wasteCodes.AddRange(unClass.Codes);
}
WasteCodesCollection = wasteCodes;
}
public WasteType(Guid importNotificationId,
string name,
BaselOecdCode baselOecdCode,
EwcCode ewcCode,
YCode yCode,
HCode hCode,
UnClass unClass,
ChemicalComposition chemicalComposition)
{
Guard.ArgumentNotDefaultValue(() => importNotificationId, importNotificationId);
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotNull(() => baselOecdCode, baselOecdCode);
Guard.ArgumentNotNull(() => ewcCode, ewcCode);
Guard.ArgumentNotNull(() => yCode, yCode);
Guard.ArgumentNotNull(() => hCode, hCode);
Guard.ArgumentNotNull(() => unClass, unClass);
Guard.ArgumentNotDefaultValue(() => chemicalComposition, chemicalComposition);
ImportNotificationId = importNotificationId;
Name = name;
var wasteCodes = new List<WasteTypeWasteCode>();
WasteCodesCollection = new List<WasteTypeWasteCode>();
BaselOecdCodeNotListed = baselOecdCode.NotListed;
YCodeNotApplicable = yCode.NotApplicable;
HCodeNotApplicable = hCode.NotApplicable;
UnClassNotApplicable = unClass.NotApplicable;
ChemicalCompositionType = chemicalComposition;
wasteCodes.AddRange(ewcCode.Codes);
if (!BaselOecdCodeNotListed)
{
wasteCodes.Add(baselOecdCode.Code);
}
if (!YCodeNotApplicable)
{
wasteCodes.AddRange(yCode.Codes);
}
if (!HCodeNotApplicable)
{
wasteCodes.AddRange(hCode.Codes);
}
if (!UnClassNotApplicable)
{
wasteCodes.AddRange(unClass.Codes);
}
WasteCodesCollection = wasteCodes;
}
private UnClass CreateUnClass(bool notApplicable, IEnumerable <Guid> codeIds)
{
if (notApplicable)
{
return(UnClass.CreateNotApplicable());
}
var wasteCodes = Task.Run(() => wasteCodeRepository.GetWasteCodesByIds(codeIds)).Result;
return(UnClass.CreateFor(wasteCodes));
}
public void EwcCodeNull_Throws()
{
Assert.Throws <ArgumentNullException>(() => new WasteType(ImportNotificationId,
"WasteTypeName",
BaselOecdCode.CreateNotListed(),
null,
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other));
}
public void Update(string name,
BaselOecdCode baselOecdCode,
EwcCode ewcCode,
YCode yCode,
HCode hCode,
UnClass unClass)
{
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotNull(() => baselOecdCode, baselOecdCode);
Guard.ArgumentNotNull(() => ewcCode, ewcCode);
Guard.ArgumentNotNull(() => yCode, yCode);
Guard.ArgumentNotNull(() => hCode, hCode);
Guard.ArgumentNotNull(() => unClass, unClass);
Name = name;
var wasteCodes = new List <WasteTypeWasteCode>();
var existingCodes = WasteCodes.ToList();
BaselOecdCodeNotListed = baselOecdCode.NotListed;
YCodeNotApplicable = yCode.NotApplicable;
HCodeNotApplicable = hCode.NotApplicable;
UnClassNotApplicable = unClass.NotApplicable;
foreach (var code in existingCodes)
{
WasteCodesCollection.Remove(code);
}
wasteCodes.AddRange(ewcCode.Codes);
if (!BaselOecdCodeNotListed)
{
wasteCodes.Add(baselOecdCode.Code);
}
if (!YCodeNotApplicable)
{
wasteCodes.AddRange(yCode.Codes);
}
if (!HCodeNotApplicable)
{
wasteCodes.AddRange(hCode.Codes);
}
if (!UnClassNotApplicable)
{
wasteCodes.AddRange(unClass.Codes);
}
WasteCodesCollection = wasteCodes;
}
public void CanCreateWasteType()
{
var wasteType = new WasteType(ImportNotificationId,
"WasteTypeName",
BaselOecdCode.CreateFor(AnyWasteCode(CodeType.Basel)),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateFor(new[] { AnyWasteCode(CodeType.Y) }),
HCode.CreateFor(new[] { AnyWasteCode(CodeType.H) }),
UnClass.CreateFor(new[] { AnyWasteCode(CodeType.Un) }),
ChemicalComposition.Other);
Assert.IsType <WasteType>(wasteType);
}
public void UnClassNotApplicable_NotApplicableTrue()
{
var wasteType = new WasteType(ImportNotificationId,
"WasteTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.True(wasteType.UnClassNotApplicable);
}
public void UnsetChemicalComposition_Throws()
{
Assert.Throws <ArgumentException>(() => new WasteType(ImportNotificationId,
"Name",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[]
{
AnyWasteCode(CodeType.Ewc)
}),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
default(ChemicalComposition)));
}
public void BaselOecdCode_Null_Throws()
{
Assert.Throws <ArgumentNullException>(() => new WasteType(ImportNotificationId,
"WasteTypeName",
null,
EwcCode.CreateFor(new[]
{
AnyWasteCode(CodeType.Ewc)
}),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other));
}
public void ImportNotificationIdDefaultValue_Throws()
{
Assert.Throws <ArgumentException>(() => new WasteType(Guid.Empty,
"WasteTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[]
{
AnyWasteCode(CodeType.Ewc)
}),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other));
}
public void UnClassesAreSet()
{
var unCode = AnyWasteCode(CodeType.Un);
var unCodeId = new Guid("4B50E7AA-0136-444A-9185-FE31BE6CF98E");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, unCodeId, unCode);
var wasteType = new WasteType(ImportNotificationId,
"WateTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateFor(new[] { unCode }),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == unCodeId));
}
public void HCodesAreSet()
{
var hCode = AnyWasteCode(CodeType.H);
var hCodeId = new Guid("B21D8610-EBB0-436F-BD26-D2F40B42B866");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, hCodeId, hCode);
var wasteType = new WasteType(ImportNotificationId,
"WateTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateNotApplicable(),
HCode.CreateFor(new[] { hCode }),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == hCodeId));
}
public void YCodesAreSet()
{
var yCode = AnyWasteCode(CodeType.Y);
var yCodeId = new Guid("F416BD1D-56E9-45D8-9A4E-7476DF201AB2");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, yCodeId, yCode);
var wasteType = new WasteType(ImportNotificationId,
"WateTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateFor(new[] { yCode }),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == yCodeId));
}
public void EwcCodesAreSet()
{
var ewcCode = AnyWasteCode(CodeType.Ewc);
var ewcCodeId = new Guid("A4DA3323-B6BD-4245-B144-B9E05661BEC6");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, ewcCodeId, ewcCode);
var wasteType = new WasteType(ImportNotificationId,
"WateTypeName",
BaselOecdCode.CreateNotListed(),
EwcCode.CreateFor(new[] { ewcCode }),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == ewcCodeId));
}
public void OecdCodeIsSet()
{
var oecdCode = AnyWasteCode(CodeType.Oecd);
var oecdCodeId = new Guid("A58E7CE8-FA46-4E35-A3ED-26E395678CA0");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, oecdCodeId, oecdCode);
var wasteType = new WasteType(ImportNotificationId,
"WasteTypeName",
BaselOecdCode.CreateFor(oecdCode),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == oecdCodeId));
}
public void BaselCodeIsSet()
{
var baselCode = AnyWasteCode(CodeType.Basel);
var baselCodeId = new Guid("72669DEE-1126-47B3-8C45-2395F54C82D8");
ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, baselCodeId, baselCode);
var wasteType = new WasteType(ImportNotificationId,
"WasteTypeName",
BaselOecdCode.CreateFor(baselCode),
EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
YCode.CreateNotApplicable(),
HCode.CreateNotApplicable(),
UnClass.CreateNotApplicable(),
ChemicalComposition.Other);
Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == baselCodeId));
}
public UnPropertyList ReadPropertyList(UnPackage package, BinaryReader reader, UnExport export, UnClass owner)
{
return(new UE3PropertyListInstanceReader(package, reader, export, owner).Read());
}
public void AnyUnClassesWrongType_Throws(CodeType codeType)
{
Assert.Throws <ArgumentException>(() => UnClass.CreateFor(new[] { AnyWasteCode(codeType) }));
}
public UnPropertyList ReadPropertyList(UnPackage package, BinaryReader reader, UnExport export, UnClass owner)
{
return new UE3PropertyListInstanceReader(package, reader, export, owner).Read();
}
public void UnClass_CreateFor_Null_Throws()
{
Assert.Throws <ArgumentNullException>(() => UnClass.CreateFor(null));
}
