public async Task HandleAsync_SendsEmailWithSchemeName()
{
// Arrange
string emailAddress = "*****@*****.**";
var competentAuthority = new UKCompetentAuthority(Guid.NewGuid(), "Name", "Abbreviation", A.Dummy<Country>(), emailAddress);
Scheme scheme = A.Fake<Scheme>();
A.CallTo(() => scheme.CompetentAuthority)
.Returns(competentAuthority);
A.CallTo(() => scheme.SchemeName)
.Returns("Test Scheme Name");
Quarter quarter = new Quarter(2016, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
dataReturnVersion.Submit("testUserId");
var schemeSubmissionEvent = new SchemeDataReturnSubmissionEvent(dataReturnVersion);
var emailService = A.Fake<IWeeeEmailService>();
var dataAccess = A.Dummy<ISchemeDataReturnSubmissionEventHandlerDataAccess>();
var handler = new SchemeDataReturnSubmissionEventHandler(emailService, dataAccess);
// Act
await handler.HandleAsync(schemeSubmissionEvent);
// Assert
A.CallTo(() => emailService.SendSchemeDataReturnSubmitted(A<string>._, "Test Scheme Name", A<int>._, A<int>._, A<bool>._))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task FetchResultsAsync_WithUnsubmittedReturnData_ReturnsEmptyList()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amount1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Empty(results);
}
}
public void SetCurrentDataReturnVersion_ThrowsArugmentNullException()
{
// Arrange
Scheme scheme = new Scheme(Guid.NewGuid());
Quarter quarter = new Quarter(2016, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
// Act
Action action = () => dataReturn.SetCurrentVersion(null);
// Assert
Assert.Throws<ArgumentNullException>(action);
}
public void Submit_WhenNotYetSubmitted_MarksDataReturnVersionAsSubmitted()
{
// Arrange
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn);
// Act
dataReturnVersion.Submit("*****@*****.**");
// Assert
Assert.True(dataReturnVersion.IsSubmitted);
Assert.Equal(dataReturnVersion.SubmittingUserId, "*****@*****.**");
Assert.Equal(dataReturnVersion.DataReturn.Id, dataReturn.Id);
}
public void Submit_AddSubmissionEventToEventsList()
{
// Arrange
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn);
// Act
dataReturnVersion.Submit("*****@*****.**");
// Assert
Assert.Equal(1, dataReturnVersion.Events.Count());
Assert.IsType<SchemeDataReturnSubmissionEvent>(dataReturnVersion.Events.Single());
Assert.Same(dataReturnVersion, ((SchemeDataReturnSubmissionEvent)dataReturnVersion.Events.Single()).DataReturnVersion);
}
public void SetCurrentDataReturnVersion_ThrowInvalidOperationException()
{
// Arrange
Scheme scheme = new Scheme(Guid.NewGuid());
Quarter quarter = new Quarter(2016, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(new DataReturn(scheme, quarter));
// Act
Action action = () => dataReturn.SetCurrentVersion(version);
// Assert
Assert.Throws<InvalidOperationException>(action);
}
public void Submit_WhenAlreadySubmitted_ThrowInvalidOperationException()
{
// Arrange
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn);
// Act
dataReturnVersion.Submit("*****@*****.**");
// Act
Action action = () => dataReturnVersion.Submit("*****@*****.**");
// Assert
Assert.Throws<InvalidOperationException>(action);
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_DoesNotContainReturnData_WithNoDataForNewReturn_ReturnsNullReturnVersions()
{
var dataReturn = new DataReturn(A.Dummy <Scheme>(), A.Dummy <Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, null, null, null);
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
var result = await builder.Build();
Assert.Null(result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.Null(result.DataReturnVersion.WeeeDeliveredReturnVersion);
Assert.Null(result.DataReturnVersion.EeeOutputReturnVersion);
}
/// <summary>
/// 批量增加
/// </summary>
/// <typeparam name="T">泛型</typeparam>
/// <param name="model">实体</param>
/// <param name="IsTrans">是否事务</param>
/// <returns></returns>
public WriteReturn AddList <T>(List <T> list, string key = null, bool IsTrans = false, bool isLog = true) where T : class, new()
{
ConfigModel config = null;
var result = new DataReturn <T>();
var stopwatch = new Stopwatch();
stopwatch.Start();
using (var tempDb = new DataContext(key))
{
result = tempDb.AddList <T>(list, IsTrans, isLog);
config = tempDb.config;
}
stopwatch.Stop();
DbLog.LogSql(config.IsOutSql, result.sql, config.DbType, stopwatch.Elapsed.TotalMilliseconds);
return(result.writeReturn);
}
public DataReturn SaveAttachmentInRequest(JobRequestAttachmentMain model)
{
DataReturn obj = new DataReturn();
try
{
JobRequestAttachments fj = db.JobRequestAttachments.SingleOrDefault(m => m.RequestKey == model.RequestObj.RequestKey && m.DocumentTypeKey == model.DocumentTypeKey);
if (fj == null)
{
}
else
{
db.JobRequestAttachments.Remove(fj);
db.SaveChanges();
db = new RCSdbEntities();
}
JobRequestAttachments invoice = new JobRequestAttachments();
invoice.PKey = Guid.NewGuid();
invoice.RequestKey = (Guid)model.RequestObj.RequestKey;
invoice.DocumentTypeKey = model.DocumentTypeKey;
invoice.DocFile = model.fileObj.DocFile;
invoice.Filename = model.fileObj.Filename;
invoice.FileType = model.fileObj.FileType;
db.JobRequestAttachments.Add(invoice);
db.SaveChanges();
obj.flag = 1;
obj.mess = "Data has been updated successfully.";
}
catch (Exception ex)
{
obj.mess = ex.ToString();
obj.flag = 0;
}
obj.key = model.RequestObj.RequestKey;
return(obj);
}
public void AddEeeOutputAmount_WithRegisteredProducerFromAnotherComplianceYear_ThrowsInvalidOperationException()
{
// Arrange
var scheme = A.Fake <Scheme>();
A.CallTo(() => scheme.ApprovalNumber)
.Returns("WEE/SC1000SCH");
var dataReturn = new DataReturn(scheme, new Quarter(2016, QuarterType.Q2));
var dataReturnVersion = new DataReturnVersion(dataReturn);
var eeeOutputReturnVersion = new EeeOutputReturnVersion();
eeeOutputReturnVersion.AddDataReturnVersion(dataReturnVersion);
var registeredProducer = new RegisteredProducer("PRN", 2015, scheme);
// Act, Assert
Assert.Throws <InvalidOperationException>(() => eeeOutputReturnVersion.AddEeeOutputAmount(
new EeeOutputAmount(ObligationType.B2C, WeeeCategory.AutomaticDispensers, 100, registeredProducer)));
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithNoExistingWeeeDeliveredReturnVersion_ReturnsDataReturnVersionWithNewWeeeDeliveredReturnVersion()
{
var dataReturn = new DataReturn(A.Dummy <Scheme>(), A.Dummy <Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy <WeeeCollectedReturnVersion>(),
null, A.Dummy <EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotNull(result.DataReturnVersion.WeeeDeliveredReturnVersion);
Assert.Equal(1, result.DataReturnVersion.WeeeDeliveredReturnVersion.WeeeDeliveredAmounts.Count);
}
public ActionResult ChangePass(CustomerLoginClass model, string Save)
{
if (GlobalClass.SystemSession)
{
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(Save))
{
DataReturn obj = AddUserToLogin(model);
ViewBag.mess = obj.mess;
}
}
model = LoadCustomerLogin(GlobalClass.LoginUser.ContactKey);
return(View(model));
}
else
{
Exception e = new Exception("Sorry, your Session has Expired");
return(View("Error", new HandleErrorInfo(e, "Home", "Logout")));
}
}
public ActionResult Create(Prescription model)
{
if (GlobalClass.SystemSession)
{
ViewBag.mess = "Customer Configuration";
if (ModelState.IsValid)
{
DataReturn data = manage.SaveMainData(model);
ViewBag.mess = data.mess;
if (data.flag == 1)
{
GlobalClass.RxId = data.Pkey.ToString();
return(RedirectToAction("PrintPrescriptionFromIndex", "tbl_Rx", new { id = data.Pkey }));
// return RedirectToAction("PrintPrescriptionFromIndex");
}
}
var MajorAreaList = (from x in db.tbl_MajorArea
select x).OrderBy(m => m.Name);
ViewBag.MajorAreaId = new SelectList(MajorAreaList.ToList(), "Id", "Name");
var VisualAcuityLeftEyeTypeList = (from x in db.tbl_VisualAcuityType
select x).OrderBy(m => m.Name);
ViewBag.VisualAcuityLeftEyeType = new SelectList(VisualAcuityLeftEyeTypeList.ToList(), "Id", "Name");
var VisualAcuityRightEyeTypeList = (from x in db.tbl_VisualAcuityType
select x).OrderBy(m => m.Name);
ViewBag.VisualAcuityRightEyeType = new SelectList(VisualAcuityRightEyeTypeList.ToList(), "Id", "Name");
return(View(model));
}
else
{
Exception e = new Exception("Sorry, your Session has Expired");
return(View("Error", new HandleErrorInfo(e, "UserHome", "Logout")));
}
}
public void CreateResults_WithQ1FinalHolderCollectedAmountOfZero_PopulatesFinalHolderQ1AndFinalHolderTotalWithZero()
{
// Arrange
DataReturn dataReturn = new DataReturn(A.Dummy <Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
WeeeCollectedAmount weeeCollectedAmount = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.FinalHolder,
Domain.Obligation.ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
0);
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount);
dataReturn.SetCurrentVersion(dataReturnVersion);
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
A.Dummy <IWeeeAuthorization>(),
A.Dummy <IGetUkWeeeCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
// Act
IEnumerable <GetUkWeeeCsvHandler.CsvResult> results = handler.CreateResults(new List <DataReturn>()
{
dataReturn
});
// Assert
GetUkWeeeCsvHandler.CsvResult result = results
.Single(r => r.Category == WeeeCategory.LargeHouseholdAppliances && r.ObligationType == DomainObligationType.B2C);
Assert.NotNull(result);
Assert.Equal(0, result.FinalHolderQ1);
Assert.Equal(null, result.FinalHolderQ2);
Assert.Equal(null, result.FinalHolderQ3);
Assert.Equal(null, result.FinalHolderQ4);
Assert.Equal(0, result.FinalHolderTotal);
}
public void CreateResults_WithQ1DeliveredAmountOfZero_PopulatesDeliveredQ1AndDeliveredTotalWithZero()
{
// Arrange
DataReturn dataReturn = new DataReturn(A.Dummy <Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
WeeeDeliveredAmount weeeDeliveredAmount = new WeeeDeliveredAmount(
DomainObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
0,
new AatfDeliveryLocation("WEE/AA1234AA/ATF", "Facility Name"));
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount);
dataReturn.SetCurrentVersion(dataReturnVersion);
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
A.Dummy <IWeeeAuthorization>(),
A.Dummy <IGetUkWeeeCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
// Act
IEnumerable <GetUkWeeeCsvHandler.CsvResult> results = handler.CreateResults(new List <DataReturn>()
{
dataReturn
});
// Assert
GetUkWeeeCsvHandler.CsvResult result = results
.Single(r => r.Category == WeeeCategory.LargeHouseholdAppliances && r.ObligationType == DomainObligationType.B2C);
Assert.NotNull(result);
Assert.Equal(0, result.DeliveredQ1);
Assert.Equal(null, result.DeliveredQ2);
Assert.Equal(null, result.DeliveredQ3);
Assert.Equal(null, result.DeliveredQ4);
Assert.Equal(0, result.DeliveredTotal);
}
public void CreateResults_ForDataReturnVersionWithNullWeeeDeliveredDataReturnVersion_DoesNotIncludeWeeeDeliveredDataReturnVersionItemsInResults()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
authorization,
A.Dummy <IGetUkWeeeCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
var dataReturn = new DataReturn(A.Fake <Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy <WeeeCollectedReturnVersion>(), null, A.Dummy <EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
// Act
var result = handler.CreateResults(new List <DataReturn> {
dataReturn
});
// Assert
Assert.All(result, r => Assert.Null(r.DeliveredQ1));
}
public async Task Build_NoSubmittedDataReturnVersion_ReturnsDataReturnVersionWithNewData()
{
var dataReturn = new DataReturn(A.Dummy <Scheme>(), A.Dummy <Quarter>());
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddEeeOutputAmount("PRN", "ProducerName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotNull(result.DataReturnVersion);
Assert.NotNull(result.DataReturnVersion.EeeOutputReturnVersion);
Assert.NotNull(result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.NotNull(result.DataReturnVersion.WeeeDeliveredReturnVersion);
}
public DataReturn AddUserToLogin(CustomerLoginClass model)
{
DataReturn xx = new DataReturn();
try
{
CustomerLogin obj = db.CustomerLogin.Find(model.UserKey);
obj.Username = model.Username;
obj.Password = model.Password;
db.SaveChanges();
GlobalClass.UserDetail = obj;
xx.key = model.ContactObj.CustomerKey;
xx.mess = "Data is Saved Successfully";
xx.flag = 1;
}
catch (Exception ex)
{
xx.mess = ex.Message.ToString();
xx.flag = 0;
}
return(xx);
}
public void CreateResults_ForDataReturnWithNullCurrentDataReturnVersion_DoesNotIncludeDataReturnItemsInResults()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
authorization,
A.Dummy <IGetUkWeeeCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
var dataReturn = new DataReturn(A.Fake <Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
// Act
var result = handler.CreateResults(new List <DataReturn> {
dataReturn
});
// Assert
Assert.All(result, r => Assert.Null(r.DcfQ1));
Assert.All(result, r => Assert.Null(r.DistributorQ1));
Assert.All(result, r => Assert.Null(r.FinalHolderQ1));
Assert.All(result, r => Assert.Null(r.DeliveredQ1));
}
public async Task FetchResultsAsync_WithNoReturnDataForScheme_ReturnsEmptyList()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme1 = new Scheme(organisation);
Scheme scheme2 = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme1, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amount1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme2.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Empty(results);
}
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithSomeExistingWeeeCollectedAmounts_ReturnsDataReturnVersionWithExistingWeeeCollectedAmounts()
{
var weeeCollectedAmount1 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2C, WeeeCategory.DisplayEquipment, 100);
var weeeCollectedAmount2 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedAmount3 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedAmount4 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedReturnVersion = new WeeeCollectedReturnVersion();
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount1);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount2);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount3);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount4);
var dataReturn = new DataReturn(A.Dummy <Scheme>(), A.Dummy <Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, weeeCollectedReturnVersion,
A.Dummy <WeeeDeliveredReturnVersion>(), A.Dummy <EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotSame(weeeCollectedReturnVersion, result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.Collection(result.DataReturnVersion.WeeeCollectedReturnVersion.WeeeCollectedAmounts,
r1 => Assert.Same(weeeCollectedAmount2, r1),
r2 => Assert.Same(weeeCollectedAmount3, r2));
}
public async Task FetchResultsAsync_WithSeveralOutputAmounts_ReturnsSumOfAmounts()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer1 = new RegisteredProducer("WEE/AA1111AA", 2099, scheme);
RegisteredProducer registeredProducer2 = new RegisteredProducer("WEE/BB2222BB", 2099, scheme);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
EeeOutputAmount amount1 = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
100,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amount1);
EeeOutputAmount amount2 = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
200,
registeredProducer2);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amount2);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.Equal(300, result.Category1);
}
}
public async Task Build_ExistingDataReturn_ReturnsDataReturnVersionWithExistingDataReturn()
{
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddAatfDeliveredAmount("Approval Number", "Facility name", A.Dummy<WeeeCategory>(), ObligationType.B2C, A.Dummy<decimal>());
var result = await builder.Build();
Assert.Equal(dataReturn, result.DataReturnVersion.DataReturn);
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithSomeExistingEeeOutputAmounts_ReturnsDataReturnVersionWithExistingEeeOutputAmounts()
{
var registeredProducer1 = A.Fake<RegisteredProducer>();
A.CallTo(() => registeredProducer1.ProducerRegistrationNumber)
.Returns("Producer1");
A.CallTo(() => registeredProducer1.Equals(A<RegisteredProducer>._))
.Returns(true);
var registeredProducer2 = A.Fake<RegisteredProducer>();
A.CallTo(() => registeredProducer2.ProducerRegistrationNumber)
.Returns("Producer2");
A.CallTo(() => registeredProducer2.Equals(A<RegisteredProducer>._))
.Returns(true);
var eeeOutputAmount1 = new EeeOutputAmount(ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100, registeredProducer1);
var eeeOutputAmount2 = new EeeOutputAmount(ObligationType.B2C, WeeeCategory.MedicalDevices, 200, registeredProducer1);
var eeeOutputAmount3 = new EeeOutputAmount(ObligationType.B2C, WeeeCategory.ToysLeisureAndSports, 100, registeredProducer2);
var eeeOutputAmount4 = new EeeOutputAmount(ObligationType.B2C, WeeeCategory.ConsumerEquipment, 150, registeredProducer2);
var eeeOutputReturnVersion = new EeeOutputReturnVersion();
eeeOutputReturnVersion.AddEeeOutputAmount(eeeOutputAmount1);
eeeOutputReturnVersion.AddEeeOutputAmount(eeeOutputAmount2);
eeeOutputReturnVersion.AddEeeOutputAmount(eeeOutputAmount3);
eeeOutputReturnVersion.AddEeeOutputAmount(eeeOutputAmount4);
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(),
A.Dummy<WeeeDeliveredReturnVersion>(), eeeOutputReturnVersion);
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
A.CallTo(() => helper.DataAccess.GetRegisteredProducer("Producer1"))
.Returns(registeredProducer1);
A.CallTo(() => helper.DataAccess.GetRegisteredProducer("Producer2"))
.Returns(registeredProducer2);
var builder = helper.Create();
await builder.AddEeeOutputAmount("Producer1", "ProducerName", WeeeCategory.MedicalDevices, ObligationType.B2C, 200);
await builder.AddEeeOutputAmount("Producer2", "ProducerName", WeeeCategory.ToysLeisureAndSports, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotSame(eeeOutputReturnVersion, result.DataReturnVersion.EeeOutputReturnVersion);
Assert.Collection(result.DataReturnVersion.EeeOutputReturnVersion.EeeOutputAmounts,
r1 => Assert.Same(eeeOutputAmount2, r1),
r2 => Assert.Same(eeeOutputAmount3, r2));
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithSomeExistingWeeeCollectedAmounts_ReturnsDataReturnVersionWithExistingWeeeCollectedAmounts()
{
var weeeCollectedAmount1 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2C, WeeeCategory.DisplayEquipment, 100);
var weeeCollectedAmount2 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedAmount3 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedAmount4 = new WeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder, ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100);
var weeeCollectedReturnVersion = new WeeeCollectedReturnVersion();
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount1);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount2);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount3);
weeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount4);
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, weeeCollectedReturnVersion,
A.Dummy<WeeeDeliveredReturnVersion>(), A.Dummy<EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotSame(weeeCollectedReturnVersion, result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.Collection(result.DataReturnVersion.WeeeCollectedReturnVersion.WeeeCollectedAmounts,
r1 => Assert.Same(weeeCollectedAmount2, r1),
r2 => Assert.Same(weeeCollectedAmount3, r2));
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithAllExistingWeeeDeliveredAmounts_ReturnsDataReturnVersionWithExistingWeeeDeliveredReturnVersion()
{
var aatfDeliveryLocation = new AatfDeliveryLocation("ApprovalNumber", "FacilityName");
var weeeDeliveredReturnVersion = new WeeeDeliveredReturnVersion();
weeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100, aatfDeliveryLocation));
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(),
weeeDeliveredReturnVersion, A.Dummy<EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
A.CallTo(() => helper.DataAccess.GetOrAddAatfDeliveryLocation(A<string>._, A<string>._))
.Returns(aatfDeliveryLocation);
var builder = helper.Create();
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.Same(weeeDeliveredReturnVersion, result.DataReturnVersion.WeeeDeliveredReturnVersion);
}
public async Task Build_NoSubmittedDataReturnVersion_ReturnsDataReturnVersionWithNewData()
{
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddEeeOutputAmount("PRN", "ProducerName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotNull(result.DataReturnVersion);
Assert.NotNull(result.DataReturnVersion.EeeOutputReturnVersion);
Assert.NotNull(result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.NotNull(result.DataReturnVersion.WeeeDeliveredReturnVersion);
}
internal DataReturn SaveMainData(Prescription prescriptionObj)
{
DataReturn model = new DataReturn();
try
{
tbl_Rx ent = new tbl_Rx();
// ent.Id = prescriptionObj.Id;
ent.MajorAreaId = prescriptionObj.MajorAreaId;
ent.Rx = prescriptionObj.Rx;
ent.PatientId = prescriptionObj.PatientId;
ent.NextVisit = prescriptionObj.NextVisit;
ent.EntryDate = DateTime.Now;
ent.VisualAcuityLeftEye = prescriptionObj.VisualAcuityLeftEye;
ent.VisualAcuityLeftEyeType = prescriptionObj.VisualAcuityLeftEyeType;
ent.VisualAcuityRightEye = prescriptionObj.VisualAcuityRightEye;
ent.VisualAcuityRightEyeType = prescriptionObj.VisualAcuityRightEyeType;
db.tbl_Rx.Add(ent);
db.SaveChanges();
model.Pkey = ent.Id;
foreach (var drug in GlobalClass.DragList)
{
tbl_RxDrug drugEnt = new tbl_RxDrug();
drugEnt.DrugId = drug.DrugId;
drugEnt.RxId = model.Pkey;
drugEnt.Instruction = drug.Instruction;
db.tbl_RxDrug.Add(drugEnt);
db.SaveChanges();
}
foreach (var drop in GlobalClass.DropList)
{
tbl_RxDrop dropEnt = new tbl_RxDrop();
dropEnt.DropId = drop.DropId;
dropEnt.RxId = model.Pkey;
dropEnt.Instruction = drop.Instruction;
db.tbl_RxDrop.Add(dropEnt);
db.SaveChanges();
}
foreach (var invest in GlobalClass.InvestigationList)
{
tbl_RxInvestigation investEnt = new tbl_RxInvestigation();
investEnt.InvestigationId = invest.InvestigationId;
investEnt.RxId = model.Pkey;
investEnt.Instruction = invest.Instruction;
db.tbl_RxInvestigation.Add(investEnt);
db.SaveChanges();
}
model.flag = 1;
model.mess = "Data has been saved successfully.";
}
catch (Exception ex)
{
model.flag = 0;
model.mess = ex.Message.ToString();
}
return(model);
}
public async Task FetchResultsAsync_WithOneAmountOfEachTypeAndSourceAndObligationType_ReturnsResultForEachAmountWithCorrectOrdering()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer1 = new RegisteredProducer("WEE/AA9365AA", 2099, scheme);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amountCollectedDcfB2C = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDcfB2C);
WeeeCollectedAmount amountCollectedDistributor = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Distributor,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDistributor);
WeeeCollectedAmount amountCollectedFinalHolder = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.FinalHolder,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedFinalHolder);
WeeeDeliveredAmount amountDeliveredAatfB2C = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AatfDeliveryLocation("WEE/AA6845AA/ATF", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAatfB2C);
WeeeDeliveredAmount amountDeliveredAeB2C = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA2658AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAeB2C);
EeeOutputAmount amountOutputB2C = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amountOutputB2C);
WeeeCollectedAmount amountCollectedDcfB2B = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDcfB2B);
WeeeDeliveredAmount amountDeliveredAatfB2B = new WeeeDeliveredAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AatfDeliveryLocation("WEE/AA7445AA/ATF", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAatfB2B);
WeeeDeliveredAmount amountDeliveredAeB2B = new WeeeDeliveredAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA3658AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAeB2B);
EeeOutputAmount amountOutputB2B = new EeeOutputAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amountOutputB2B);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(10, results.Count);
Assert.Collection(results,
r => { Assert.Equal(0, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(2, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(2, r.Type); Assert.Equal(null, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(2, r.Type); Assert.Equal(null, r.Source); Assert.Equal("B2B", r.ObligationType); });
}
}
public void CreateResults_ForDataReturnVersionWithNullWeeeDeliveredDataReturnVersion_DoesNotIncludeWeeeDeliveredDataReturnVersionItemsInResults()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
authorization,
A.Dummy<IGetUkWeeeCsvDataAccess>(),
A.Dummy<CsvWriterFactory>());
var dataReturn = new DataReturn(A.Fake<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(), null, A.Dummy<EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
// Act
var result = handler.CreateResults(new List<DataReturn> { dataReturn });
// Assert
Assert.All(result, r => Assert.Null(r.DeliveredQ1));
}
internal DataReturn SaveMainData(JobRequestObject obj)
{
DataReturn model = new DataReturn();
try
{
JobRequest _job = new JobRequest();
_job.RequestKey = Guid.NewGuid();
_job.LocationKey = obj.LocationKey;
_job.CustomerKey = GlobalClass.LoginUser.CustomerKey;
_job.CContactKey = obj.CContactKey;
_job.TradeKey = obj.TradeKey;
_job.JobPriorityKey = obj.JobPriorityKey;
_job.ServiceNeeded = obj.ServiceNeeded;
if (string.IsNullOrEmpty(obj.ServiceNeededByOrOn))
{
_job.ServiceNeededByOrOn = "Service Needed by";
}
else
{
_job.ServiceNeededByOrOn = obj.ServiceNeededByOrOn;
}
if (obj.DNEamount == null)
{
_job.DNEamount = 0;
}
else
{
_job.DNEamount = obj.DNEamount;
}
if (string.IsNullOrEmpty(obj.SpecialNote))
{
_job.SpecialNote = "n/a";
}
else
{
_job.SpecialNote = obj.SpecialNote;
}
_job.ServiceDate = obj.ServiceDate;
if (string.IsNullOrEmpty(obj.ServiceByTime))
{
_job.ServiceByTime = "--";
}
else
{
_job.ServiceByTime = obj.ServiceByTime;
}
if (string.IsNullOrEmpty(obj.SVCLocationContact))
{
_job.SVCLocationContact = "--";
}
else
{
_job.SVCLocationContact = obj.SVCLocationContact;
}
if (string.IsNullOrEmpty(obj.SvcLocationContactPhone))
{
_job.SvcLocationContactPhone = "--";
}
else
{
_job.SvcLocationContactPhone = obj.SvcLocationContactPhone;
}
_job.EntryDatetime = DateTime.Now;
_job.IsRequest = true;
_job.Isviewed = false;
db.JobRequest.Add(_job);
db.SaveChanges();
model.flag = 1;
model.key = _job.RequestKey;
model.mess = "Data has been saved successfully.";
}
catch (Exception ex)
{
model.flag = 0;
model.mess = ex.Message.ToString();
}
return(model);
}
public async Task HandleAsync_InvokesDataAccess_GetNumberOfDataReturnSubmissionsAsync_WithCorrectParameters()
{
// Arrange
string emailAddress = "*****@*****.**";
var competentAuthority = new UKCompetentAuthority(Guid.NewGuid(), "Name", "Abbreviation", A.Dummy<Country>(), emailAddress);
Scheme scheme = A.Fake<Scheme>();
A.CallTo(() => scheme.CompetentAuthority)
.Returns(competentAuthority);
Quarter quarter = new Quarter(2016, QuarterType.Q2);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
dataReturnVersion.Submit("testUserId");
var dataAccess = A.Fake<ISchemeDataReturnSubmissionEventHandlerDataAccess>();
var emailService = A.Fake<IWeeeEmailService>();
var handler = new SchemeDataReturnSubmissionEventHandler(emailService, dataAccess);
var schemeSubmissionEvent = new SchemeDataReturnSubmissionEvent(dataReturnVersion);
// Act
await handler.HandleAsync(schemeSubmissionEvent);
// Assert
A.CallTo(() => dataAccess.GetNumberOfDataReturnSubmissionsAsync(scheme, 2016, QuarterType.Q2))
.MustHaveHappened();
}
public async Task FetchResultsAsync_WithQ1ReturnDataWithDeliveredToAeB2CAmount_ReturnsOneResultForQ1Type1Source1B2C()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeDeliveredAmount amount1 = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA1111AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.Equal(1, result.Quarter);
Assert.Equal(1, result.Type);
Assert.Equal(1, result.Source);
Assert.Equal("B2C", result.ObligationType);
}
}
public async Task FetchResultsAsync_WithOneAmountOfEachTypeAndSourceAndObligationType_ReturnsResultForEachAmountWithCorrectOrdering()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer1 = new RegisteredProducer("WEE/AA9365AA", 2099, scheme);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amountCollectedDcfB2C = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDcfB2C);
WeeeCollectedAmount amountCollectedDistributor = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Distributor,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDistributor);
WeeeCollectedAmount amountCollectedFinalHolder = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.FinalHolder,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedFinalHolder);
WeeeDeliveredAmount amountDeliveredAatfB2C = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AatfDeliveryLocation("WEE/AA6845AA/ATF", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAatfB2C);
WeeeDeliveredAmount amountDeliveredAeB2C = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA2658AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAeB2C);
EeeOutputAmount amountOutputB2C = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amountOutputB2C);
WeeeCollectedAmount amountCollectedDcfB2B = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountCollectedDcfB2B);
WeeeDeliveredAmount amountDeliveredAatfB2B = new WeeeDeliveredAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AatfDeliveryLocation("WEE/AA7445AA/ATF", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAatfB2B);
WeeeDeliveredAmount amountDeliveredAeB2B = new WeeeDeliveredAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA3658AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amountDeliveredAeB2B);
EeeOutputAmount amountOutputB2B = new EeeOutputAmount(
ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amountOutputB2B);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(10, results.Count);
Assert.Collection(results,
r => { Assert.Equal(0, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(0, r.Type); Assert.Equal(2, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(0, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(1, r.Type); Assert.Equal(1, r.Source); Assert.Equal("B2B", r.ObligationType); },
r => { Assert.Equal(2, r.Type); Assert.Equal(null, r.Source); Assert.Equal("B2C", r.ObligationType); },
r => { Assert.Equal(2, r.Type); Assert.Equal(null, r.Source); Assert.Equal("B2B", r.ObligationType); });
}
}
public void CreateResults_WithQ1DeliveredAmountOfZero_PopulatesDeliveredQ1AndDeliveredTotalWithZero()
{
// Arrange
DataReturn dataReturn = new DataReturn(A.Dummy<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
WeeeDeliveredAmount weeeDeliveredAmount = new WeeeDeliveredAmount(
DomainObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
0,
new AatfDeliveryLocation("WEE/AA1234AA/ATF", "Facility Name"));
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount);
dataReturn.SetCurrentVersion(dataReturnVersion);
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
A.Dummy<IWeeeAuthorization>(),
A.Dummy<IGetUkWeeeCsvDataAccess>(),
A.Dummy<CsvWriterFactory>());
// Act
IEnumerable<GetUkWeeeCsvHandler.CsvResult> results = handler.CreateResults(new List<DataReturn>() { dataReturn });
// Assert
GetUkWeeeCsvHandler.CsvResult result = results
.Single(r => r.Category == WeeeCategory.LargeHouseholdAppliances && r.ObligationType == DomainObligationType.B2C);
Assert.NotNull(result);
Assert.Equal(0, result.DeliveredQ1);
Assert.Equal(null, result.DeliveredQ2);
Assert.Equal(null, result.DeliveredQ3);
Assert.Equal(null, result.DeliveredQ4);
Assert.Equal(0, result.DeliveredTotal);
}
public void CreateResults_WithQ1FinalHolderCollectedAmountOfZero_PopulatesFinalHolderQ1AndFinalHolderTotalWithZero()
{
// Arrange
DataReturn dataReturn = new DataReturn(A.Dummy<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
WeeeCollectedAmount weeeCollectedAmount = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.FinalHolder,
Domain.Obligation.ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
0);
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount);
dataReturn.SetCurrentVersion(dataReturnVersion);
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
A.Dummy<IWeeeAuthorization>(),
A.Dummy<IGetUkWeeeCsvDataAccess>(),
A.Dummy<CsvWriterFactory>());
// Act
IEnumerable<GetUkWeeeCsvHandler.CsvResult> results = handler.CreateResults(new List<DataReturn>() { dataReturn });
// Assert
GetUkWeeeCsvHandler.CsvResult result = results
.Single(r => r.Category == WeeeCategory.LargeHouseholdAppliances && r.ObligationType == DomainObligationType.B2C);
Assert.NotNull(result);
Assert.Equal(0, result.FinalHolderQ1);
Assert.Equal(null, result.FinalHolderQ2);
Assert.Equal(null, result.FinalHolderQ3);
Assert.Equal(null, result.FinalHolderQ4);
Assert.Equal(0, result.FinalHolderTotal);
}
public async Task HandleAsync_WithDataReturnWithNoEee_SetsHasSubmittedEEEToFalse()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
Organisation organisation = Organisation.CreateSoleTrader("Trading Name");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer = new RegisteredProducer("WEE/AA1111AA", 2016, scheme);
Guid registeredProducerId = new Guid("75B6B4E7-BA92-477D-A6CA-C43C8C0E9823");
typeof(Entity).GetProperty("Id").SetValue(registeredProducer, registeredProducerId);
MemberUpload memberUpload = new MemberUpload(
A.Dummy<Guid>(),
"data",
new List<MemberUploadError>(),
0,
2016,
scheme,
"file.xml",
"UserID");
ProducerSubmission producerSubmission = new ProducerSubmission(
registeredProducer,
memberUpload,
A.Dummy<ProducerBusiness>(),
A.Dummy<AuthorisedRepresentative>(),
A.Dummy<DateTime>(),
A.Dummy<decimal?>(),
A.Dummy<bool>(),
A.Dummy<DateTime?>(),
A.Dummy<string>(),
A.Dummy<EEEPlacedOnMarketBandType>(),
A.Dummy<SellingTechniqueType>(),
A.Dummy<ObligationType>(),
A.Dummy<AnnualTurnOverBandType>(),
A.Dummy<List<BrandName>>(),
A.Dummy<List<SICCode>>(),
A.Dummy<ChargeBandAmount>(),
A.Dummy<decimal>());
registeredProducer.SetCurrentSubmission(producerSubmission);
DataReturn dataReturn = new DataReturn(scheme, new Quarter(2016, QuarterType.Q4));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
dataReturnVersion.Submit("UserID");
IGetProducerDetailsByRegisteredProducerIdDataAccess dataAccess = A.Fake<IGetProducerDetailsByRegisteredProducerIdDataAccess>();
A.CallTo(() => dataAccess.Fetch(registeredProducerId)).Returns(registeredProducer);
A.CallTo(() => dataAccess.FetchDataReturns(scheme, 2016)).Returns(new List<DataReturn>() { dataReturn });
GetProducerDetailsByRegisteredProducerIdHandler handler = new GetProducerDetailsByRegisteredProducerIdHandler(dataAccess, authorization);
// Act
GetProducerDetailsByRegisteredProducerId request = new GetProducerDetailsByRegisteredProducerId(registeredProducerId);
ProducerDetailsScheme result = await handler.HandleAsync(request);
// Assert
Assert.Equal(false, result.HasSubmittedEEE);
}
public async Task <DataReturnVersion> GenerateAsync(TestFileSettings settings)
{
if (settings.NumberOfAatfs < 0 || settings.NumberOfAatfs > 250)
{
throw new ArgumentOutOfRangeException("settings", "The number of AATFs specified in the settings number be in the range [0, 250].");
}
if (settings.NumberOfAes < 0 || settings.NumberOfAes > 50)
{
throw new ArgumentOutOfRangeException("settings", "The number of AEs specified in the settings number be in the range [0, 50].");
}
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeAsync(settings.OrganisationID);
Quarter quarter = new Quarter(
settings.Quarter.Year,
(QuarterType)settings.Quarter.Q);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn);
IEnumerable <ReturnItem> returnItemsCollectedFromDcf = CreateReturnItems(null);
foreach (var returnItem in returnItemsCollectedFromDcf)
{
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf,
returnItem.ObligationType,
returnItem.WeeeCategory,
returnItem.Tonnage));
}
int numberOfDeliveredToAatfs = settings.NumberOfAatfs;
int aatfApprovalNumberSeedOffset = r.Next(250);
List <string> aatfApprovalNumbers = new List <string>();
for (int index = 0; index < numberOfDeliveredToAatfs; ++index)
{
int approvalNumberSeed = (index + aatfApprovalNumberSeedOffset) % 250;
aatfApprovalNumbers.Add(GetAtfApprovalNumber(approvalNumberSeed));
}
IOrderedEnumerable <string> orderedAatfApprovalNumbers = aatfApprovalNumbers.OrderBy(x => x);
foreach (string approvalNumber in orderedAatfApprovalNumbers)
{
var deliveredToAatfs = CreateDeliveredToAatfs(approvalNumber);
foreach (var deliveredToAatf in deliveredToAatfs)
{
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(deliveredToAatf);
}
}
int numberOfDeliveredToAes = settings.NumberOfAes;
int aaeApprovalNumberSeedOffset = r.Next(50);
List <string> aaeApprovalNumbers = new List <string>();
for (int index = 0; index < numberOfDeliveredToAes; ++index)
{
int approvalNumberSeed = (index + aaeApprovalNumberSeedOffset) % 250;
aaeApprovalNumbers.Add(GetAeApprovalNumber(approvalNumberSeed));
}
IOrderedEnumerable <string> orderedAaeApprovalNumbers = aaeApprovalNumbers.OrderBy(x => x);
foreach (string approvalNumber in orderedAaeApprovalNumbers)
{
var deliveredToAes = CreateDeliveredToAes(approvalNumber);
foreach (var deliveredToAe in deliveredToAes)
{
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(deliveredToAe);
}
}
IEnumerable <ReturnItem> b2cWeeeFromDistributors = CreateReturnItems(ObligationType.B2C);
foreach (var returnItem in b2cWeeeFromDistributors)
{
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor,
returnItem.ObligationType,
returnItem.WeeeCategory,
returnItem.Tonnage));
}
IEnumerable <ReturnItem> b2cWeeeFromFinalHolders = CreateReturnItems(ObligationType.B2C);
foreach (var returnItem in b2cWeeeFromFinalHolders)
{
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder,
returnItem.ObligationType,
returnItem.WeeeCategory,
returnItem.Tonnage));
}
IList <RegisteredProducer> registeredProducers = await dataAccess.FetchRegisteredProducersAsync(scheme, quarter.Year);
int numberOfProducers;
if (settings.AllProducers)
{
numberOfProducers = registeredProducers.Count;
}
else
{
numberOfProducers = Math.Min(settings.NumberOfProduces, registeredProducers.Count);
}
IOrderedEnumerable <RegisteredProducer> producersToInclude = registeredProducers
.Shuffle()
.Take(numberOfProducers)
.OrderBy(x => x.ProducerRegistrationNumber);
foreach (RegisteredProducer producerToInclude in producersToInclude)
{
var eeeOutputAmounts = CreateEeeOutputAmounts(producerToInclude);
foreach (var eeeOutputAmount in eeeOutputAmounts)
{
dataReturnVersion.EeeOutputReturnVersion.AddEeeOutputAmount(eeeOutputAmount);
}
}
return(dataReturnVersion);
}
private void cloneWorkerDoWork(object sender, DoWorkEventArgs e,bool newversionattached)
{
// do a save of the current doc
try
{
//Always fails cause the handler returns an error to stop the normal save
Globals.ThisAddIn.Application.ActiveDocument.Save();
}
catch (Exception)
{
}
// now clone!
DataReturn dr = new DataReturn();
string newid = "";
string VersionName = "";
string VersionNumber = "";
DataReturn versionmax = _d.GetVersionMax(_matterid);
string vmax = versionmax.dt.Rows[0][0].ToString();
double vmaxint = 1;
if (vmax != null)
{
try
{
vmaxint = Convert.ToDouble(vmax) + 1;
}
catch (Exception)
{
}
}
VersionName = "Version " + vmaxint.ToString();
VersionNumber = vmaxint.ToString();
_DocumentRow["Name"] = VersionName;
_DocumentRow["Version_Number__c"] = VersionNumber;
// if there is an external id field then blank it cause we can't have 2 with the same id
if (_DocumentRow.Table.Columns.Contains("External_ID__c"))
{
_DocumentRow["External_ID__c"] = "";
}
DataReturn tempdr = _d.Save(_sDocumentObjectDef, _DocumentRow);
if (!tempdr.success)
{
dr.success = false;
dr.errormessage += tempdr.errormessage;
}
else
{
// update the version id to the new one and clear the attachment id
newid = tempdr.id;
_versionid = newid;
_attachmentid = "";
_versionclonename = VersionName;
_versionclonenumber = VersionNumber;
_versioncloneattachedmode = newversionattached;
}
e.Result = dr;
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithNoExistingWeeeDeliveredReturnVersion_ReturnsDataReturnVersionWithNewWeeeDeliveredReturnVersion()
{
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(),
null, A.Dummy<EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.NotNull(result.DataReturnVersion.WeeeDeliveredReturnVersion);
Assert.Equal(1, result.DataReturnVersion.WeeeDeliveredReturnVersion.WeeeDeliveredAmounts.Count);
}
void saveWorkerDoWork(object sender, DoWorkEventArgs e)
{
DataReturn dr = new DataReturn();
if (_DocumentChanges)
{
DataReturn tempdr = _d.Save(_sDocumentObjectDef, _DocumentRow);
if (!tempdr.success)
{
_versionid = dr.id;
dr.success = false;
dr.errormessage += tempdr.errormessage;
}
}
if (_MatterChanges)
{
DataReturn tempdr = _d.Save(_sMatterObjectDef, _MatterRow);
if (!tempdr.success)
{
_MatterRow.CancelEdit();
dr.success = false;
dr.errormessage += tempdr.errormessage;
}
else
{
_MatterRow.EndEdit();
}
}
if (_RequestChanges)
{
DataReturn tempdr = _d.Save(_sRequestObjectDef, _RequestRow);
if (!tempdr.success)
{
_RequestRow.CancelEdit();
dr.success = false;
dr.errormessage += tempdr.errormessage;
}
else
{
_RequestRow.EndEdit();
}
}
e.Result = dr;
}
public async Task Build_ExistingLatestSubmittedDataReturnVersion_WithAllExistingEeeOutputAmounts_ReturnsDataReturnVersionWithExistingEeeOutputReturnVersion()
{
var registeredProducer = A.Fake<RegisteredProducer>();
A.CallTo(() => registeredProducer.Equals(A<RegisteredProducer>._))
.Returns(true);
var eeeOutputReturnVersion = new EeeOutputReturnVersion();
eeeOutputReturnVersion.AddEeeOutputAmount(
new EeeOutputAmount(ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100, registeredProducer));
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(),
A.Dummy<WeeeDeliveredReturnVersion>(), eeeOutputReturnVersion);
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
A.CallTo(() => helper.DataAccess.GetRegisteredProducer(A<string>._))
.Returns(registeredProducer);
var builder = helper.Create();
await builder.AddEeeOutputAmount("PRN", "ProducerName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
var result = await builder.Build();
Assert.Same(eeeOutputReturnVersion, result.DataReturnVersion.EeeOutputReturnVersion);
}
public void GenerateXml_CreatesValidDataReturnsXmlFile()
{
// Arrange
var scheme = A.Fake <Scheme>();
A.CallTo(() => scheme.ApprovalNumber)
.Returns("WEE/SC0001ST/SCH");
var dataReturn = new DataReturn(scheme, new Quarter(2016, QuarterType.Q2));
var dataReturnVersion = new DataReturnVersion(dataReturn);
// WEEE collected
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2C, WeeeCategory.ElectricalAndElectronicTools, 100));
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, ObligationType.B2B, WeeeCategory.DisplayEquipment, 200));
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, ObligationType.B2C, WeeeCategory.ElectricalAndElectronicTools, 100));
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, ObligationType.B2C, WeeeCategory.ITAndTelecommsEquipment, 50));
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder, ObligationType.B2C, WeeeCategory.ElectricalAndElectronicTools, 100));
dataReturnVersion.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(
new WeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder, ObligationType.B2C, WeeeCategory.MedicalDevices, 2));
// WEEE delivered
var aatfDeliveryLocation1 = new AatfDeliveryLocation("WEE/AA0001AA/ATF", "TestAATF1");
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.LargeHouseholdAppliances, 200, aatfDeliveryLocation1));
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.PhotovoltaicPanels, 200, aatfDeliveryLocation1));
var aatfDeliveryLocation2 = new AatfDeliveryLocation("WEE/AA0002AA/ATF", "TestAATF2");
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2B, WeeeCategory.PhotovoltaicPanels, 200, aatfDeliveryLocation2));
var aeDeliveryLocation1 = new AeDeliveryLocation("WEE/AA0001AA/AE", "TestAE1");
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.LargeHouseholdAppliances, 200, aeDeliveryLocation1));
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2B, WeeeCategory.LightingEquipment, 20, aeDeliveryLocation1));
var aeDeliveryLocation2 = new AeDeliveryLocation("WEE/AA0002AA/AE", "TestAE2");
dataReturnVersion.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(
new WeeeDeliveredAmount(ObligationType.B2B, WeeeCategory.LightingEquipment, 10, aeDeliveryLocation2));
// EEE output
var registeredProducer1 = CreateRegisteredProducer(scheme, 2016, "WEE/AA0001RP", "Test Organisation1");
dataReturnVersion.EeeOutputReturnVersion.AddEeeOutputAmount(
new EeeOutputAmount(ObligationType.B2C, WeeeCategory.LightingEquipment, 3000, registeredProducer1));
dataReturnVersion.EeeOutputReturnVersion.AddEeeOutputAmount(
new EeeOutputAmount(ObligationType.B2C, WeeeCategory.PhotovoltaicPanels, 100, registeredProducer1));
var registeredProducer2 = CreateRegisteredProducer(scheme, 2016, "WEE/AA0002RP", "Test Organisation2");
dataReturnVersion.EeeOutputReturnVersion.AddEeeOutputAmount(
new EeeOutputAmount(ObligationType.B2C, WeeeCategory.PhotovoltaicPanels, 100, registeredProducer2));
var xmlGenerator = new XmlGenerator();
// Act
var generatedXml = xmlGenerator.GenerateXml(dataReturnVersion);
// Assert
var xmlSchemaHelper = new XmlSchemaHelper(@"DataReturns\v3schema.xsd");
var validationResult = xmlSchemaHelper.ValidateXml(generatedXml);
Assert.Empty(validationResult);
}
public async Task Build_ExistingLatestDataReturnVersion_WithSomeExistingWeeeDeliveredAmounts_ReturnsDataReturnVersionWithExistingWeeeDeliveredAmounts()
{
var weeeDeliveredAmount1 = new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.ConsumerEquipment, 100, new AatfDeliveryLocation("ApprovalNumber", "FacilityName"));
var weeeDeliveredAmount2 = new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.ITAndTelecommsEquipment, 200, new AatfDeliveryLocation("ApprovalNumber", "FacilityName"));
var weeeDeliveredAmount3 = new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.DisplayEquipment, 100, new AeDeliveryLocation("ApprovalNumber", "FacilityName"));
var weeeDeliveredAmount4 = new WeeeDeliveredAmount(ObligationType.B2C, WeeeCategory.LargeHouseholdAppliances, 300, new AeDeliveryLocation("ApprovalNumber", "OperatorName"));
var weeeDeliveredReturnVersion = new WeeeDeliveredReturnVersion();
weeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount1);
weeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount2);
weeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount3);
weeeDeliveredReturnVersion.AddWeeeDeliveredAmount(weeeDeliveredAmount4);
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var dataReturnVersion = new DataReturnVersion(dataReturn, A.Dummy<WeeeCollectedReturnVersion>(),
weeeDeliveredReturnVersion, A.Dummy<EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
A.CallTo(() => helper.DataAccess.GetOrAddAatfDeliveryLocation(A<string>._, A<string>._))
.Returns(new AatfDeliveryLocation("ApprovalNumber", "FacilityName"));
A.CallTo(() => helper.DataAccess.GetOrAddAeDeliveryLocation(A<string>._, A<string>._))
.Returns(new AeDeliveryLocation("ApprovalNumber", "OperatorName"));
var builder = helper.Create();
await builder.AddAatfDeliveredAmount("ApprovalNumber", "FacilityName", WeeeCategory.ConsumerEquipment, ObligationType.B2C, 100);
await builder.AddAeDeliveredAmount("ApprovalNumber", "OperatorName", WeeeCategory.LargeHouseholdAppliances, ObligationType.B2C, 300);
var result = await builder.Build();
Assert.NotSame(weeeDeliveredReturnVersion, result.DataReturnVersion.WeeeDeliveredReturnVersion);
Assert.Collection(result.DataReturnVersion.WeeeDeliveredReturnVersion.WeeeDeliveredAmounts,
r1 => Assert.Same(weeeDeliveredAmount1, r1),
r2 => Assert.Same(weeeDeliveredAmount4, r2));
}
public void CreateResults_ForDataReturnWithNullCurrentDataReturnVersion_DoesNotIncludeDataReturnItemsInResults()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
authorization,
A.Dummy<IGetUkWeeeCsvDataAccess>(),
A.Dummy<CsvWriterFactory>());
var dataReturn = new DataReturn(A.Fake<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
// Act
var result = handler.CreateResults(new List<DataReturn> { dataReturn });
// Assert
Assert.All(result, r => Assert.Null(r.DcfQ1));
Assert.All(result, r => Assert.Null(r.DistributorQ1));
Assert.All(result, r => Assert.Null(r.FinalHolderQ1));
Assert.All(result, r => Assert.Null(r.DeliveredQ1));
}
public async Task Build_NoExistingSubmittedDataReturnVersion_WithNoDataForNewReturn_ReturnsNullReturnVersions()
{
var dataReturn = new DataReturn(A.Dummy<Scheme>(), A.Dummy<Quarter>());
var helper = new DataReturnVersionBuilderHelper();
A.CallTo(() => helper.DataAccess.FetchDataReturnOrDefault())
.Returns(dataReturn);
var builder = helper.Create();
var result = await builder.Build();
Assert.Null(result.DataReturnVersion.WeeeCollectedReturnVersion);
Assert.Null(result.DataReturnVersion.WeeeDeliveredReturnVersion);
Assert.Null(result.DataReturnVersion.EeeOutputReturnVersion);
}
public void CreateResults_WithSeveralDcfCollectedAmountsInDifferentQuarters_PopulatesDcfTotalWithSum()
{
// Arrange
DataReturn dataReturn1 = new DataReturn(A.Dummy<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q2));
DataReturnVersion dataReturnVersion1 = new DataReturnVersion(dataReturn1);
WeeeCollectedAmount weeeCollectedAmount1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
DomainObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
100);
dataReturnVersion1.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount1);
dataReturn1.SetCurrentVersion(dataReturnVersion1);
DataReturn dataReturn2 = new DataReturn(A.Dummy<Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q4));
DataReturnVersion dataReturnVersion2 = new DataReturnVersion(dataReturn2);
WeeeCollectedAmount weeeCollectedAmount2 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
DomainObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
200);
dataReturnVersion2.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(weeeCollectedAmount2);
dataReturn2.SetCurrentVersion(dataReturnVersion2);
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
A.Dummy<IWeeeAuthorization>(),
A.Dummy<IGetUkWeeeCsvDataAccess>(),
A.Dummy<CsvWriterFactory>());
// Act
IEnumerable<GetUkWeeeCsvHandler.CsvResult> results = handler.CreateResults(new List<DataReturn>() { dataReturn1, dataReturn2 });
// Assert
GetUkWeeeCsvHandler.CsvResult result = results
.Single(r => r.Category == WeeeCategory.LargeHouseholdAppliances && r.ObligationType == DomainObligationType.B2C);
Assert.NotNull(result);
Assert.Equal(300, result.DcfTotal);
}
public async Task FetchResultsAsync_WithReturnDataForTowQuarters_ReturnsOneResultForEachQuarter()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter1 = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturnQ1 = new DataReturn(scheme, quarter1);
DataReturnVersion versionQ1 = new DataReturnVersion(dataReturnQ1);
WeeeCollectedAmount amountQ1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
versionQ1.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountQ1);
wrapper.WeeeContext.DataReturns.Add(dataReturnQ1);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturnQ1.SetCurrentVersion(versionQ1);
await wrapper.WeeeContext.SaveChangesAsync();
Quarter quarter2 = new Quarter(2099, QuarterType.Q2);
DataReturn dataReturnQ2 = new DataReturn(scheme, quarter2);
DataReturnVersion versionQ2 = new DataReturnVersion(dataReturnQ2);
WeeeCollectedAmount amountQ2 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
versionQ2.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amountQ2);
wrapper.WeeeContext.DataReturns.Add(dataReturnQ2);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturnQ2.SetCurrentVersion(versionQ2);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(2, results.Count);
Assert.Collection(results,
r => Assert.Equal(1, r.Quarter),
r => Assert.Equal(2, r.Quarter));
}
}
public async Task FetchResultsAsync_WithLargeHouseHoldAppliancesAmount_ReturnsNullForAllOtherCategories()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amount1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List<DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.NotNull(result.Category1);
Assert.Null(result.Category2);
Assert.Null(result.Category3);
Assert.Null(result.Category4);
Assert.Null(result.Category5);
Assert.Null(result.Category6);
Assert.Null(result.Category7);
Assert.Null(result.Category8);
Assert.Null(result.Category9);
Assert.Null(result.Category10);
Assert.Null(result.Category11);
Assert.Null(result.Category12);
Assert.Null(result.Category13);
Assert.Null(result.Category14);
}
}
public async Task <DataReturn> UploadDataAsync(IList <UploadModel> uploadModels)
{
var initialVendorCount = DataContext.Vendors.Count();
var finalVendorCount = 0;
var initialInvoiceCount = DataContext.Invoices.Count();
var finalInvoiceCount = 0;
var totalAmount = 0.00m;
var invalidCount = 0;
foreach (var model in uploadModels)
{
var isInvoiceExists = DataContext.Invoices.Any(x => x.InvoiceNumbers == model.InvoiceNumbers);
// if invoice does not exist
if (!isInvoiceExists)
{
var vendorModel = DataContext.Vendors.FirstOrDefault(x => x.VendorCode == model.VendorCode);
var vendorId = vendorModel?.VendorId;
if (vendorModel == null)
{
var newVedor = new Vendor
{
VendorCode = model.VendorCode,
VendorName = model.VendorName,
VendorType = model.VendorType
};
DataContext.Vendors.Add(newVedor);
vendorId = newVedor.VendorId;
}
var newInvoice = new Invoice
{
VendorId = vendorId.Value,
Amount = model.Amount,
DocumentDate = model.DocumentDate,
DocumentNumber = model.DocumentNumber,
DocumentType = model.DocumentType,
InvoiceNumbers = model.InvoiceNumbers,
NetDueDate = model.NetDueDate,
PostingDate = model.PostingDate,
};
DataContext.Invoices.Add(newInvoice).State = Microsoft.EntityFrameworkCore.EntityState.Added;
totalAmount += newInvoice.Amount;
//return true;
}
else
{
invalidCount++;
}
await DataContext.SaveChangesAsync().ConfigureAwait(false);
}
finalInvoiceCount = DataContext.Invoices.Count();
finalVendorCount = DataContext.Vendors.Count();
var returnModel = new DataReturn
{
TotalInvoices = finalInvoiceCount - initialInvoiceCount,
TotalVendors = finalVendorCount - initialVendorCount,
SumOfAmount = totalAmount,
InvalidInvoiceCount = invalidCount
};
return(returnModel);
}
public async Task HandleAsync_WithDataReturnWithNullEee_SetsHasSubmittedEEEToFalse()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
Organisation organisation = Organisation.CreateSoleTrader("Trading Name");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer = new RegisteredProducer("WEE/AA1111AA", 2016, scheme);
Guid registeredProducerId = new Guid("75B6B4E7-BA92-477D-A6CA-C43C8C0E9823");
typeof(Entity).GetProperty("Id").SetValue(registeredProducer, registeredProducerId);
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
"data",
new List <MemberUploadError>(),
0,
2016,
scheme,
"file.xml",
"UserID");
ProducerSubmission producerSubmission = new ProducerSubmission(
registeredProducer,
memberUpload,
A.Dummy <ProducerBusiness>(),
A.Dummy <AuthorisedRepresentative>(),
A.Dummy <DateTime>(),
A.Dummy <decimal?>(),
A.Dummy <bool>(),
A.Dummy <DateTime?>(),
A.Dummy <string>(),
A.Dummy <EEEPlacedOnMarketBandType>(),
A.Dummy <SellingTechniqueType>(),
A.Dummy <ObligationType>(),
A.Dummy <AnnualTurnOverBandType>(),
A.Dummy <List <BrandName> >(),
A.Dummy <List <SICCode> >(),
A.Dummy <ChargeBandAmount>(),
A.Dummy <decimal>(),
A.Dummy <StatusType>());
registeredProducer.SetCurrentSubmission(producerSubmission);
DataReturn dataReturn = new DataReturn(scheme, new Quarter(2016, QuarterType.Q4));
DataReturnVersion dataReturnVersion = new DataReturnVersion(dataReturn,
new WeeeCollectedReturnVersion(), new WeeeDeliveredReturnVersion(), null);
dataReturnVersion.Submit("UserID");
IGetProducerDetailsByRegisteredProducerIdDataAccess dataAccess = A.Fake <IGetProducerDetailsByRegisteredProducerIdDataAccess>();
A.CallTo(() => dataAccess.Fetch(registeredProducerId)).Returns(registeredProducer);
A.CallTo(() => dataAccess.FetchDataReturns(scheme, 2016)).Returns(new List <DataReturn>()
{
dataReturn
});
GetProducerDetailsByRegisteredProducerIdHandler handler = new GetProducerDetailsByRegisteredProducerIdHandler(dataAccess, authorization);
// Act
GetProducerDetailsByRegisteredProducerId request = new GetProducerDetailsByRegisteredProducerId(registeredProducerId);
ProducerDetailsScheme result = await handler.HandleAsync(request);
// Assert
Assert.Equal(false, result.HasSubmittedEEE);
}
