/// <summary> /// Returns a string correpsonding to the pattern 'X. Quartal' depending on /// the current date and the given quarterType enum. /// </summary> /// <param name="quarterType"></param> /// <returns></returns> public static string GetQuarterString(QuarterType quarterType) { var currentQuarter = GetQuarter(DateTime.Today); switch (quarterType) { case QuarterType.Previous: if (currentQuarter > 1) { return(string.Format("{0}. Quartal {1}", currentQuarter - 1, DateTime.Today.Year)); } else { return(string.Format("4. Quartal {0}", DateTime.Today.Year - 1)); } case QuarterType.Current: return(string.Format("{0}. Quartal {1}", currentQuarter, DateTime.Today.Year)); case QuarterType.Next: if (currentQuarter == 4) { return(string.Format("1. Quartal {0}", DateTime.Today.Year + 1)); } else { return(string.Format("{0}. Quartal {1}", currentQuarter + 1, DateTime.Today.Year)); } default: return(string.Empty); } }
/// <summary> /// Creates a DateExCondition object from the quarter. /// </summary> /// <param name="quarter">The quarter.</param> /// <returns>The DateExCondition object.</returns> public static DateExCondition FromQuarter(QuarterType quarter) { return(new DateExCondition(quarter) { expectTypeId = 2 }); }
private string WorkOutErrorMessageForNotAllowingCreateReturn(ReturnsData source) { if (!WindowHelper.IsThereAnOpenWindow(source.CurrentDate)) { return ($"The {source.CurrentDate.AddYears(-1).Year} compliance period has closed. You can start submitting your {source.CurrentDate.Year} Q1 returns on 1st April."); } foreach (Quarter q in source.OpenQuarters) { if (source.ReturnsList.Count(p => p.Quarter == q) > 0) { QuarterType nextQuarter = WorkOutNextQuarter(source.OpenQuarters); int startYear; if (nextQuarter == QuarterType.Q4) { startYear = source.NextWindow.WindowOpenDate.Year - 1; } else { startYear = source.NextWindow.WindowOpenDate.Year; } return ($"Returns have been started or submitted for all open quarters. You can start submitting your {startYear} {nextQuarter} returns on {source.NextWindow.WindowOpenDate.ToReadableDateTime()}."); } } return(NotExpectedError); }
private Return CreateSubmittedReturn(DatabaseWrapper db, QuarterType quarter, Organisation organisation) { var @return = ObligatedWeeeIntegrationCommon.CreateReturn(organisation, db.Model.AspNetUsers.First().Id, FacilityType.Aatf, 2019, quarter); @return.UpdateSubmitted(db.Model.AspNetUsers.First().Id, false); return(@return); }
public EeeValidatorBuilder() { Year = 2016; Quarter = QuarterType.Q1; Scheme = A.Fake <Scheme>(); DataAccess = A.Fake <IDataReturnVersionBuilderDataAccess>(); }
public async Task <bool> HasReturnQuarter(Guid organisationId, int year, QuarterType quarterType, EA.Weee.Core.AatfReturn.FacilityType facilityType) { return(await context.Returns .AnyAsync(r => r.Organisation.Id == organisationId && r.FacilityType.Value == (int)facilityType && r.Quarter.Year == year && (int)r.Quarter.Q == (int)quarterType)); }
public Task<int> GetNumberOfDataReturnSubmissionsAsync(Scheme scheme, int complianceYear, QuarterType quarter) { return weeeContext.DataReturnVersions .Where(d => d.SubmittedDate.HasValue) .Where(d => d.DataReturn.Scheme.Id == scheme.Id) .Where(d => d.DataReturn.Quarter.Year == complianceYear) .Where(d => d.DataReturn.Quarter.Q == quarter) .CountAsync(); }
public Quarter(int year, QuarterType q) { if (year < 1900 || year >= 3000) { throw new ArgumentOutOfRangeException("year"); } Year = year; Q = q; }
/// <summary> /// logical AND /// </summary> public static QuarterType operator &(QuarterType a, QuarterType b) { QuarterType q = new QuarterType(false, false, false, false); q.Hx_left_restricted = a.Hx_left_restricted && b.Hx_left_restricted; q.Hx_right_restricted = a.Hx_right_restricted && b.Hx_right_restricted; q.Vx_down_restricted = a.Vx_down_restricted && b.Vx_down_restricted; q.Vx_up_restricted = a.Vx_up_restricted && b.Vx_up_restricted; return(q); }
private QuarterType WorkOutNextQuarter(List <Quarter> openQuarters) { QuarterType latestOpen = openQuarters.OrderByDescending(p => p.Q).First().Q; if ((int)latestOpen == 4) { return(QuarterType.Q1); } return((QuarterType)((int)latestOpen + 1)); }
public async Task <QuarterWindow> GetNextQuarterWindow(QuarterType q, int year) { int next = q == QuarterType.Q4 ? 1 : (int)q + 1; QuarterWindowTemplate quarterWindowTemplate = await dataAccess.GetByQuarter(next); DateTime startDate = new DateTime(year + quarterWindowTemplate.AddStartYears, quarterWindowTemplate.StartMonth, quarterWindowTemplate.StartDay); DateTime endDate = new DateTime(year + quarterWindowTemplate.AddEndYears, quarterWindowTemplate.EndMonth, quarterWindowTemplate.EndDay); return(new QuarterWindow(startDate, endDate, (QuarterType)next)); }
public void Map_GivenReturnQuarter_ComplianceReturnPropertiesShouldBeSet(QuarterType quarter) { var returnsData = new ReturnsData(A.CollectionOfFake <ReturnData>(1).ToList(), new Quarter(2019, quarter), A.Fake <List <Quarter> >(), QuarterWindowTestHelper.GetDefaultQuarterWindow(), DateTime.Now); var result = returnsMap.Map(new ReturnToReturnsViewModelTransfer() { ReturnsData = returnsData }); result.ComplianceYear.Should().Be(2019); result.Quarter.Should().Be(quarter); }
public async void IndexPost_GivenOrganisationId_ReturnShouldBeCreated(QuarterType quarterType) { var model = new ReturnsViewModel() { OrganisationId = Guid.NewGuid(), ComplianceYear = 2019, Quarter = quarterType }; await controller.Index(model); A.CallTo(() => weeeClient.SendAsync(A <string> ._, A <AddReturn> .That .Matches(c => c.OrganisationId.Equals(model.OrganisationId) && c.Quarter.Equals(model.Quarter) && c.Year.Equals(model.ComplianceYear)))).MustHaveHappened(Repeated.Exactly.Once); }
private IEnumerable <WeeeDeliveredAmount> GetDeliveredAmounts( IEnumerable <DataReturn> dataReturns, Domain.Obligation.ObligationType obligationType, WeeeCategory category, QuarterType quarter) { return(dataReturns .Where(dr => dr.Quarter.Q == quarter) .Where(dr => dr.CurrentVersion != null) .Where(dr => dr.CurrentVersion.WeeeDeliveredReturnVersion != null) .SelectMany(dr => dr.CurrentVersion.WeeeDeliveredReturnVersion.WeeeDeliveredAmounts) .Where(wca => wca.ObligationType == obligationType) .Where(wca => wca.WeeeCategory == category)); }
/// <summary> /// Deletes a given QuarterType object. /// </summary> /// <param name="QuarterType"></param> public void QuarterTypeRemove(QuarterType quartertype) { try { using (NetballEntities context = new NetballEntities()) { context.Entry(quartertype).State = EntityState.Deleted; context.SaveChanges(); } } catch (Exception ex) { throw ex; } }
public async Task <Guid> HandleAsync(ProcessDataReturnXmlFile message) { Scheme scheme = await dataAccess.FetchSchemeByOrganisationIdAsync(message.OrganisationId); authorization.EnsureSchemeAccess(scheme.Id); // record XML processing start time Stopwatch stopwatch = Stopwatch.StartNew(); var xmlGeneratorResult = xmlGenerator.GenerateDataReturns <SchemeReturn>(message); DataReturnUpload dataReturnUpload; if (xmlGeneratorResult.SchemaErrors.Any()) { dataReturnUpload = new DataReturnUpload(scheme, xmlGeneratorResult.XmlString, xmlGeneratorResult.SchemaErrors.Select(e => e.ToDataReturnsUploadError()).ToList(), message.FileName, null, null); } else { int complianceYear = int.Parse(xmlGeneratorResult.DeserialisedType.ComplianceYear); QuarterType quarter = xmlGeneratorResult.DeserialisedType.ReturnPeriod.ToDomainQuarterType(); var pcsReturnVersionBuilder = dataReturnVersionBuilderDelegate(scheme, new Quarter(complianceYear, quarter)); var dataReturnVersionFromXmlBuilder = dataReturnVersionFromXmlBuilderDelegate(pcsReturnVersionBuilder); var dataReturnVersionBuilderResult = await dataReturnVersionFromXmlBuilder.Build(xmlGeneratorResult.DeserialisedType); var allErrors = (dataReturnVersionBuilderResult.ErrorData .Select(e => new DataReturnUploadError(e.ErrorLevel.ToDomainErrorLevel(), Domain.Error.UploadErrorType.Business, e.Description))) .ToList(); dataReturnUpload = new DataReturnUpload(scheme, xmlGeneratorResult.XmlString, allErrors, message.FileName, complianceYear, Convert.ToInt32(quarter)); if (!dataReturnVersionBuilderResult.ErrorData.Any(e => e.ErrorLevel == ErrorLevel.Error)) { dataReturnUpload.SetDataReturnVersion(dataReturnVersionBuilderResult.DataReturnVersion); } } // Record XML processing end time stopwatch.Stop(); dataReturnUpload.SetProcessTime(stopwatch.Elapsed); await dataAccess.AddAndSaveAsync(dataReturnUpload); return(dataReturnUpload.Id); }
public DataReturnForSubmission( Guid dataReturnUploadId, Guid organisationId, int? year, QuarterType? quarter, IReadOnlyCollection<DataReturnWarning> warnings, IReadOnlyCollection<DataReturnError> errors, bool isResubmission) { DataReturnUploadId = dataReturnUploadId; OrganisationId = organisationId; Quarter = quarter; Year = year; Warnings = warnings; Errors = errors; IsResubmission = isResubmission; }
public async Task GivenSomeCollectedWeeeExists_StoredProcedureReturnsThatDataSuccessfully() { const int complianceYear = 1372; const Domain.Obligation.ObligationType obligationType = Domain.Obligation.ObligationType.B2B; const int collectedTonnage = 179; const WeeeCategory category = WeeeCategory.AutomaticDispensers; const QuarterType quarterType = QuarterType.Q1; using (var dbWrapper = new DatabaseWrapper()) { var modelHelper = new ModelHelper(dbWrapper.Model); var org = modelHelper.CreateOrganisation(); var scheme = modelHelper.CreateScheme(org); scheme.ObligationType = (int)obligationType; var weeeCollectedReturnVersion = modelHelper.CreateWeeeCollectedReturnVersion(); modelHelper.CreateDataReturnVersion(scheme, complianceYear, (int)quarterType, true, null, weeeCollectedReturnVersion); await dbWrapper.Model.SaveChangesAsync(); var weeeCollectedAmount = modelHelper.CreateWeeeCollectedAmount(obligationType, collectedTonnage, category); modelHelper.CreateWeeeCollectedReturnVersionAmount(weeeCollectedAmount, weeeCollectedReturnVersion); await dbWrapper.Model.SaveChangesAsync(); var results = await dbWrapper.StoredProcedures.SpgSchemeWeeeCsvAsync(complianceYear, null, obligationType.ToString()); Assert.NotEmpty(results.CollectedAmounts); var collectedAmountResult = results.CollectedAmounts.Single(ca => ca.SchemeId == scheme.Id); Assert.NotNull(collectedAmountResult); Assert.Equal((int)quarterType, collectedAmountResult.QuarterType); Assert.Equal(collectedTonnage, collectedAmountResult.Tonnage); Assert.Equal((int)category, collectedAmountResult.WeeeCategory); var schemeResult = results.Schemes.Single(s => s.SchemeId == scheme.Id); Assert.NotNull(schemeResult); } }
public void CreateResults_WithSingleQuarter_PopulatesQuarterWithSum(QuarterType quarterType) { // Arrange var year = 1900 + fixture.Create <int>(); var category = fixture.Create <WeeeCategory>(); var received = fixture.Build <WeeeObligatedData>() .With(r => r.CategoryId, (int)category) .CreateMany().ToList(); var reused = fixture.Build <WeeeObligatedData>() .With(r => r.CategoryId, (int)category) .CreateMany().ToList(); var sentOn = fixture.Build <WeeeObligatedData>() .With(r => r.CategoryId, (int)category) .CreateMany().ToList(); var partialReturn = fixture.Build <PartialAatfReturn>() .With(r => r.Quarter, new Quarter(year, quarterType)) .With(r => r.ObligatedWeeeReceivedData, received) .With(r => r.ObligatedWeeeReusedData, reused) .With(r => r.ObligatedWeeeSentOnData, sentOn) .Create(); var handler = new GetUkWeeeAtAatfsCsvHandler( A.Dummy <IWeeeAuthorization>(), A.Dummy <IGetUkWeeeAtAatfsCsvDataAccess>(), A.Dummy <CsvWriterFactory>()); // Act var results = handler.CreateResults(new List <PartialAatfReturn>() { partialReturn }, year.ToString()); // Assert var result = results.SingleOrDefault(r => r.Category == category && r.TimePeriod == quarterType.ToString()); Assert.NotNull(result); Assert.Equal(received.Sum(r => r.B2B), result.B2bForTreatment); Assert.Equal(received.Sum(r => r.B2C), result.B2cForTreatment); Assert.Equal(reused.Sum(r => r.B2B), result.B2bForReuse); Assert.Equal(reused.Sum(r => r.B2C), result.B2cForReuse); Assert.Equal(sentOn.Sum(r => r.B2B), result.B2bForAatf); Assert.Equal(sentOn.Sum(r => r.B2C), result.B2cForAatf); }
public int?QuarterTypeUpdateTransaction(QuarterType quartertype) { int?quartertypeID = null; try { using (NetballEntities context = new NetballEntities()) { context.Entry(quartertype).State = EntityState.Modified; context.SaveChanges(); quartertypeID = quartertype.QuarterTypeID; } } catch (Exception ex) { throw ex; } return(quartertypeID); }
public QuarterType GetQuarterType(int quartertypeID) { QuarterType quartertype = new QuarterType(); try { using (NetballEntities context = new NetballEntities()) { context.Configuration.ProxyCreationEnabled = false; quartertype = context.QuarterTypes .Include(c => c.GameQuarters) .Where(c => c.QuarterTypeID == quartertypeID) .FirstOrDefault(); } } catch (Exception ex) { throw ex; } return(quartertype); }
private Return CreateReturn(Guid id, int year, QuarterType quarter, Organisation organisation = null, DateTime?submittedDate = null, DomainFacilityType facilityType = null) { var @return = A.Fake <Return>(); A.CallTo(() => @return.Id).Returns(id); A.CallTo(() => @return.Quarter).Returns(new Quarter(year, quarter)); A.CallTo(() => @return.SubmittedDate).Returns(submittedDate ?? fixture.Create <DateTime>()); if (organisation == null) { organisation = A.Fake <Organisation>(); A.CallTo(() => organisation.Id).Returns(fixture.Create <Guid>()); } A.CallTo(() => @return.Organisation).Returns(organisation); if (facilityType == null) { facilityType = DomainFacilityType.Aatf; } A.CallTo(() => @return.FacilityType).Returns(facilityType); return(@return); }
public QuarterWindow(DateTime windowOpenDate, DateTime windowClosedDate, QuarterType quarterType) { int startMonth; int startYear; if (quarterType == QuarterType.Q4) { startMonth = 10; startYear = windowOpenDate.Year - 1; } else { startMonth = windowOpenDate.Month - 3; startYear = windowOpenDate.Year; } QuarterStart = new DateTime(startYear, startMonth, 1); QuarterEnd = windowOpenDate.AddDays(-1); WindowOpenDate = windowOpenDate; WindowClosedDate = windowClosedDate; QuarterType = quarterType; }
/// <summary> /// Quarters house a yearNum, quarterType, and as well as a list of classes /// </summary> /// <param name="yN"></param> /// <param name="qT"></param> /// public Quarter(int yN, QuarterType qT) { classes = new ObservableCollection<Class>(); yearNum = yN; quarterType = qT; }
public async Task HandleAsync_GivenAddReturnRequest_DataAccessSubmitsIsCalled(QuarterType quarterType, FacilityType facility) { var request = new AddReturn { OrganisationId = Guid.NewGuid(), Quarter = quarterType, Year = year, FacilityType = Core.AatfReturn.FacilityType.Aatf }; var @return = A.Dummy <Return>(); var organisation = new Organisation(); var userId = Guid.NewGuid(); A.CallTo(() => userContext.UserId).Returns(userId); A.CallTo(() => genericDataAccess.GetById <Organisation>(request.OrganisationId)).Returns(organisation); A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarterType)); await handler.HandleAsync(request); A.CallTo(() => returnDataAccess.Submit(A <Return> .That.Matches(c => c.Quarter.Year == request.Year && (int)c.Quarter.Q == (int)quarterType && c.Organisation.Equals(organisation) && c.CreatedById.Equals(userId.ToString())))).MustHaveHappened(Repeated.Exactly.Once); }
public QuarterWindow(DateTime startDate, DateTime endDate, QuarterType quarterType) { StartDate = startDate; EndDate = endDate; QuarterType = quarterType; }
public Task <int> GetNumberOfDataReturnSubmissionsAsync(Scheme scheme, int complianceYear, QuarterType quarter) { return(weeeContext.DataReturnVersions .Where(d => d.SubmittedDate.HasValue) .Where(d => d.DataReturn.Scheme.Id == scheme.Id) .Where(d => d.DataReturn.Quarter.Year == complianceYear) .Where(d => d.DataReturn.Quarter.Q == quarter) .CountAsync()); }
public void IsOpen_DayAfterReportingWindowCloses_ReturnsFalse(DateTime windowOpenDate, QuarterType quarterType) { var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType); var date = new DateTime(2019, 03, 17); var result = quarter.IsOpen(date); result.Should().BeFalse(); }
public void Constructor_GivenConstructorParameters_PropertiesShouldBeSet(DateTime windowOpenDate, QuarterType quarterType) { var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType); quarter.QuarterType.Should().Be(quarterType); quarter.WindowOpenDate.Should().Be(windowOpenDate); quarter.WindowClosedDate.Should().Be(windowClosedDate); }
public void IsOpen_DayBeforeReportingWindowOpens_ReturnsFalse(DateTime windowOpenDate, int currentDay, int currentMonth, QuarterType quarterType) { var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType); var date = new DateTime(2018, currentMonth, currentDay); var result = quarter.IsOpen(date); result.Should().BeFalse(); }
public void IsOpen_DayReportingWindowOpens_ReturnsTrue(DateTime windowOpenDate, int currentMonth, int currentYear, QuarterType quarterType) { var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType); var date = new DateTime(currentYear, currentMonth, 01); var result = quarter.IsOpen(date); result.Should().BeTrue(); }
public static Return CreateReturn(Organisation organisation, string createdById, FacilityType facilityType, int year, QuarterType quarter) { if (organisation == null) { organisation = Organisation.CreateSoleTrader("Test Organisation"); } return(new Return(organisation, new Quarter(year, quarter), createdById, facilityType)); }
// return null if no quarter of this type exists public Quarter getQuarter(QuarterType qT) { foreach (Quarter q in quarters) { if (q.QuarterType.Equals(qT)) return q; } return null; }
public EeeValidatorBuilder() { Year = 2016; Quarter = QuarterType.Q1; Scheme = A.Fake<Scheme>(); DataAccess = A.Fake<IDataReturnVersionBuilderDataAccess>(); }
public async Task FetchPartialAatfReturnsForComplianceYearAsync_DoesNotIncludePreviousVersions(QuarterType quarter) { // Arrange var year = 1900 + fixture.Create <int>(); var previousId = fixture.Create <Guid>(); var id = fixture.Create <Guid>(); var organisationId = fixture.Create <Guid>(); var organisation = A.Fake <Organisation>(); A.CallTo(() => organisation.Id).Returns(organisationId); var returns = new List <Return> { CreateReturn(previousId, year, quarter, organisation, new DateTime(year, 01, 01)), CreateReturn(id, year, quarter, organisation, new DateTime(year, 01, 02)) }; var returnsDbSet = helper.GetAsyncEnabledDbSet(returns); A.CallTo(() => context.Returns).Returns(returnsDbSet); var received = new List <WeeeReceived> { CreateWeeeReceived(previousId, out var categoryReceivedPrevious, out var receivedB2bQ1Previous, out var receivedB2cQ1Previous), CreateWeeeReceived(id, out var categoryReceived, out var receivedB2bQ1, out var receivedB2cQ1) }; var receivedDbSet = helper.GetAsyncEnabledDbSet(received); A.CallTo(() => context.WeeeReceived).Returns(receivedDbSet); var reused = new List <WeeeReused> { CreateWeeeReused(previousId, out var categoryReusedPrevious, out var reusedB2bQ1Previous, out var reusedB2cQ1Previous), CreateWeeeReused(id, out var categoryReused, out var reusedB2bQ1, out var reusedB2cQ1) }; var reusedDbSet = helper.GetAsyncEnabledDbSet(reused); A.CallTo(() => context.WeeeReused).Returns(reusedDbSet); var sentOn = new List <WeeeSentOn> { CreateWeeeSentOn(previousId, out var categorySentOnPrevious, out var sentOnB2bQ1Previous, out var sentOnB2cQ1Previous), CreateWeeeSentOn(id, out var categorySentOn, out var sentOnB2bQ1, out var sentOnB2cQ1) }; var sentOnDbSet = helper.GetAsyncEnabledDbSet(sentOn); A.CallTo(() => context.WeeeSentOn).Returns(sentOnDbSet); // Act var results = await dataAccess.FetchPartialAatfReturnsForComplianceYearAsync(year); // Assert Assert.Equal(1, results.Count()); var result = results.First(); Assert.Equal(year, result.Quarter.Year); Assert.Equal(1, result.ObligatedWeeeReceivedData.Count()); AssertWeeeObligatedData(result.ObligatedWeeeReceivedData.First(), categoryReceived, receivedB2bQ1, receivedB2cQ1); Assert.Equal(1, result.ObligatedWeeeReusedData.Count()); AssertWeeeObligatedData(result.ObligatedWeeeReusedData.First(), categoryReused, reusedB2bQ1, reusedB2cQ1); Assert.Equal(1, result.ObligatedWeeeSentOnData.Count()); AssertWeeeObligatedData(result.ObligatedWeeeSentOnData.First(), categorySentOn, sentOnB2bQ1, sentOnB2cQ1); }