private static void GetHeaderValueCreateGrmEventInformation(BaseValueSegmentTransactionDto transaction, GrmEventListCreateDto eventsToBeCreated)
{
var valueHeadersThatNeedEvents = transaction.BaseValueSegmentValueHeaders.Where(o => o.GRMEventId == null);
var baseValueSegmentValueHeaderDtos = valueHeadersThatNeedEvents as BaseValueSegmentValueHeaderDto[] ??
valueHeadersThatNeedEvents.ToArray();
var notValidHeaderValues = baseValueSegmentValueHeaderDtos.Where(v => v.GrmEventInformation == null);
if (notValidHeaderValues.Any())
{
throw new BadRequestException("No GRMEvent Id defined and no GRMEventCreateInformation was provided.");
}
foreach (var valueHeader in baseValueSegmentValueHeaderDtos)
{
eventsToBeCreated.GrmEventList.Add(
new GrmEventCreateDto
{
ParentId = valueHeader.Id,
ParentType = GrmEventParentType.HeaderValue,
EffectiveDateTime = valueHeader.GrmEventInformation.EffectiveDateTime,
RevenueObjectId = valueHeader.GrmEventInformation.RevenueObjectId,
EventType = valueHeader.GrmEventInformation.EventType
}
);
}
}
private static void GetOwnerCreateGrmEventInformation(BaseValueSegmentTransactionDto transaction, GrmEventListCreateDto eventsToBeCreated)
{
var ownersThatNeedEvents = transaction.BaseValueSegmentOwners.Where(o => o.GRMEventId == null);
var baseValueSegmentOwnerDtos = ownersThatNeedEvents as BaseValueSegmentOwnerDto[] ?? ownersThatNeedEvents.ToArray();
var notValidOwners = baseValueSegmentOwnerDtos.Where(v => v.GrmEventInformation == null);
if (notValidOwners.Any())
{
throw new BadRequestException("No GRMEvent Id defined and no GRMEventCreateInformation was provided.");
}
foreach (var owner in baseValueSegmentOwnerDtos)
{
eventsToBeCreated.GrmEventList.Add(
new GrmEventCreateDto
{
// ReSharper disable once PossibleInvalidOperationException
ParentId = owner.Id.Value,
ParentType = GrmEventParentType.Owner,
EffectiveDateTime = owner.GrmEventInformation.EffectiveDateTime,
RevenueObjectId = owner.GrmEventInformation.RevenueObjectId,
EventType = owner.GrmEventInformation.EventType
}
);
}
}
public void CreateBaseValueSegmentTransactionNoValueHeadersBadRequestExceptionIsThrown()
{
var baseValueSegmentTransaction = new BaseValueSegmentTransactionDto();
baseValueSegmentTransaction.BaseValueSegmentOwners.Add(new BaseValueSegmentOwnerDto());
Should.ThrowAsync <BadRequestException>(() => _baseValueSegmentTransactionDomain.CreateAsync(baseValueSegmentTransaction));
}
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);
}
private async Task <int[]> CreateEventForTransaction(BaseValueSegmentTransactionDto transaction)
{
GrmEventListCreateDto eventsToBeCreated = new GrmEventListCreateDto();
// get grm event that need to be created
GetOwnerCreateGrmEventInformation(transaction, eventsToBeCreated);
GetHeaderValueCreateGrmEventInformation(transaction, eventsToBeCreated);
// call grm events to create
var createdEvents = await _grmEventRepository.CreateAsync(eventsToBeCreated);
// now map back
MapOwnerCreatedGrmEventToBvs(createdEvents, transaction);
MapHeaderValueCreatedGrmEventToBvs(createdEvents, transaction);
return(createdEvents.GrmEventList.Select(e => e.GrmEventId).ToArray());
}
public async Task <BaseValueSegmentTransactionDto> CreateAsync(BaseValueSegmentTransactionDto baseValueSegmentTransactionDto)
{
if (baseValueSegmentTransactionDto.BaseValueSegmentOwners == null ||
baseValueSegmentTransactionDto.BaseValueSegmentOwners.Count == 0)
{
throw new BadRequestException("No Base Value Segment Owners defined for the Base Value Segment Transaction");
}
if (baseValueSegmentTransactionDto.BaseValueSegmentValueHeaders == null ||
baseValueSegmentTransactionDto.BaseValueSegmentValueHeaders.Count == 0)
{
throw new BadRequestException("No Base Value Segment Value Headers defined for the Base Value Segment Transaction");
}
var eventsCreated = await _grmEventDomain.CreateForTransaction(baseValueSegmentTransactionDto);
var baseValueSegmentTransaction = baseValueSegmentTransactionDto.ToEntity();
PrepareTransactionForCreate(baseValueSegmentTransaction, true);
var baseValueSegmentOwnerValues = new List <BaseValueSegmentOwnerValue>();
DiscoverOwnerValuesForSavingInTransaction(() => _baseValueSegmentRepository.GetUserTransactionType(),
() => _baseValueSegmentRepository.GetUserDeletedTransactionType(),
baseValueSegmentTransaction,
baseValueSegmentOwnerValues);
try
{
await _baseValueSegmentTransactionRepository.CreateAsync(baseValueSegmentTransaction, baseValueSegmentOwnerValues);
}
catch
{
_grmEventDomain.Delete(eventsCreated);
throw;
}
return(baseValueSegmentTransaction.ToDomain());
}
public static BaseValueSegmentTransaction ToEntity(this BaseValueSegmentTransactionDto baseValueSegmentTransactionDto)
{
return(Mapper.Map <BaseValueSegmentTransaction>(baseValueSegmentTransactionDto));
}
private async Task <OwnerDto[]> CreateOwners(BaseValueSegmentTransactionDto bvsTransaction,
List <GrmEventInformationDto> grmEventInformationDtos,
List <LegalPartyDocumentDto> legalPartyRoleDocuments,
DateTime assessmentEventDate, int assessmentEventType)
{
var ownerDtos = new List <OwnerDto>();
// now build segments and base value segment per owner
foreach (var bvsOwner in bvsTransaction.BaseValueSegmentOwners)
{
// now build assessment event dto
var owner = bvsOwner.ToOwner();
grmEventInformationDtos.PopulateEvent(owner, bvsOwner.GRMEventId);
legalPartyRoleDocuments.PopulateOwner(owner, bvsOwner);
// the legal party role document may not tie back
if (string.IsNullOrEmpty(owner.BeneficialInterest))
{
var legalPartyRole = (await _legalPartyDomain.GetLegalPartyRole(bvsOwner.LegalPartyRoleId, assessmentEventDate));
owner.BeneficialInterest = legalPartyRole.LegalParty.DisplayName;
}
owner.IsOverride = bvsOwner.IsOverride;
ownerDtos.Add(owner);
// cast so we can add our base value segments
var ownerEvents = new List <OwnerValueDto>();
foreach (var ownerValue in bvsOwner.BaseValueSegmentOwnerValueValues)
{
// get the values associated with the owner value
var valueHeaderDtos = bvsTransaction.BaseValueSegmentValueHeaders.Where(v => ownerValue.BaseValueSegmentValueHeaderId == v.Id);
foreach (var valueHeaderDto in valueHeaderDtos)
{
// now build new assessment dto
var ownerValueDto = new OwnerValueDto
{
ValueHeaderId = ownerValue.BaseValueSegmentValueHeaderId, // NEW HOW TO SELECT ITEM IN COMBO
OwnerId = bvsOwner.Id.Value,
// ReSharper disable once PossibleInvalidOperationException
OwnerValueId = ownerValue.Id.Value,
//GrmEventId = valueHeaderDto.GRMEventId, //OLD HOW TO SELECT ITEM IN COMBO
BaseYear = valueHeaderDto.BaseYear,
BaseValue = decimal.Truncate(ownerValue.BaseValue)
};
grmEventInformationDtos.PopulateEvent(ownerValueDto, valueHeaderDto.GRMEventId);
var fbyvDetail = _baseValueSegmentRepository.GetFactorBaseYearValueDetail(assessmentEventDate,
valueHeaderDto.BaseYear, ownerValue.BaseValue, assessmentEventType);
ownerValueDto.Fbyv = fbyvDetail.Result.Fbyv;
ownerValueDto.IsOverride = valueHeaderDto.BaseValueSegmentValues.Any(x => x.IsOverride == true);
ownerEvents.Add(ownerValueDto);
}
}
owner.OwnerValues = ownerEvents.ToArray();
}
//Add default sorting
ownerDtos = ownerDtos.OrderBy(x => x.BeneficialInterest)
.ThenBy(x => x.EventDate).ToList();
return(ownerDtos.ToArray());
}
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);
}
private ComponentDto[] CreateComponents(BaseValueSegmentTransactionDto bvsTransaction,
List <GrmEventInformationDto> grmEventInformationDtos,
DateTime baseValueSegmentAsOfDate,
int baseValueSegmentRevObjId,
DateTime assessmentEventDate,
int assessmentEventType)
{
var componentDtos = new List <ComponentDto>();
// now build segments and base value segment per subComponents
foreach (var bvsValueHeader in bvsTransaction.BaseValueSegmentValueHeaders)
{
// per meeting with bob do not error out if grm even information is missing, return unknown
var grmEventInformationDto = grmEventInformationDtos.FirstOrDefault(grm => grm.GrmEventId == bvsValueHeader.GRMEventId);
if (grmEventInformationDto == null)
{
continue;
}
grmEventInformationDto.RevenueObjectId = baseValueSegmentRevObjId;
var eventName = grmEventInformationDto.Description;
var eventType = grmEventInformationDto.EventType;
var eventDate = string.Format("{0:d}", grmEventInformationDto.EventDate);
var effectiveDate = string.Format("{0:d}", grmEventInformationDto.EffectiveDate);
var subComponentDetailDtos = _baseValueSegmentRepository.GetSubComponentDetails(baseValueSegmentRevObjId, baseValueSegmentAsOfDate).Result.ToList();
// Build Component dto
var component = new ComponentDto
{
EventName = eventName,
EventType = eventType,
EventDate = eventDate,
EffectiveDate = effectiveDate,
EventId = bvsValueHeader.GRMEventId,
BaseYear = bvsValueHeader.BaseYear,
FbyvAsOfYear = (grmEventInformationDto.EventDate.Month < 7) ? grmEventInformationDto.EventDate.Year : grmEventInformationDto.EventDate.Year + 1,
ValueHeaderId = bvsValueHeader.Id
};
// Build Component Details
var componentDetails = new List <ComponentDetailDto>();
foreach (var value in bvsValueHeader.BaseValueSegmentValues)
{
var subComponentDetail = subComponentDetailDtos.FirstOrDefault(x => x.SubComponentId == value.SubComponent);
int componentId = -1;
int subComponentId = -1;
string componentName = Constants.ComponentUnknownName;
string subComponentName = Constants.SubComponentUnknownName;
if (subComponentDetail != null)
{
componentId = subComponentDetail.ComponentTypeId;
subComponentId = subComponentDetail.SubComponentId;
componentName = subComponentDetail.Component;
subComponentName = subComponentDetail.SubComponent;
}
// build new component detail dto
var componentDetail = new ComponentDetailDto
{
ComponentId = componentId,
Component = componentName,
SubComponentId = subComponentId,
SubComponent = subComponentName,
BaseValue = decimal.Truncate(value.ValueAmount),
// ReSharper disable once PossibleInvalidOperationException
ValueId = value.Id.Value
};
var fbyvDetail = _baseValueSegmentRepository.GetFactorBaseYearValueDetail(assessmentEventDate,
bvsValueHeader.BaseYear, value.ValueAmount, assessmentEventType);
componentDetail.Fbyv = fbyvDetail.Result.Fbyv;
componentDetail.IsOverride = value.IsOverride;
componentDetails.Add(componentDetail);
}
component.IsOverride = bvsValueHeader.BaseValueSegmentValues.All(x => x.IsOverride == true);
component.ComponentDetails = componentDetails;
componentDtos.Add(component);
}
//Add default sorting
componentDtos = componentDtos.OrderBy(x => x.BaseYear)
.ThenBy(x => x.EffectiveDate).ToList();
return(componentDtos.ToArray());
}
public async Task CreateTransactionAsync(BaseValueSegmentTransactionDto baseValueSegmentTransactionDto)
{
await _httpClientWrapper.Post <BaseValueSegmentTransactionDto>(Url, $"{Version}/BaseValueSegments/Transactions", baseValueSegmentTransactionDto);
}
private static void MapOwnerCreatedGrmEventToBvs(GrmEventListCreateDto createdEvents, BaseValueSegmentTransactionDto transaction)
{
var ownerCreated = createdEvents.GrmEventList.Where(o => o.ParentType == GrmEventParentType.Owner);
foreach (var ownerGrmEvent in ownerCreated)
{
var owner = transaction.BaseValueSegmentOwners.Single(o => o.Id == ownerGrmEvent.ParentId);
owner.GRMEventId = ownerGrmEvent.GrmEventId;
}
}
private static void MapHeaderValueCreatedGrmEventToBvs(GrmEventListCreateDto createdEvents, BaseValueSegmentTransactionDto transaction)
{
var headerValueCreated = createdEvents.GrmEventList.Where(o => o.ParentType == GrmEventParentType.HeaderValue);
foreach (var headerGrmEvent in headerValueCreated)
{
var header = transaction.BaseValueSegmentValueHeaders.Single(h => h.Id == headerGrmEvent.ParentId);
header.GRMEventId = headerGrmEvent.GrmEventId;
}
}
public async Task <int[]> CreateForTransaction(BaseValueSegmentTransactionDto transaction)
{
var transactionEventIds = await CreateEventForTransaction(transaction);
return(transactionEventIds.ToArray());
}
private async Task <DetailDto[]> CreateDetails(BaseValueSegmentTransactionDto bvsTransaction,
List <GrmEventInformationDto> grmEventInformationDtos,
List <LegalPartyDocumentDto> legalPartyDocumentDtos,
DateTime assessmentEventDate,
int baseValueSegmentRevObjId)
{
var list = new List <DetailDto>();
// now build segments and base value segment per owner
foreach (var bvsOwner in bvsTransaction.BaseValueSegmentOwners)
{
// per meeting with bob do not error out if grm even information is missing, return unknown
var grmOwnerEventInformationDto = grmEventInformationDtos.FirstOrDefault(grm => grm.GrmEventId == bvsOwner.GRMEventId);
DateTime?ownerEventDate = null;
string ownerEventType;
string ownerEventName;
if (grmOwnerEventInformationDto != null)
{
ownerEventName = grmOwnerEventInformationDto.Description;
ownerEventType = grmOwnerEventInformationDto.EventType;
ownerEventDate = grmOwnerEventInformationDto.EffectiveDate;
}
else
{
ownerEventName = Constants.EventUnknownName;
ownerEventType = Constants.EventUnknownName;
}
var allTheOwnersDocuments = legalPartyDocumentDtos.Where(x => x.LegalPartyRoleId == bvsOwner.LegalPartyRoleId).ToList();
foreach (var ownerValue in bvsOwner.BaseValueSegmentOwnerValueValues)
{
// get the values associated with the owner value
var baseValueHeaders = bvsTransaction.BaseValueSegmentValueHeaders.Where(v => ownerValue.BaseValueSegmentValueHeaderId == v.Id);
foreach (var bvsValueHeader in baseValueHeaders)
{
// per meeting with bob do not error out if grm even information is missing, return unknown
var grmValueHeaderEventInformationDto = grmEventInformationDtos.FirstOrDefault(grm => grm.GrmEventId == bvsValueHeader.GRMEventId);
// HACK: this should set but the migration process, bob told arpan to set revobject
// to zero for dummy grmevents created for bvs, need to discuss
grmValueHeaderEventInformationDto.RevenueObjectId = baseValueSegmentRevObjId;
string valueHeaderEventName;
string valueHeaderEventType;
DateTime?valueHeaderEventDate = null;
if (grmOwnerEventInformationDto != null)
{
valueHeaderEventName = grmValueHeaderEventInformationDto.Description;
valueHeaderEventType = grmValueHeaderEventInformationDto.EventType;
valueHeaderEventDate = grmValueHeaderEventInformationDto.EffectiveDate;
}
else
{
valueHeaderEventName = Constants.EventUnknownName;
valueHeaderEventType = Constants.EventUnknownName;
}
var subComponentDetailDtos = _baseValueSegmentRepository.GetSubComponentDetails(baseValueSegmentRevObjId, assessmentEventDate).Result.ToList();
foreach (var value in bvsValueHeader.BaseValueSegmentValues)
{
var subComponentDetail = subComponentDetailDtos.FirstOrDefault(x => x.SubComponentId == value.SubComponent);
if (subComponentDetail is null)
{
continue;
}
var ownerSpecificEventDocument = allTheOwnersDocuments.SingleOrDefault(x => x.GrmEventId == bvsOwner.GRMEventId);
string beneficialInterest;
string docNumber;
decimal?percentageInterestGain = null;
if (ownerSpecificEventDocument != null)
{
beneficialInterest = ownerSpecificEventDocument.LegalPartyDisplayName;
docNumber = ownerSpecificEventDocument.DocNumber;
percentageInterestGain = ownerSpecificEventDocument.PctGain;
}
else
{
var legalPartyRole = (await _legalPartyDomain.GetLegalPartyRole(bvsOwner.LegalPartyRoleId, assessmentEventDate));
beneficialInterest = legalPartyRole.LegalParty.DisplayName;
docNumber = Constants.DocumentUnknownName;
}
// now build dto
var detail = new DetailDto
{
BeneficialInterest = beneficialInterest,
DocNumber = docNumber,
PercentageInterestGain = percentageInterestGain,
OwnershipEventName = ownerEventName,
OwnershipEventType = ownerEventType,
OwnershipEventDate = ownerEventDate,
BaseValueSegmentEventName = valueHeaderEventName,
BaseValueSegmentEventType = valueHeaderEventType,
BaseValueSegmentEventDate = valueHeaderEventDate,
BiPercentage = bvsOwner.BeneficialInterestPercent,
ComponentName = subComponentDetail.Component,
SubComponentName = subComponentDetail.SubComponent,
SubComponentId = subComponentDetail.SubComponentId,
BaseYear = bvsValueHeader.BaseYear,
OwnerIsOverride = bvsOwner.IsOverride,
ComponentIsOverride = bvsValueHeader.BaseValueSegmentValues.Any(x => x.IsOverride == true && x.SubComponent == subComponentDetail.SubComponentId),
OwnerId = bvsOwner.Id,
AssessmentEventDate = assessmentEventDate,
ValueHeaderId = bvsValueHeader.Id
};
list.Add(detail);
}
}
}
}
return(list.ToArray());
}
public async Task <IActionResult> Create([FromBody] BaseValueSegmentTransactionDto baseValueSegmentTransactionDto)
{
baseValueSegmentTransactionDto = await _baseValueSegmentTransactionDomainDomain.CreateAsync(baseValueSegmentTransactionDto);
return(CreatedAtRoute(GetRouteName, new { id = baseValueSegmentTransactionDto.Id }, baseValueSegmentTransactionDto));
}
public void CreateForTransactionFromBaseValueSegmentTransactionDtoMappingsOccurAndGetGrmEventIdArray()
{
var transaction = 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.CreateForTransaction(transaction).Result;
results.ShouldNotBeNull();
results[0].ShouldBe(44);
results[1].ShouldBe(45);
results[2].ShouldBe(46);
results[3].ShouldBe(47);
}
public async Task <Models.V1.AssessmentHeader> Get(int assessmentEventId)
{
if (assessmentEventId < 1)
{
throw new BadRequestException("Invalid AssessmentEventId");
}
var assessmentEventDto = await _httpClientWrapper.Get <AssessmentEventDto>(_applicationSettingsHelper.AssessmentEventServiceApiUrl, $"{Version}/assessmentevents/{assessmentEventId}");
if (assessmentEventDto == null)
{
return(null);
}
var assessmentEventTran = assessmentEventDto.AssessmentEventTransactions.OrderByDescending(aet => aet.Id).FirstOrDefault();
BaseValueSegmentTransactionDto currentBaseValueSegmentTransaction = null;
BaseValueSegmentDto baseValueSegmentDto = null;
try
{
baseValueSegmentDto = await _httpClientWrapper.Get <BaseValueSegmentDto>(_applicationSettingsHelper.BaseValueSegmentServiceApiUrl,
$"{Version}/basevaluesegments/RevenueObjectId/{assessmentEventDto.RevObjId}/AssessmentEventDate/{assessmentEventDto.EventDate:yyyy-MM-dd}");
}
catch (NotFoundException)
{
// no records found
}
if (baseValueSegmentDto != null)
{
var baseValueSegmentTransactions = baseValueSegmentDto.BaseValueSegmentTransactions.OrderByDescending(x => x.Id);
if (baseValueSegmentTransactions.Any())
{
currentBaseValueSegmentTransaction = baseValueSegmentTransactions.First();
}
}
var assessmentHeader = new Models.V1.AssessmentHeader
{
AssessmentEvent = new AssessmentEvent
{
AssessmentEventId = assessmentEventDto.Id,
AssessmentEventType = assessmentEventDto.AsmtEventType,
AssessmentEventTypeDescription = assessmentEventDto.AsmtEventTypeDescription,
RevenueObjectId = assessmentEventDto.RevObjId,
EventDate = assessmentEventDto.EventDate,
TaxYear = assessmentEventDto.TaxYear,
EventState = assessmentEventTran?.AsmtEventStateDescription,
TransactionId = assessmentEventTran?.Id ?? null,
BVSTranType = (currentBaseValueSegmentTransaction != null) ? currentBaseValueSegmentTransaction.BaseValueSegmentTransactionType.Description : string.Empty,
PrimaryBaseYear = assessmentEventDto.PrimaryBaseYear,
PrimaryBaseYearMultipleOrSingleDescription = assessmentEventDto.PrimaryBaseYearMultipleOrSingleDescription
}
};
RevenueObjectDto revenueObjectDto = null;
try
{
revenueObjectDto = await _httpClientWrapper.Get <RevenueObjectDto>(_applicationSettingsHelper.RevenueObjectServiceApiUrl,
$"{Version}/revenueobjects/{assessmentEventDto.RevObjId}/EffectiveDate/{assessmentEventDto.EventDate:yyyy-MM-dd}");
}
catch (NotFoundException)
{
//if not found it could be because the PIN is inactive so send back a user-friendly message
throw new NotFoundException("BVS data is unavailable. This may be because the PIN is no longer active.");
}
catch
{
throw new NotFoundException("Unable to look up the Revenue Object. This may be the result of an inactive record.");
}
var legalPartyRoleDtos = await _httpClientWrapper.Get <IList <LegalPartyRoleDto> >(_applicationSettingsHelper.LegalPartyServiceApiUrl,
$"{Version}/LegalParties/LegalPartyRoles/RevenueObjectId/{assessmentEventDto.RevObjId}/EffectiveDate/{assessmentEventDto.EventDate:O}");
AssessmentRevisionDto assessmentRevisionDto = null;
if (assessmentEventTran != null)
{
assessmentRevisionDto = await _httpClientWrapper.Get <AssessmentRevisionDto>(_applicationSettingsHelper.AssessmentEventServiceApiUrl,
$"{Version}/AssessmentEvents/AssessmentRevisionEventId/{assessmentEventTran.AsmtRevnEventId}/AssessmentEventDate/{assessmentEventDto.EventDate:yyyy-MM-dd}/AssessmentRevision");
}
var tagDto = await _httpClientWrapper.Get <TAGDto>(_applicationSettingsHelper.RevenueObjectServiceApiUrl,
$"{Version}/revenueobjects/RevenueObjectId/{assessmentEventDto.RevObjId}/EffectiveDate/{assessmentEventDto.EventDate:yyyy-MM-dd}/TAG");
StatutoryReferenceDto statutoryReferenceDto = null;
if (assessmentEventTran != null)
{
statutoryReferenceDto = await _httpClientWrapper.Get <StatutoryReferenceDto>(_applicationSettingsHelper.AssessmentEventServiceApiUrl,
$"{Version}/StatutoryReference/{assessmentEventTran.Id}");
}
if (statutoryReferenceDto != null)
{
assessmentHeader.AssessmentEvent.RevenueAndTaxCode = statutoryReferenceDto.Description;
}
if (revenueObjectDto != null)
{
assessmentHeader.RevenueObject = new RevenueObject
{
Id = revenueObjectDto.Id,
BeginEffectiveDate = revenueObjectDto.BeginEffectiveDate,
EffectiveStatus = revenueObjectDto.EffectiveStatus,
Pin = revenueObjectDto.Pin,
UnformattedPin = revenueObjectDto.UnformattedPin,
Ain = revenueObjectDto.Ain,
GeoCd = revenueObjectDto.GeoCd,
ClassCd = revenueObjectDto.ClassCd,
AreaCd = revenueObjectDto.AreaCd,
CountyCd = revenueObjectDto.CountyCd,
CensusTrack = revenueObjectDto.CensusTrack,
CensusBlock = revenueObjectDto.CensusBlock,
XCoordinate = revenueObjectDto.XCoordinate,
YCoordinate = revenueObjectDto.YCoordinate,
ZCoordinate = revenueObjectDto.ZCoordinate,
RightEstate = revenueObjectDto.RightEstate,
RightType = revenueObjectDto.RightType,
RightDescription = revenueObjectDto.RightDescription,
Type = revenueObjectDto.Type,
SubType = revenueObjectDto.SubType,
TAG = tagDto.Description,
SitusAddress = revenueObjectDto.SitusAddress != null
? new SitusAddress
{
FreeFormAddress = revenueObjectDto.SitusAddress.FreeFormAddress,
City = revenueObjectDto.SitusAddress.City,
StateCode = revenueObjectDto.SitusAddress.StateCode,
PostalCode = revenueObjectDto.SitusAddress.PostalCode
}
: null,
Description = revenueObjectDto.Description,
PropertyType = revenueObjectDto.PropertyType,
RelatedPins = revenueObjectDto.RelatedPins,
ClassCodeDescription = revenueObjectDto.ClassCodeDescription,
//TODO Remove hard coding of TotalBaseValue once true source is determined
TotalBaseValue = 345000m
};
}
if (legalPartyRoleDtos != null && legalPartyRoleDtos.Count > 0)
{
var primeLegalPartyRole = GetPrimeLegalPartyRole(legalPartyRoleDtos);
if (primeLegalPartyRole != null)
{
var primeLegalParty = primeLegalPartyRole.LegalParty;
assessmentHeader.LegalParty = new LegalParty
{
LegalPartyId = primeLegalParty.Id,
DisplayName = primeLegalParty.DisplayName,
FirstName = primeLegalParty.FirstName,
MiddleName = primeLegalParty.MiddleName,
LastName = primeLegalParty.LastName,
NameSfx = primeLegalParty.NameSfx,
RevenueAcct = primeLegalPartyRole.AcctId,
LegalPartyRoleObjectType = primeLegalPartyRole.ObjectType
};
}
}
if (assessmentRevisionDto != null)
{
assessmentHeader.AssessmentEvent.RevisionId = assessmentRevisionDto.Id;
assessmentHeader.AssessmentEvent.ReferenceNumber = assessmentRevisionDto.ReferenceNumber;
assessmentHeader.AssessmentEvent.ChangeReason = assessmentRevisionDto.ChangeReason;
assessmentHeader.AssessmentEvent.Note = assessmentRevisionDto.Note;
}
return(assessmentHeader);
}
