public async Task <ApplicationResponseDto> ShareHoldersAsync(NewShareHoldersRequestDto dto)
{
var response = await _client.PostAsJsonAsync("entity/shareholders", dto);
if (response.IsSuccessStatusCode)
{
return(await response.Content.ReadAsAsync <ApplicationResponseDto>());
}
return(null);
}
public async Task <IActionResult> ShareHolders(NomineeBeneficiariesRequestDto dto)
{
var shareHoldersRequestDto = new NewShareHoldersRequestDto
{
ApplicationId = dto.ApplicationId
};
foreach (var shareHolder in dto.ShareHolders)
{
var subscription = _mapper.Map <ShareholderSubscriptionDto>(shareHolder);
var nominee = _mapper.Map <NewShareHolderRequestDto>(shareHolder);
nominee.Subs.Add(subscription);
if (!string.IsNullOrEmpty(shareHolder.BeneficiaryCountryCode))
{
var beneficiary = new NewShareHolderRequestDto
{
CountryCode = shareHolder.BeneficiaryCountryCode,
Surname = shareHolder.BeneficiarySurname,
Names = shareHolder.BeneficiaryNames,
Gender = shareHolder.BeneficiaryGender,
DateOfBirth = shareHolder.BeneficiaryDateOfBirth,
NationalIdentification = shareHolder.BeneficiaryNationalIdentification,
PhysicalAddress = shareHolder.BeneficiaryPhysicalAddress,
MobileNumber = shareHolder.BeneficiaryMobileNumber,
EmailAddress = shareHolder.BeneficiaryEmailAddress,
DateOfTakeUp = shareHolder.BeneficiaryDateOfAppointment,
};
beneficiary.Subs.Add(subscription);
nominee.PeopleRepresented.Add(beneficiary);
shareHoldersRequestDto.People.Add(nominee);
}
if (string.IsNullOrEmpty(shareHolder.BeneficiaryEntityCountry))
{
continue;
}
var beneficiaryEntity = _mapper.Map <NewShareHoldingEntityRequestDto>(shareHolder);
beneficiaryEntity.Nominees.Add(nominee);
beneficiaryEntity.Subs.Add(subscription);
shareHoldersRequestDto.Entities.Add(beneficiaryEntity);
}
if (await _privateEntityApiClientService.ShareHoldersAsync(shareHoldersRequestDto) != null)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> ShareHoldingPeople([FromBody] NewShareHoldersRequestDto dto)
{
User user;
using (var client = new HttpClient())
{
var accessToken = await HttpContext.GetTokenAsync("access_token");
client.SetBearerToken(accessToken);
var response = await client.GetAsync("https://localhost:5001/connect/userinfo");
if (response.IsSuccessStatusCode)
{
user = await response.Content.ReadAsAsync <User>();
}
else
{
return(Unauthorized());
}
}
return(Ok(await _privateEntityService.InsertMembersAsync(user.Sub, dto)));
}
public async Task <ApplicationResponseDto> InsertMembersAsync(Guid user, NewShareHoldersRequestDto dto)
{
// Get application from db
var application = await GetPrivateEntityApplicationAsync(user, dto.ApplicationId);
await LoadSavedMemorandumAsync(application);
await _context.Entry(application.PrivateEntity.MemorandumOfAssociation)
.Collection(m => m.ShareClauses)
.LoadAsync();
// Get share clause
var shareClauses = application.PrivateEntity.MemorandumOfAssociation.ShareClauses;
// Map shareholding pple
foreach (var personDto in dto.People)
{
var person = MapPerson(personDto, shareClauses);
await _context.AddAsync(person);
if (personDto.HasBeneficiaries())
{
foreach (var benefactor in personDto.PeopleRepresented)
{
var beneficiary = MapPerson(benefactor, shareClauses);
await _context.AddAsync(beneficiary);
person.PersonRepresentsPersonss.Add(new PersonRepresentsPerson(person,
beneficiary));
}
}
AddPrivateEntityMember(application, person);
}
// Map shareholding Entities
foreach (var entity in dto.Entities)
{
if (entity.IsRepresented())
{
if (entity.CountryCode.Equals("ZWE"))
{
var registeredEntity = await _context.PrivateEntities
.Include(p => p.Name)
.ThenInclude(a => a.NameSearch)
.ThenInclude(n => n.Names)
.SingleOrDefaultAsync(p =>
p.Name.NameSearch.Names
.Single(n => n.Status.Equals(ENameStatus.Used)).Value == entity.Name &&
p.Reference.Equals(entity.CompanyReference));
if (!registeredEntity.Equals(null))
{
foreach (var nominee in entity.Nominees)
{
var person = MapPerson(nominee, shareClauses);
AddPrivateEntityMember(application, person);
registeredEntity.PersonRepresentsPrivateEntity.Add(
new PersonRepresentsPrivateEntity(registeredEntity, person));
}
}
else
{
throw new Exception("One of the local shareholding entities is not registered.");
}
}
else
{
var shareholdingForeignEntity = _mapper.Map <ForeignEntity>(entity);
foreach (var subscription in entity.Subs)
{
shareholdingForeignEntity.ForeignEntitySubscriptions.Add(
new ForeignEntitySubscription(shareholdingForeignEntity,
shareClauses.Single(s => s.Title.Equals(subscription.Title)), subscription.Amount));
}
foreach (var nominee in entity.Nominees)
{
var person = MapPerson(nominee, shareClauses);
shareholdingForeignEntity.PersonRepresentsForeignEntities.Add(
new PersonRepresentsForeignEntity(shareholdingForeignEntity, person));
await _context.AddAsync(shareholdingForeignEntity);
AddPrivateEntityMember(application, person);
}
// await _context.SaveChangesAsync();
}
}
else
{
throw new Exception("One of the shareholding entities is not represented.");
}
}
return(await ReturnApplicationResponse(application));
}
