public static BaseValueSegmentDto CreateMockDto()
{
var baseValueSegment = new BaseValueSegmentDto
{
AsOf = new DateTime(2013, 1, 1),
AssessmentEventTransactionId = 435,
RevenueObjectId = 54,
DynCalcInstanceId = 5346,
SequenceNumber = 1,
TransactionId = 6457,
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>(),
BaseValueSegmentAssessmentRevisions = new List <AssessmentRevisionBaseValueSegmentDto>()
};
baseValueSegment.BaseValueSegmentTransactions.Add(CreateMockTransactionDto());
baseValueSegment.BaseValueSegmentAssessmentRevisions.Add(new AssessmentRevisionBaseValueSegmentDto
{
ReviewMessage = "foo bar",
BaseValueSegmentStatusType = new BaseValueSegmentStatusTypeDto {
Description = "foobar", Name = "foobar"
}
});
return(baseValueSegment);
}
public async Task <BaseValueSegmentDto> SaveAsync(int assessmentEventId, BaseValueSegmentDto baseValueSegmentDto)
{
if (baseValueSegmentDto == null)
{
throw new BadRequestException("BaseValueSegmentDto is null.");
}
var assessmentEvents = await _assessmentEventRepository.ListAsync(baseValueSegmentDto.RevenueObjectId, baseValueSegmentDto.AsOf);
// 1 based index, NOT 0-based index.
var sequenceNumber = assessmentEvents.OrderBy(x => x.Id).Select((item, index) =>
new { item.Id, Index = index }).Single(x => x.Id == assessmentEventId).Index + 1;
if (await IsExist(baseValueSegmentDto, sequenceNumber))
{
await _baseValueSegmentRepository.CreateTransactionAsync(baseValueSegmentDto.BaseValueSegmentTransactions.Single(x => x.Id.HasValue && x.Id < 0));
return(baseValueSegmentDto);
}
baseValueSegmentDto.SequenceNumber = sequenceNumber;
baseValueSegmentDto.Id = null; // Remember to null out the Id as we are about to create
// a brand new Base Value Segment!
// TODO: validate if caller sends multiple creates ie negative number
baseValueSegmentDto.BaseValueSegmentTransactions =
baseValueSegmentDto.BaseValueSegmentTransactions.Where(t => t.Id < 0).ToList();
return(await _baseValueSegmentRepository.CreateAsync(baseValueSegmentDto));
}
public async Task <Tuple <BaseValueSegmentDto, BaseValueSegmentDto> > GetCurrentAndPrevious(int assessmentEventId)
{
var assessmentEventsWithSameRevenueObjectId = (await _assessmentEventRepository.ListAsync(assessmentEventId))
.OrderBy(x => x.EventDate.Date)
.ThenBy(x => x.Id).ToList();
var selectedAssessmentEvent = assessmentEventsWithSameRevenueObjectId.SingleOrDefault(x => x.Id == assessmentEventId);
if (selectedAssessmentEvent == null)
{
throw new NotFoundException($"Assessment event Id: {assessmentEventId} is invalid.");
}
var sameDayAssessments = assessmentEventsWithSameRevenueObjectId
.Where(x => x.EventDate.Date == selectedAssessmentEvent.EventDate.Date)
.ToList();
var sequence = sameDayAssessments.Count == 1 ? 1 : sameDayAssessments.IndexOf(selectedAssessmentEvent) + 1;
List <BaseValueSegmentInfoDto> baseValueSegmentDtos = (await _baseValueSegmentRepository.GetListAsync(selectedAssessmentEvent.RevObjId))
.Where(x => x.AsOf.Date < selectedAssessmentEvent.EventDate.Date ||
(x.AsOf.Date == selectedAssessmentEvent.EventDate.Date && x.SequenceNumber <= sequence))
.OrderByDescending(x => x.AsOf.Date).ThenByDescending(x => x.SequenceNumber).ToList();
BaseValueSegmentDto current =
// ReSharper disable once PossibleInvalidOperationException
baseValueSegmentDtos.Count == 0 ? null : await _baseValueSegmentRepository.GetAsync(baseValueSegmentDtos.First().Id.Value);
BaseValueSegmentDto previous =
// ReSharper disable once PossibleInvalidOperationException
baseValueSegmentDtos.Count > 1 ? await _baseValueSegmentRepository.GetAsync(baseValueSegmentDtos[1].Id.Value) : null;
return(new Tuple <BaseValueSegmentDto, BaseValueSegmentDto>(current, previous));
}
public async Task <IEnumerable <GrmEventInformationDto> > GetOwnerGrmEvents(BaseValueSegmentDto baseValueSegmentDto)
{
// build search object
var grmEventSearchDto = new GrmEventSearchDto();
var idList = new List <int>();
var firstTransaction = baseValueSegmentDto.FirstTransaction();
// get owner grm event ids
var owners = firstTransaction.BaseValueSegmentOwners;
// ReSharper disable once PossibleInvalidOperationException
var grmEventIds = owners.Where(o => o.GRMEventId.HasValue).Select(owner => owner.GRMEventId.Value).Distinct();
idList.AddRange(grmEventIds);
// get header grm event ids
var headerValuesGrmEventIds = firstTransaction.BaseValueSegmentValueHeaders.Where(hv => hv.GRMEventId.HasValue).Select(hv => hv.GRMEventId.Value).Distinct();
idList.AddRange(headerValuesGrmEventIds);
grmEventSearchDto.GrmEventIdList.AddRange(idList.Distinct());
// call service with search object to get grm event associated to this base value segment
var eventInformationDtos = _grmEventRepository.SearchAsync(grmEventSearchDto).Result;
var effectiveDate = baseValueSegmentDto.AsOf;
var revenueObjectId = baseValueSegmentDto.RevenueObjectId;
// call service with search object to get legal parties associated to this base value segment
var grmEventInformationDtos = await _grmEventRepository.GetAsync(revenueObjectId, effectiveDate);
// return unique set
return(eventInformationDtos.Union(grmEventInformationDtos, new GrmEventInformationDtoComparer()).ToArray());
}
public void CreateBaseValueSegmentNoOwnersBadRequestExceptionIsThrown()
{
var baseValueSegment = new BaseValueSegmentDto();
baseValueSegment.BaseValueSegmentTransactions.Add(new BaseValueSegmentTransactionDto());
Should.ThrowAsync <BadRequestException>(() => _baseValueSegmentDomain.CreateAsync(baseValueSegment));
}
public void CreateBaseValueSegmentWithValidIdGetBadRequestException()
{
var baseValueSegment = new BaseValueSegmentDto {
Id = 0
};
Should.ThrowAsync <BadRequestException>(() => _baseValueSegmentDomain.CreateAsync(baseValueSegment));
}
public async Task <int[]> Create(BaseValueSegmentDto baseValueSegmentDto)
{
List <int> createdEventIds = new List <int>();
foreach (var transaction in baseValueSegmentDto.BaseValueSegmentTransactions)
{
var transactionEventIds = await CreateEventForTransaction(transaction);
createdEventIds.AddRange(transactionEventIds);
}
// return created information
return(createdEventIds.ToArray());
}
public void CreateBaseValueSegmentNoValueHeaderBadRequestExceptionIsThrown()
{
var baseValueSegment = new BaseValueSegmentDto();
baseValueSegment.BaseValueSegmentTransactions.Add(new BaseValueSegmentTransactionDto
{
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
new BaseValueSegmentOwnerDto()
}
});
Should.ThrowAsync <BadRequestException>(() => _baseValueSegmentDomain.CreateAsync(baseValueSegment));
}
private BaseValueSegmentDto MockData()
{
var owner1 = new BaseValueSegmentOwnerDto {
GRMEventId = 101
};
var owner2 = new BaseValueSegmentOwnerDto();
var owner3 = new BaseValueSegmentOwnerDto {
GRMEventId = 202
}; // Testing the distint part of the query
var owner4 = new BaseValueSegmentOwnerDto {
GRMEventId = 202
};
var transaction = new BaseValueSegmentTransactionDto();
transaction.BaseValueSegmentOwners.Add(owner1);
transaction.BaseValueSegmentOwners.Add(owner2);
transaction.BaseValueSegmentOwners.Add(owner3);
transaction.BaseValueSegmentOwners.Add(owner4);
var header1 = new BaseValueSegmentValueHeaderDto {
GRMEventId = 400
};
var header2 = new BaseValueSegmentValueHeaderDto();
var header3 = new BaseValueSegmentValueHeaderDto {
GRMEventId = 510
}; // Testing the distint part of the query
var header4 = new BaseValueSegmentValueHeaderDto {
GRMEventId = 510
};
var header5 = new BaseValueSegmentValueHeaderDto {
GRMEventId = 202
};
transaction.BaseValueSegmentValueHeaders.Add(header1);
transaction.BaseValueSegmentValueHeaders.Add(header2);
transaction.BaseValueSegmentValueHeaders.Add(header3);
transaction.BaseValueSegmentValueHeaders.Add(header4);
transaction.BaseValueSegmentValueHeaders.Add(header5);
var baseValueSegmentDto = new BaseValueSegmentDto
{
RevenueObjectId = 4565,
AsOf = new DateTime(2011, 8, 1)
};
baseValueSegmentDto.BaseValueSegmentTransactions.Add(transaction);
return(baseValueSegmentDto);
}
public void Get_CallsGetOnAssessmentEventService_ReceivesAssessmentEventServiceDomainDTO_GetRevenueObjectThrowsNotFoundException()
{
var assessmentEventId = 1;
var assessmentEventDto = new AssessmentEventDto
{
Id = assessmentEventId,
EventDate = DateTime.Now,
AsmtEventType = 999,
AsmtEventTypeDescription = "Annual",
RevObjId = 888,
DynCalcStepTrackingId = 777,
TaxYear = 2017,
TranId = 99999999999
};
var assessmentEventTranDto = new AssessmentEventTransactionDto
{
AsmtEventStateDescription = "Review Required",
AsmtEventId = assessmentEventId,
AsmtEventState = 1,
AsmtRevnEventId = 2,
Id = 4
};
assessmentEventDto.AssessmentEventTransactions.Add(assessmentEventTranDto);
var baseValueSegmentDto = new BaseValueSegmentDto()
{
AsOf = DateTime.Now,
RevenueObjectId = 999,
};
var httpClientWrapperMock = new Mock <IHttpClientWrapper>();
httpClientWrapperMock.Setup(x => x.Get <AssessmentEventDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(assessmentEventDto);
httpClientWrapperMock.Setup(x => x.Get <AssessmentEventTransactionDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(assessmentEventTranDto);
httpClientWrapperMock.Setup(x => x.Get <BaseValueSegmentDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(baseValueSegmentDto);
var applicationSettingsHelper = new Mock <IApplicationSettingsHelper>();
applicationSettingsHelper.Setup(x => x.AssessmentEventServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.RevenueObjectServiceApiUrl).Throws(new NotFoundException("something"));
applicationSettingsHelper.Setup(x => x.LegalPartyServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.BaseValueSegmentServiceApiUrl).Returns("");
var domain = new AssessmentHeaderDomain(httpClientWrapperMock.Object, applicationSettingsHelper.Object);
Should.Throw <NotFoundException>(() => domain.Get(assessmentEventId));
}
public void CreateGrmEventsFromBaseValueSegmentDtoWithoutGrmEventsForOwnerGetBadRequestException()
{
var baseValueSegment = new BaseValueSegmentDto
{
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto
{
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
new BaseValueSegmentOwnerDto
{
Id = 5235
},
new BaseValueSegmentOwnerDto
{
Id = 5238
}
}, BaseValueSegmentValueHeaders = new List <BaseValueSegmentValueHeaderDto>
{
new BaseValueSegmentValueHeaderDto
{
Id = 352523,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 2),
RevenueObjectId = 6346436,
EventType = 312455
}
},
new BaseValueSegmentValueHeaderDto
{
Id = 352528,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 3),
RevenueObjectId = 75544,
EventType = 65344
}
}
}
}
}
};
Should.Throw <BadRequestException>(() => _grmEventDomain.Create(baseValueSegment));
}
public void CreateGrmEventsFromBaseValueSegmentDtoWithoutGrmEventsForHeaderValueGetBadRequestException()
{
var baseValueSegment = new BaseValueSegmentDto
{
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto
{
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
new BaseValueSegmentOwnerDto
{
Id = 5235,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 1),
RevenueObjectId = 24661,
EventType = 34664
}
},
new BaseValueSegmentOwnerDto
{
Id = 5238,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 2, 1),
RevenueObjectId = 68656,
EventType = 9563463
}
}
}, BaseValueSegmentValueHeaders = new List <BaseValueSegmentValueHeaderDto>
{
new BaseValueSegmentValueHeaderDto
{
Id = 352523
},
new BaseValueSegmentValueHeaderDto
{
Id = 352528
}
}
}
}
};
Should.Throw <BadRequestException>(() => _grmEventDomain.Create(baseValueSegment));
}
private async Task <bool> IsExist(BaseValueSegmentDto baseValueSegmentDto, int sequenceNumber)
{
try
{
var existing = await _baseValueSegmentRepository.GetAsync(baseValueSegmentDto.RevenueObjectId,
baseValueSegmentDto.AsOf, sequenceNumber);
return(existing != null);
}
catch (NotFoundException)
{
return(false);
}
catch (RecordNotFoundException)
{
return(false);
}
}
public void ShouldGetFirstTransactionOrderedByIdFromBaseValueSegmentWhereIdIsAtLast()
{
var dto = new BaseValueSegmentDto
{
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto {
Id = 101
},
new BaseValueSegmentTransactionDto {
Id = 102
},
new BaseValueSegmentTransactionDto {
Id = 300
}
}
};
var firstTransaction = dto.FirstTransaction();
firstTransaction.Id.ShouldBe(300);
}
private HeaderValue[] GetBaseValueSegmentHeaderEvents(BaseValueSegmentDto baseValueSegmentDto, BaseValueSegmentTransactionDto transaction)
{
var headerRelatedEvents = _grmEventDomain.GetValueHeaderGrmEvents(baseValueSegmentDto).Result.ToArray();
var conclusionHeaderEvents = _baseValueSegmentRepository.GetConclusionsData(baseValueSegmentDto.RevenueObjectId, baseValueSegmentDto.AsOf).Result.ToList();
var valueHeaders = new List <HeaderValue>();
foreach (var baseValueSegmentValueHeaderDto in transaction.BaseValueSegmentValueHeaders)
{
var headerRelatedEvent = headerRelatedEvents.Single(he => he.GrmEventId == baseValueSegmentValueHeaderDto.GRMEventId);
BaseValueSegmentConclusionDto conclusionEvent = null;
if (conclusionHeaderEvents.Count > 0)
{
conclusionEvent = conclusionHeaderEvents.FirstOrDefault(conclusion => conclusion.GrmEventId == headerRelatedEvent.GrmEventId);
}
var headerValue = new HeaderValue
{
HeaderValueId = baseValueSegmentValueHeaderDto.Id,
GrmEventId = headerRelatedEvent.GrmEventId,
DisplayName = headerRelatedEvent.EventType + " " + headerRelatedEvent.EffectiveDate.Year,
BaseYear = baseValueSegmentValueHeaderDto.BaseYear,
EventDate = headerRelatedEvent.EventDate,
EventType = headerRelatedEvent.EventType,
EffectiveDate = headerRelatedEvent.EffectiveDate
};
if (conclusionEvent != null)
{
headerValue.DisplayName = conclusionEvent.Description + " " + conclusionEvent.ConclusionDate.Year;
headerValue.EventType = conclusionEvent.Description;
}
valueHeaders.Add(headerValue);
}
return(valueHeaders.OrderByDescending(vh => vh.BaseYear).ToArray());
}
[Fact] // TODO: Need to consider the new services we have added.
public void Get_CallsGetOnAssessmentEventService_ReceivesAssessmentEventServiceDomainDTOAndRevenueObjectDomainAndLegalPartyRolesDomainDTO()
{
var assessmentEventId = 1;
var assessmentEventDate = DateTime.Now;
const int asmtRevnEventId = 2;
const int asmtRevnId = 6;
const int nonPrimeLegalPartyRoleId = 3;
const int primeLegalPartyRoleId = 4;
const string primeLegalPartyDisplayName = "Prime Dude";
const string nonPrimeLegalPartyDisplayName = "Nonprime Dude";
const string tagDescription = "some TAG description";
const string firstName = "UnitTestFirstName";
const string middleName = "UnitTestMiddleName";
const string lastName = "UnitTestLastName";
const string nameSfx = "UnitTestNameSfx";
const int legalPartyRoleObjectType = 9999;
var assessmentEventDto = new AssessmentEventDto
{
Id = assessmentEventId,
EventDate = assessmentEventDate,
AsmtEventType = 999,
AsmtEventTypeDescription = "Annual",
RevObjId = 888,
DynCalcStepTrackingId = 777,
TaxYear = 2017,
TranId = 99999999999,
PrimaryBaseYear = 2015,
PrimaryBaseYearMultipleOrSingleDescription = "M"
};
var assessmentEventTranDto = new AssessmentEventTransactionDto
{
AsmtEventStateDescription = "Review Required",
AsmtEventId = assessmentEventId,
AsmtEventState = 1,
AsmtRevnEventId = asmtRevnEventId,
Id = 4
};
assessmentEventDto.AssessmentEventTransactions.Add(assessmentEventTranDto);
var assessmentRevnDto = new AssessmentRevisionDto
{
Id = asmtRevnId
};
var revenueObjectDto = new RevenueObjectDto
{
Id = 333
};
var tagDto = new TAGDto
{
Description = tagDescription
};
var legalPartyRoleDtos = new List <LegalPartyRoleDto>()
{
new LegalPartyRoleDto()
{
Id = nonPrimeLegalPartyRoleId,
PrimeLegalParty = 0,
LegalParty = new LegalPartyDto()
{
DisplayName = nonPrimeLegalPartyDisplayName,
}
},
new LegalPartyRoleDto()
{
Id = primeLegalPartyRoleId,
PrimeLegalParty = 1,
LegalParty = new LegalPartyDto()
{
Id = 100,
DisplayName = primeLegalPartyDisplayName,
FirstName = firstName,
MiddleName = middleName,
LastName = lastName,
NameSfx = nameSfx,
},
ObjectType = legalPartyRoleObjectType
}
};
var bvsTran1 = new BaseValueSegmentTransactionDto()
{
Id = 1,
BaseValueSegmentTransactionTypeId = 3,
BaseValueSegmentTransactionType = new BaseValueSegmentTransactionTypeDto()
{
Name = "Conversion",
Description = "Conversion"
}
};
var bvsTran2 = new BaseValueSegmentTransactionDto()
{
Id = 2,
BaseValueSegmentTransactionTypeId = 2,
BaseValueSegmentTransactionType = new BaseValueSegmentTransactionTypeDto()
{
Name = "User",
Description = "User"
}
};
var baseValueSegmentDto = new BaseValueSegmentDto()
{
AsOf = assessmentEventDate,
RevenueObjectId = 888,
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>()
{
bvsTran1,
bvsTran2
}
};
var statutoryReferenceDto = new StatutoryReferenceDto()
{
Description = "Test Statuatory Reference"
};
var httpClientWrapperMock = new Mock <IHttpClientWrapper>();
httpClientWrapperMock.Setup(x => x.Get <AssessmentEventDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(assessmentEventDto);
httpClientWrapperMock.Setup(x => x.Get <AssessmentRevisionDto>(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(assessmentRevnDto);
httpClientWrapperMock.Setup(x => x.Get <RevenueObjectDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(revenueObjectDto);
httpClientWrapperMock.Setup(x => x.Get <TAGDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(tagDto);
httpClientWrapperMock.Setup(x => x.Get <IList <LegalPartyRoleDto> >(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(legalPartyRoleDtos);
httpClientWrapperMock.Setup(x => x.Get <BaseValueSegmentDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(baseValueSegmentDto);
httpClientWrapperMock.Setup(x => x.Get <StatutoryReferenceDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(statutoryReferenceDto);
var applicationSettingsHelper = new Mock <IApplicationSettingsHelper>();
applicationSettingsHelper.Setup(x => x.AssessmentEventServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.RevenueObjectServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.LegalPartyServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.BaseValueSegmentServiceApiUrl).Returns("");
var domain = new AssessmentHeaderDomain(httpClientWrapperMock.Object, applicationSettingsHelper.Object);
var assessmentHeaderModel = domain.Get(assessmentEventId).Result;
assessmentHeaderModel.ShouldNotBeNull();
assessmentHeaderModel.ShouldBeOfType <Models.V1.AssessmentHeader>();
assessmentHeaderModel.AssessmentEvent.AssessmentEventId.ShouldBe(assessmentEventDto.Id);
assessmentHeaderModel.AssessmentEvent.EventDate.ShouldBe(assessmentEventDto.EventDate);
assessmentHeaderModel.AssessmentEvent.AssessmentEventType.ShouldBe(assessmentEventDto.AsmtEventType);
assessmentHeaderModel.AssessmentEvent.AssessmentEventTypeDescription.ShouldBe(assessmentEventDto.AsmtEventTypeDescription);
assessmentHeaderModel.AssessmentEvent.RevenueObjectId.ShouldBe(assessmentEventDto.RevObjId);
assessmentHeaderModel.AssessmentEvent.TaxYear.ShouldBe(assessmentEventDto.TaxYear);
assessmentHeaderModel.AssessmentEvent.EventState.ShouldBe(assessmentEventDto.AssessmentEventTransactions[0].AsmtEventStateDescription);
assessmentHeaderModel.AssessmentEvent.RevisionId.ShouldBe(assessmentRevnDto.Id);
assessmentHeaderModel.AssessmentEvent.BVSTranType.ShouldBe("User");
assessmentHeaderModel.AssessmentEvent.TransactionId.ShouldBe(4);
assessmentHeaderModel.AssessmentEvent.Note.ShouldBeNull();
assessmentHeaderModel.AssessmentEvent.ReferenceNumber.ShouldBeNull();
assessmentHeaderModel.AssessmentEvent.ChangeReason.ShouldBeNull();
assessmentHeaderModel.AssessmentEvent.RevenueAndTaxCode.ShouldBe("Test Statuatory Reference");
assessmentHeaderModel.AssessmentEvent.PrimaryBaseYear.ShouldBe(assessmentEventDto.PrimaryBaseYear);
assessmentHeaderModel.AssessmentEvent.PrimaryBaseYearMultipleOrSingleDescription.ShouldBe(assessmentEventDto.PrimaryBaseYearMultipleOrSingleDescription);
assessmentHeaderModel.RevenueObject.TAG.ShouldBe(tagDto.Description);
assessmentHeaderModel.RevenueObject.Id.ShouldBe(333);
assessmentHeaderModel.RevenueObject.Ain.ShouldBeNull();
assessmentHeaderModel.RevenueObject.AreaCd.ShouldBeNull();
assessmentHeaderModel.RevenueObject.BeginEffectiveDate.ShouldBe(DateTime.MinValue);
assessmentHeaderModel.RevenueObject.CensusBlock.ShouldBeNull();
assessmentHeaderModel.RevenueObject.CensusTrack.ShouldBeNull();
assessmentHeaderModel.RevenueObject.ClassCd.ShouldBe(0);
assessmentHeaderModel.RevenueObject.ClassCodeDescription.ShouldBeNull();
assessmentHeaderModel.RevenueObject.CountyCd.ShouldBeNull();
assessmentHeaderModel.RevenueObject.Description.ShouldBeNull();
assessmentHeaderModel.RevenueObject.EffectiveStatus.ShouldBeNull();
assessmentHeaderModel.RevenueObject.GeoCd.ShouldBeNull();
assessmentHeaderModel.RevenueObject.Pin.ShouldBeNull();
assessmentHeaderModel.RevenueObject.PropertyType.ShouldBeNull();
assessmentHeaderModel.RevenueObject.RelatedPins.ShouldBeNull();
assessmentHeaderModel.RevenueObject.RevenueCode.ShouldBeNull();
assessmentHeaderModel.RevenueObject.RightDescription.ShouldBe(0);
assessmentHeaderModel.RevenueObject.RightEstate.ShouldBe(0);
assessmentHeaderModel.RevenueObject.RightType.ShouldBe(0);
assessmentHeaderModel.RevenueObject.SitusAddress.ShouldBeNull();
assessmentHeaderModel.RevenueObject.SubType.ShouldBe(0);
assessmentHeaderModel.RevenueObject.TaxCode.ShouldBeNull();
assessmentHeaderModel.RevenueObject.Type.ShouldBe(0);
assessmentHeaderModel.RevenueObject.UnformattedPin.ShouldBeNull();
assessmentHeaderModel.RevenueObject.XCoordinate.ShouldBeNull();
assessmentHeaderModel.RevenueObject.YCoordinate.ShouldBeNull();
assessmentHeaderModel.RevenueObject.ZCoordinate.ShouldBeNull();
assessmentHeaderModel.LegalParty.DisplayName.ShouldBe(primeLegalPartyDisplayName);
assessmentHeaderModel.LegalParty.LegalPartyId.ShouldBe(100);
assessmentHeaderModel.LegalParty.FirstName.ShouldBe(firstName);
assessmentHeaderModel.LegalParty.MiddleName.ShouldBe(middleName);
assessmentHeaderModel.LegalParty.LastName.ShouldBe(lastName);
assessmentHeaderModel.LegalParty.NameSfx.ShouldBe(nameSfx);
assessmentHeaderModel.LegalParty.RevenueAcct.ShouldBe(0);
assessmentHeaderModel.LegalParty.LegalPartyRoleObjectType.ShouldBe(legalPartyRoleObjectType);
}
public void GetSubComponentsWithValidAssessmentEventId()
{
int assessmentEventId = 100;
int revenueObjectId = 200;
int bvsId = 300;
int bvsTransId = 310;
int bvsOwnerId = 320;
int bvsValueHeaderId = 330;
int bvsOwnerValueId = 340;
int bvsValueId = 350;
int transId = 400;
int legalPartyRoleId = 400;
int grmEventId = 500;
int subComponentId = 600;
int sequenceNumber = 1;
int dynCalcStepTrackingId = -100;
DateTime eventDate = new DateTime(2016, 1, 1);
DateTime effectiveDate = new DateTime(2016, 2, 1);
var baseValueSegmentCurrent = new BaseValueSegmentDto
{
AsOf = eventDate,
AssessmentEventTransactionId = 10,
BaseValueSegmentAssessmentRevisions = new List <AssessmentRevisionBaseValueSegmentDto>(),
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto
{
Id = bvsTransId,
BaseValueSegmentId = bvsId,
TransactionId = transId,
EffectiveStatus = "A",
BaseValueSegmentTransactionTypeId = 2,
BaseValueSegmentTransactionType = new BaseValueSegmentTransactionTypeDto
{
Description = "UnitTestBVSTransactionType",
Name = "UnitTestBVSTransactionType"
},
DynCalcStepTrackingId = dynCalcStepTrackingId,
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
new BaseValueSegmentOwnerDto
{
Id = bvsOwnerId,
BaseValueSegmentTransactionId = bvsTransId,
BeneficialInterestPercent = 50,
DynCalcStepTrackingId = dynCalcStepTrackingId,
GRMEventId = grmEventId,
LegalPartyRoleId = legalPartyRoleId,
BaseValueSegmentOwnerValueValues = new List <BaseValueSegmentOwnerValueDto>
{
new BaseValueSegmentOwnerValueDto
{
Id = bvsOwnerValueId,
BaseValueSegmentOwnerId = bvsOwnerId,
BaseValueSegmentValueHeaderId = bvsValueHeaderId,
BaseValue = 10000,
DynCalcStepTrackingId = dynCalcStepTrackingId
}
}
},
},
BaseValueSegmentValueHeaders = new List <BaseValueSegmentValueHeaderDto>
{
new BaseValueSegmentValueHeaderDto
{
Id = bvsValueHeaderId,
BaseValueSegmentTransactionId = bvsTransId,
GRMEventId = grmEventId,
BaseYear = 2016,
BaseValueSegmentValues = new List <BaseValueSegmentValueDto>
{
new BaseValueSegmentValueDto
{
Id = bvsValueId,
BaseValueSegmentValueHeaderId = bvsValueHeaderId,
DynCalcStepTrackingId = dynCalcStepTrackingId,
FullValueAmount = 100000,
PercentComplete = 50,
SubComponent = subComponentId,
ValueAmount = 80000
}
}
}
}
}
},
DynCalcInstanceId = -1,
Id = bvsId,
RevenueObjectId = revenueObjectId,
SequenceNumber = sequenceNumber,
TransactionId = -1000
};
var baseValueSegmentInfoList = new List <BaseValueSegmentInfoDto>
{
new BaseValueSegmentInfoDto
{
AsOf = eventDate,
Id = bvsId,
RevenueObjectId = revenueObjectId,
SequenceNumber = sequenceNumber
}
};
var assessmentEvent = new AssessmentEventDto
{
Id = assessmentEventId,
EventDate = eventDate
};
var conclusionEventsList = new List <BaseValueSegmentConclusionDto>
{
new BaseValueSegmentConclusionDto
{
ConclusionDate = eventDate,
Description = "UnitTestConclusionEvent",
GrmEventId = grmEventId
}
};
var legalPartyRoleDocumentList = new List <LegalPartyDocumentDto>
{
new LegalPartyDocumentDto
{
LegalPartyRoleId = legalPartyRoleId,
DocDate = effectiveDate,
DocNumber = "UnitTestDocument",
DocType = "Deed",
GrmEventId = grmEventId,
LegalPartyDisplayName = "Unit Test Legal Party",
PctGain = 50,
RightTransferId = 0
}
};
_legalPartyDomainRepository.Setup(x => x.GetLegalPartyRoleDocuments(It.IsAny <BaseValueSegmentDto>()))
.ReturnsAsync(legalPartyRoleDocumentList);
var valueHeaderGrmEvents = new List <GrmEventInformationDto>
{
new GrmEventInformationDto
{
GrmEventId = grmEventId,
Description = "UnitTestGrmEvent",
EventDate = eventDate,
EffectiveDate = effectiveDate,
RevenueObjectId = revenueObjectId,
EventType = "Transfer"
}
};
var marketRestrictedValues = new List <MarketAndRestrictedValueDto>
{
new MarketAndRestrictedValueDto
{
SubComponent = subComponentId,
MarketValue = 100000,
RestrictedValue = 50000
}
};
var subComponentDetailsList = new List <SubComponentDetailDto>
{
new SubComponentDetailDto
{
SubComponentId = subComponentId,
Component = "Unit Test Component",
SubComponent = "Unit Test Subcomponent"
}
};
var factorBaseYearValueDetail = new FactorBaseYearValueDetailDto
{
AssessmentYear = 2016,
Fbyv = 102000
};
_baseValueSegmentRepository.Setup(x => x.GetListAsync(revenueObjectId)).ReturnsAsync(baseValueSegmentInfoList);
Tuple <BaseValueSegmentDto, BaseValueSegmentDto> resultSet = new Tuple <BaseValueSegmentDto, BaseValueSegmentDto>(baseValueSegmentCurrent, null);
_baseValueSegmentProvider.Setup(x => x.GetCurrentAndPrevious(assessmentEventId)).ReturnsAsync(resultSet);
_assessmentEventRepository.Setup(x => x.Get(assessmentEventId)).ReturnsAsync(assessmentEvent);
_grmEventDomain.Setup(x => x.GetValueHeaderGrmEvents(It.IsAny <BaseValueSegmentDto>()))
.ReturnsAsync(valueHeaderGrmEvents.AsEnumerable);
_baseValueSegmentRepository.Setup(x => x.GetConclusionsData(It.IsAny <int>(), It.IsAny <DateTime>()))
.ReturnsAsync(conclusionEventsList.AsEnumerable);
_revenueObjectDomain.Setup(x => x.GetMarketAndRestrictedValues(It.IsAny <DateTime>(), It.IsAny <int>()))
.ReturnsAsync(marketRestrictedValues.AsEnumerable);
_baseValueSegmentRepository.Setup(x => x.GetSubComponentDetails(It.IsAny <int>(), It.IsAny <DateTime>()))
.ReturnsAsync(subComponentDetailsList.AsEnumerable);
_baseValueSegmentRepository.Setup(x => x.GetFactorBaseYearValueDetail(It.IsAny <DateTime>(),
It.IsAny <int>(), It.IsAny <decimal>(), It.IsAny <int>())).ReturnsAsync(factorBaseYearValueDetail);
var subComponent = _subComponentBaseValueSegmentDomain.Get(assessmentEventId).Result;
subComponent.ShouldNotBeNull();
subComponent.CurrentBaseValueSegment.ShouldNotBeNull();
subComponent.PreviousBaseValueSegment.ShouldBeNull();
var bvsComponent = subComponent.CurrentBaseValueSegment;
bvsComponent.ShouldNotBeNull();
bvsComponent.BaseValueSegmentTransactionTypeDescription.ShouldBe("UnitTestBVSTransactionType");
bvsComponent.EventDate.ShouldBe(eventDate);
bvsComponent.EffectiveDate.ShouldBe(effectiveDate);
bvsComponent.EventName.ShouldBe("UnitTestGrmEvent");
bvsComponent.EventType.ShouldBe("UnitTestConclusionEvent");
bvsComponent.Source.ShouldBe(baseValueSegmentCurrent);
bvsComponent.Components.Length.ShouldBeGreaterThan(0);
bvsComponent.ValueHeaders.Length.ShouldBeGreaterThan(0);
var component = bvsComponent.Components[0];
component.BaseValue.ShouldBe(80000);
component.BaseYear.ShouldBe(2016);
component.EventId.ShouldBe(grmEventId);
component.EventName.ShouldBe("UnitTestGrmEvent");
component.EventType.ShouldBe("UnitTestConclusionEvent");
component.Fbyv.ShouldBe(102000);
component.FbyvAsOfYear.ShouldBe(2016);
component.ValueHeaderId.ShouldBe(bvsValueHeaderId);
var componentDetail = component.ComponentDetails[0];
componentDetail.BaseValue.ShouldBe(80000);
componentDetail.Component.ShouldBe("Unit Test Component");
componentDetail.ComponentId.ShouldBe(0);
componentDetail.Fbyv.ShouldBe(102000);
componentDetail.SubComponent.ShouldBe("Unit Test Subcomponent");
componentDetail.SubComponentId.ShouldBe(subComponentId);
componentDetail.ValueId.ShouldBe(bvsValueId);
var valueHeader = bvsComponent.ValueHeaders[0];
valueHeader.BaseYear.ShouldBe(2016);
valueHeader.DisplayName.ShouldBe("UnitTestConclusionEvent 2016");
valueHeader.EffectiveDate.ShouldBe(effectiveDate);
valueHeader.EventDate.ShouldBe(eventDate);
valueHeader.EventType.ShouldBe("UnitTestConclusionEvent");
valueHeader.GrmEventId.ShouldBe(grmEventId);
valueHeader.HeaderValueId.ShouldBe(bvsValueHeaderId);
}
public async Task <BaseValueSegmentDto> CreateAsync(BaseValueSegmentDto baseValueSegmentDto)
{
return(await _httpClientWrapper.Post <BaseValueSegmentDto>(Url, $"{Version}/BaseValueSegments", baseValueSegmentDto));
}
private async Task <BvsDetailDto> CreateReadBvsTransactionByDetails(DateTime assessmentEventDate, BaseValueSegmentDto baseValueSegmentDto)
{
var bvsDto = new BvsDetailDto {
Source = baseValueSegmentDto
};
// get the legal parties and document information associated to base value segment
var legalPartyRoleDocuments = (await _legalPartyDomain.GetLegalPartyRoleDocuments(baseValueSegmentDto)).ToList();
// get the unique set of events defined for the this bvs and revenue object
var events = (await _grmEventDomain.GetOwnerGrmEvents(baseValueSegmentDto)).ToList();
events.PopulateEvent(bvsDto);
// take the first transaction for the bvs
bvsDto.Details = (await CreateDetails(baseValueSegmentDto.FirstTransaction(), events, legalPartyRoleDocuments, assessmentEventDate, baseValueSegmentDto.RevenueObjectId));
return(bvsDto);
}
public async Task <IActionResult> Create([FromBody] BaseValueSegmentDto baseValueSegment)
{
baseValueSegment = await _baseValueSegmentDomain.CreateAsync(baseValueSegment);
return(CreatedAtRoute(GetRouteName, new { id = baseValueSegment.Id }, baseValueSegment));
}
public static BvsOwnerDto ToBvsOwnerDto(this BaseValueSegmentDto baseValueSegmentDto)
{
return(new BvsOwnerDto {
Source = baseValueSegmentDto
});
}
public static BaseValueSegmentTransactionDto FirstTransaction(this BaseValueSegmentDto baseValueSegmentDto)
{
// sort transactions by id desc, we are going to pop the first two, first will be current next will be previous
return(baseValueSegmentDto.BaseValueSegmentTransactions.OrderByDescending(t => t.Id).First());
}
public static BaseValueSegmentDto MockData(this Mock <IBaseValueSegmentProvider> baseValueSegmentProvider, MockData mockData)
{
var ownerValueDtos = new List <BaseValueSegmentOwnerValueDto>();
var owner = new BaseValueSegmentOwnerDto
{
Id = mockData.OwnerId,
LegalPartyRoleId = 333,
BeneficialInterestPercent = mockData.BeneficialInterestPercentage,
BaseValueSegmentOwnerValueValues = ownerValueDtos
};
ownerValueDtos.Add(new BaseValueSegmentOwnerValueDto
{
BaseValue = 100,
BaseValueSegmentOwnerId = mockData.OwnerId,
BaseValueSegmentValueHeaderId = 1
});
var baseValueSegmentDto = new BaseValueSegmentDto
{
Id = mockData.BaseValueSegmentId,
AsOf = mockData.EventDate,
SequenceNumber = 1,
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto
{
Id = 31,
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
owner
},
BaseValueSegmentTransactionType = new BaseValueSegmentTransactionTypeDto
{
Description = "BaseValueSegmentTransactionTypeDescription",
Name = "BaseValueSegmentTransactionTypeName"
}
}
}
};
var legalPartyDocuments = new List <LegalPartyDocumentDto>
{
new LegalPartyDocumentDto
{
LegalPartyRoleId = 333,
LegalPartyDisplayName = mockData.DisplayName,
DocNumber = mockData.DocumentNumber,
DocType = mockData.DocumentType,
PctGain = mockData.PercentageInterestGain
}
};
mockData.LegalPartyDomain.Setup(x => x.GetLegalPartyRoleDocuments(baseValueSegmentDto)).Returns(Task.FromResult <IEnumerable <LegalPartyDocumentDto> >(legalPartyDocuments));
var events = new List <GrmEventInformationDto>
{
new GrmEventInformationDto
{
Description = mockData.GrmEventDescription,
EventType = mockData.GrmEventType,
EventDate = mockData.GrmEventDate
}
};
mockData.GrmEventDomain
.Setup(x => x.GetOwnerGrmEvents(It.Is <BaseValueSegmentDto>(y => y.Id == mockData.BaseValueSegmentId)))
.Returns(Task.FromResult <IEnumerable <GrmEventInformationDto> >(events));
var tuple = new Tuple <BaseValueSegmentDto, BaseValueSegmentDto>(baseValueSegmentDto, null);
baseValueSegmentProvider.Setup(x => x.GetCurrentAndPrevious(It.IsAny <int>()))
.Returns(Task.FromResult(tuple));
return(baseValueSegmentDto);
}
private async Task <BvsOwnerDto> CreateReadBvsTransactionByOwners(DateTime assessmentEventDate, BaseValueSegmentDto baseValueSegmentDto, int assessmentEventType)
{
var bvsDto = baseValueSegmentDto.ToBvsOwnerDto();
// get the legal parties and document information associated to base value segment
var legalPartyRoleDocuments = (await _legalPartyDomain.GetLegalPartyRoleDocuments(baseValueSegmentDto)).ToList();
// get the unique set of events defined for the this bvs and revenue object
var events = (await _grmEventDomain.GetOwnerGrmEvents(baseValueSegmentDto)).ToList();
events.PopulateEvent(bvsDto);
var firstTransaction = baseValueSegmentDto.FirstTransaction();
// take the first transaction for the bvs
bvsDto.Owners = await CreateOwners(firstTransaction, events, legalPartyRoleDocuments, assessmentEventDate, assessmentEventType);
bvsDto.ValueHeaders = GetBaseValueSegmentHeaderEvents(baseValueSegmentDto, firstTransaction);
bvsDto.BaseValueSegmentTransactionTypeDescription = firstTransaction.BaseValueSegmentTransactionType.Description;
return(bvsDto);
}
public static Repository.Models.V1.BaseValueSegment ToEntity(this BaseValueSegmentDto baseValueSegment)
{
return(Mapper.Map <Repository.Models.V1.BaseValueSegment>(baseValueSegment));
}
public void Get_CallsGetOnAssessmentEventService_ReceivesAssessmentEventServiceDomainDTO_RevenueObjectIsNull()
{
var assessmentEventId = 1;
var assessmentEventDto = new AssessmentEventDto
{
Id = assessmentEventId,
EventDate = DateTime.Now,
AsmtEventType = 999,
AsmtEventTypeDescription = "Annual",
RevObjId = 888,
DynCalcStepTrackingId = 777,
TaxYear = 2017,
TranId = 99999999999
};
var assessmentEventTranDto = new AssessmentEventTransactionDto
{
AsmtEventStateDescription = "Review Required",
AsmtEventId = assessmentEventId,
AsmtEventState = 1,
AsmtRevnEventId = 2,
Id = 4
};
assessmentEventDto.AssessmentEventTransactions.Add(assessmentEventTranDto);
var baseValueSegmentDto = new BaseValueSegmentDto()
{
AsOf = DateTime.Now,
RevenueObjectId = 999,
};
var httpClientWrapperMock = new Mock <IHttpClientWrapper>();
httpClientWrapperMock.Setup(x => x.Get <AssessmentEventDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(assessmentEventDto);
httpClientWrapperMock.Setup(x => x.Get <AssessmentEventTransactionDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(assessmentEventTranDto);
httpClientWrapperMock.Setup(x => x.Get <BaseValueSegmentDto>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(baseValueSegmentDto);
var applicationSettingsHelper = new Mock <IApplicationSettingsHelper>();
applicationSettingsHelper.Setup(x => x.AssessmentEventServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.RevenueObjectServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.LegalPartyServiceApiUrl).Returns("");
applicationSettingsHelper.Setup(x => x.BaseValueSegmentServiceApiUrl).Returns("");
var domain = new AssessmentHeaderDomain(httpClientWrapperMock.Object, applicationSettingsHelper.Object);
var assessmentHeaderModel = domain.Get(assessmentEventId).Result;
assessmentHeaderModel.ShouldNotBeNull();
assessmentHeaderModel.ShouldBeOfType <Models.V1.AssessmentHeader>();
assessmentHeaderModel.AssessmentEvent.ShouldBeOfType <AssessmentEvent>();
assessmentHeaderModel.AssessmentEvent.AssessmentEventId.ShouldBe(assessmentEventDto.Id);
assessmentHeaderModel.AssessmentEvent.EventDate.ShouldBe(assessmentEventDto.EventDate);
assessmentHeaderModel.AssessmentEvent.AssessmentEventType.ShouldBe(assessmentEventDto.AsmtEventType);
assessmentHeaderModel.AssessmentEvent.AssessmentEventTypeDescription.ShouldBe(assessmentEventDto.AsmtEventTypeDescription);
assessmentHeaderModel.AssessmentEvent.RevenueObjectId.ShouldBe(assessmentEventDto.RevObjId);
assessmentHeaderModel.AssessmentEvent.TaxYear.ShouldBe(assessmentEventDto.TaxYear);
assessmentHeaderModel.AssessmentEvent.EventState.ShouldBe(assessmentEventDto.AssessmentEventTransactions[0].AsmtEventStateDescription);
assessmentHeaderModel.AssessmentEvent.BVSTranType.ShouldBeNullOrEmpty();
assessmentHeaderModel.RevenueObject.ShouldBeNull();
}
private async Task <BvsComponenDto> CreateReadBvsTransactionByComponents(DateTime assessmentEventDate, BaseValueSegmentDto baseValueSegmentDto, int assessmentEventType)
{
var bvsDto = new BvsComponenDto {
Source = baseValueSegmentDto
};
// get the events defined for the this bvs based on the SubComponentand revenue object
var events = (await _grmEventDomain.GetValueHeaderGrmEvents(baseValueSegmentDto)).ToList();
var conclusionHeaderEvents = _baseValueSegmentRepository.GetConclusionsData(baseValueSegmentDto.RevenueObjectId, baseValueSegmentDto.AsOf).Result;
foreach (var grmEvent in events)
{
var conclusionEvent = conclusionHeaderEvents.FirstOrDefault(conclusion => conclusion.GrmEventId == grmEvent.GrmEventId);
if (conclusionEvent != null)
{
grmEvent.EventType = conclusionEvent.Description;
}
}
events.PopulateEvent(bvsDto);
// take the first transaction for the bvs
var firstTransaction = baseValueSegmentDto.FirstTransaction();
bvsDto.Components = CreateComponents(firstTransaction, events, baseValueSegmentDto.AsOf, baseValueSegmentDto.RevenueObjectId, assessmentEventDate, assessmentEventType);
bvsDto.ValueHeaders = GetBaseValueSegmentHeaderEvents(baseValueSegmentDto, firstTransaction);
bvsDto.BaseValueSegmentTransactionTypeDescription = firstTransaction.BaseValueSegmentTransactionType.Description;
// get the legal parties and document information associated to base value segment
var legalPartyRoleDocuments = (await _legalPartyDomain.GetLegalPartyRoleDocuments(baseValueSegmentDto)).ToList();
bvsDto.Owners = firstTransaction.BaseValueSegmentOwners.ToList().Select(bvsOwner =>
{
var doc = legalPartyRoleDocuments.First(d => d.LegalPartyRoleId == bvsOwner.LegalPartyRoleId);
// We are only populating 3 fields for the sub components because only the 3 fields are used for
// determing what's the base value, market values for each BI based on the ordering of these 3
// fields. These values are used to reallocate base values/ market values if they are changed by
// the user in the UI.
return(new OwnerDto
{
// We must have an Owner Id.
// ReSharper disable once PossibleInvalidOperationException
OwnerId = bvsOwner.Id.Value,
BeneficialInterest = doc.LegalPartyDisplayName,
BiPercentage = bvsOwner.BeneficialInterestPercent
});
}).ToArray();
return(bvsDto);
}
public async Task <BaseValueSegmentDto> CreateAsync(BaseValueSegmentDto baseValueSegmentDto)
{
if (baseValueSegmentDto.Id.HasValue)
{
throw new BadRequestException(string.Format("Id {0} is invalid.", baseValueSegmentDto.Id));
}
if (baseValueSegmentDto.BaseValueSegmentTransactions.Count == 0)
{
throw new BadRequestException("No Base Value Segment Transaction defined for the Base Value Segment");
}
foreach (var transaction in baseValueSegmentDto.BaseValueSegmentTransactions)
{
if (transaction.BaseValueSegmentOwners == null ||
transaction.BaseValueSegmentOwners.Count == 0)
{
throw new BadRequestException("No Base Value Segment Owners defined for the Base Value Segment Transaction");
}
if (transaction.BaseValueSegmentValueHeaders == null ||
transaction.BaseValueSegmentValueHeaders.Count == 0)
{
throw new BadRequestException("No Base Value Segment Value Headers defined for the Base Value Segment Transaction");
}
}
// We are going to create a brand new Base Value Segment. In order for EF to know,
// we are going to set all Primary Keys to 0.
var eventsCreated = await _grmEventDomain.Create(baseValueSegmentDto);
try
{
var entity = baseValueSegmentDto.ToEntity();
entity.Id = 0;
var baseValueSegmentOwnerValues = new List <BaseValueSegmentOwnerValue>();
foreach (var baseValueSegmentTransaction in entity.BaseValueSegmentTransactions)
{
PrepareTransactionForCreate(baseValueSegmentTransaction, false);
}
foreach (var assessmentRevisionBaseValueSegmentDto in entity.BaseValueSegmentAssessmentRevisions)
{
assessmentRevisionBaseValueSegmentDto.Id = 0;
assessmentRevisionBaseValueSegmentDto.BaseValueSegmentId = 0;
}
foreach (var entityBaseValueSegmentTransaction in entity.BaseValueSegmentTransactions)
{
DiscoverOwnerValuesForSavingInTransaction(() =>
_bvsRepository.GetUserTransactionType(),
() => _bvsRepository.GetUserDeletedTransactionType(),
entityBaseValueSegmentTransaction, baseValueSegmentOwnerValues);
}
foreach (var entityBaseValueSegmentAssessmentRevision in entity.BaseValueSegmentAssessmentRevisions)
{
var newStatusType = _bvsRepository.GetNewStatusType();
entityBaseValueSegmentAssessmentRevision.BaseValueSegmentStatusType = newStatusType;
entityBaseValueSegmentAssessmentRevision.BaseValueSegmentStatusTypeId = newStatusType.Id;
}
// Client side code does not necessary set this value when passing over,
// In the case of when an assessment event does not have any current BVS, then
// this issue will be seen. We are thus covering this case on the server side.
foreach (var entityBaseValueSegmentTransaction in entity.BaseValueSegmentTransactions)
{
if (string.IsNullOrEmpty(entityBaseValueSegmentTransaction.EffectiveStatus))
{
entityBaseValueSegmentTransaction.EffectiveStatus = "A";
}
}
await _bvsRepository.CreateAsync(entity, baseValueSegmentOwnerValues);
return(entity.ToDomain());
}
catch
{
_grmEventDomain.Delete(eventsCreated);
throw;
}
}
public async Task <IActionResult> Save(int baseValueSegmentId, int assessmentEventId, [FromBody] BaseValueSegmentDto baseValueSegmentDto)
{
baseValueSegmentDto = await _baseValueSegmentDomain.SaveAsync(assessmentEventId, baseValueSegmentDto);
return(CreatedAtRoute(GetBasedOnAssessmentEventIdRouteName, new { baseValueSegmentId, assessmentEventId }, baseValueSegmentDto));
}
public void CreateGrmEventsFromBaseValueSegmentDtoMappingsOccurAndGetGrmEventIdArray()
{
var baseValueSegment = new BaseValueSegmentDto
{
BaseValueSegmentTransactions = new List <BaseValueSegmentTransactionDto>
{
new BaseValueSegmentTransactionDto
{
BaseValueSegmentOwners = new List <BaseValueSegmentOwnerDto>
{
new BaseValueSegmentOwnerDto
{
Id = 5235,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 1),
RevenueObjectId = 24661,
EventType = 34664
}
},
new BaseValueSegmentOwnerDto
{
Id = 5238,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 2, 1),
RevenueObjectId = 68656,
EventType = 9563463
}
}
}, BaseValueSegmentValueHeaders = new List <BaseValueSegmentValueHeaderDto>
{
new BaseValueSegmentValueHeaderDto
{
Id = 352523,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 2),
RevenueObjectId = 6346436,
EventType = 312455
}
},
new BaseValueSegmentValueHeaderDto
{
Id = 352528,
GrmEventInformation = new GrmEventCreateInformation
{
EffectiveDateTime = new DateTime(2012, 1, 3),
RevenueObjectId = 75544,
EventType = 65344
}
}
}
}
}
};
var created = new GrmEventListCreateDto();
created.GrmEventList.Add(new GrmEventCreateDto
{
GrmEventId = 44,
ParentType = GrmEventParentType.Owner,
ParentId = 5235
});
created.GrmEventList.Add(new GrmEventCreateDto
{
GrmEventId = 45,
ParentType = GrmEventParentType.Owner,
ParentId = 5238
});
created.GrmEventList.Add(new GrmEventCreateDto
{
GrmEventId = 46,
ParentType = GrmEventParentType.HeaderValue,
ParentId = 352523
});
created.GrmEventList.Add(new GrmEventCreateDto
{
GrmEventId = 47,
ParentType = GrmEventParentType.HeaderValue,
ParentId = 352528
});
_mockRepository.Setup(x => x.CreateAsync(It.Is <GrmEventListCreateDto>(y => y.GrmEventList.Count == 4 &&
y.GrmEventList[0].ParentId == 5235 && y.GrmEventList[0].ParentType == GrmEventParentType.Owner && y.GrmEventList[0].EffectiveDateTime == new DateTime(2012, 1, 1) && y.GrmEventList[0].EventType == 34664 &&
y.GrmEventList[1].ParentId == 5238 && y.GrmEventList[1].ParentType == GrmEventParentType.Owner && y.GrmEventList[1].EffectiveDateTime == new DateTime(2012, 2, 1) && y.GrmEventList[1].EventType == 9563463 &&
y.GrmEventList[2].ParentId == 352523 && y.GrmEventList[2].ParentType == GrmEventParentType.HeaderValue && y.GrmEventList[2].EffectiveDateTime == new DateTime(2012, 1, 2) && y.GrmEventList[2].EventType == 312455 &&
y.GrmEventList[3].ParentId == 352528 && y.GrmEventList[3].ParentType == GrmEventParentType.HeaderValue && y.GrmEventList[3].EffectiveDateTime == new DateTime(2012, 1, 3) && y.GrmEventList[3].EventType == 65344)))
.ReturnsAsync(created);
var results = _grmEventDomain.Create(baseValueSegment).Result;
results.ShouldNotBeNull();
results[0].ShouldBe(44);
results[1].ShouldBe(45);
results[2].ShouldBe(46);
results[3].ShouldBe(47);
}
