private async Task <CustomerAccountResult> Link(LinkCustomerWithCompanyInput input)
{
_logger.LogInformation(GetLogMessage(
$@"Linking Account, Account Manager: {input.AccountManagerId}, Customer Lookup Info: {input.EmailAddress} ({input.CompanyName})"));
CustomerAccountResult retVal = new CustomerAccountResult();
var cu = _customerService.Repository.Queryable()
.FindByOrganizationNameAndEmail(input.EmailAddress, input.CompanyName).FirstOrDefaultAsync();
await Task.WhenAll(cu);
if (cu.Result == null)
{
retVal.ErrorMessage = "Customer not found";
return(retVal);
}
var input2 = new CustomerAccountInput
{
CustomerId = cu.Result.CustomerId,
CustomerOrganizationId = cu.Result.OrganizationId,
PaymentTermId = input.PaymentTermId.GetValueOrDefault(1)
};
input2.InjectFrom(input);
var output = await Create(input2);
if (output.Succeeded)
{
await Task.Run(() =>
{
retVal = new CustomerAccountResult()
{
AccountManagerId = input.AccountManagerId,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
CustomerId = cu.Result.CustomerId,
CustomerOrganizationId = cu.Result.OrganizationId,
Succeeded = true,
BuyerNumber = output.BuyerNumber,
Number = output.Number
};
RaiseEvent(new CustomerAccountLinkedEvent
{
AccountManagerId = input.AccountManagerId,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
CustomerId = cu.Result.CustomerId,
CustomerOrganizationId = cu.Result.OrganizationId
});
});
}
return(retVal);
}
private async Task <CustomerAccountResult> Link(LinkCustomerInput input)
{
_logger.LogInformation(GetLogMessage(
$@"Linking Account, Account Manager: {input.AccountManagerId}, Customer Lookup Info: {input.EmailAddress}"));
CustomerAccountResult retVal = new CustomerAccountResult();
var cu = await _customers.Queryable()
.Include(x => x.Person).ThenInclude(x => x.ApplicationUser)
.Include(x => x.OrganizationCustomers)
.Where(x => x.Person.ApplicationUser.Email == input.EmailAddress)
.FirstAsync();
if (cu.OrganizationCustomers.Count > 0)
{
var orgCu = cu.OrganizationCustomers.First();
var input2 = new CustomerAccountInput
{
CustomerId = cu.Id,
CustomerOrganizationId = orgCu.OrganizationId,
PaymentTermId = input.PaymentTermId.GetValueOrDefault(1)
};
input2.InjectFrom(input);
var output = await Create(input2);
if (output.Succeeded)
{
await Task.Run(() =>
{
retVal = new CustomerAccountResult()
{
AccountManagerId = input.AccountManagerId,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
CustomerId = orgCu.CustomerId,
CustomerOrganizationId = orgCu.OrganizationId,
Succeeded = true,
BuyerNumber = output.BuyerNumber,
Number = output.Number
};
RaiseEvent(new CustomerAccountLinkedEvent
{
AccountManagerId = input.AccountManagerId,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
CustomerId = orgCu.CustomerId,
CustomerOrganizationId = orgCu.OrganizationId
});
});
}
}
return(retVal);
}
public async Task <IActionResult> UpdateAccount(
[FromRoute] Guid organizationId,
[FromRoute] int accountId,
[FromBody] CustomerAccountInput model)
{
var account = await _accountService
.Update(_agencyOwner, accountId, model);
return(Ok(account));
}
public async Task <CustomerAccountResult> Create(IOrganizationCustomer cu, JoinAsCustomerInput input)
{
_logger.LogInformation(GetLogMessage("Customer: {0}"), cu.OrganizationId);
var org = await _organizationService.Repository.Queryable()
.Include(x => x.ProviderOrganization)
.Include(x => x.AccountManagers)
.Where(x => x.ProviderOrganization.Discoverable && x.Id == input.ProviderOrganizationId)
.FirstOrDefaultAsync();
var model = new CustomerAccountInput()
{
AccountManagerId = org.ProviderOrganization.DefaultAccountManagerId,
AccountManagerOrganizationId = org.Id,
CustomerId = cu.CustomerId,
CustomerOrganizationId = cu.OrganizationId,
PaymentTermId = null
};
return(await Create(model));
}
private async Task <CustomerAccountResult> Create(CustomerAccountInput input)
{
_logger.LogInformation(GetLogMessage(
$@"Creating Account, Account Manager: {input.AccountManagerId}, Customer: {input.CustomerId}"));
var retVal = new CustomerAccountResult()
{
CustomerOrganizationId = input.CustomerOrganizationId,
CustomerId = input.CustomerId,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
AccountManagerId = input.AccountManagerId
};
var cu = await
_customerService.Repository.Queryable()
.Where(x => x.OrganizationId == input.CustomerOrganizationId && x.CustomerId == input.CustomerId)
.Include(x => x.Customer)
.ThenInclude(x => x.OrganizationMarketer)
.FirstAsync();
var am = await
_accountManagerService.Repository.Queryable().Where(x => x.AccountManagerId == input.AccountManagerId && x.OrganizationId == input.AccountManagerOrganizationId)
.FirstOrDefaultAsync();
var acctCandidate = await Repository.Queryable().Where(
x => x.AccountManagerOrganizationId == input.AccountManagerOrganizationId &&
x.AccountManagerId == input.AccountManagerId &&
x.CustomerId == input.CustomerId && x.CustomerOrganizationId == input.CustomerOrganizationId)
.IgnoreQueryFilters()
.FirstOrDefaultAsync();
if (cu == null)
{
_logger.LogInformation(GetLogMessage("Customer not found"));
retVal.ErrorMessage = "Customer not found";
return(retVal);
}
if (am == null)
{
_logger.LogInformation(GetLogMessage("Account manager not found"));
retVal.ErrorMessage = "Account manager not found";
return(retVal);
}
// todo: this value could come from somewhere else if it's a repeat customer
var marketerStream = cu.Customer.OrganizationMarketer.MarketerStream;
var marketingAgencyStream = cu.Customer.OrganizationMarketer.MarketerBonus;
var marketingAgreement = await _marketingAgreements.Queryable()
.Where(x => x.MarketingOrganizationId == cu.Customer.MarketerOrganizationId &&
x.ProviderOrganizationId == am.OrganizationId)
.FirstOrDefaultAsync();
if (marketingAgreement != null)
{
marketerStream = marketingAgreement.MarketerStream;
marketingAgencyStream = marketingAgreement.MarketingAgencyStream;
}
var entity = new CustomerAccount
{
AccountStatus = AccountStatus.Active,
ObjectState = ObjectState.Added,
AccountManagerOrganizationId = input.AccountManagerOrganizationId,
AccountManagerId = input.AccountManagerId,
CustomerId = input.CustomerId,
CreatedById = _userInfo.UserId,
UpdatedById = _userInfo.UserId,
MarketerStream = marketerStream,
MarketingAgencyStream = marketingAgencyStream,
CustomerOrganizationId = input.CustomerOrganizationId,
PaymentTermId = input.PaymentTermId.GetValueOrDefault(1),
AutoApproveTimeEntries = input.AutoApproveTimeEntries
}.InjectFrom(input) as CustomerAccount;
entity.StatusTransitions.Add(new CustomerAccountStatusTransition()
{
Status = entity.AccountStatus,
ObjectState = ObjectState.Added
});
var records = 0;
if (acctCandidate != null)
{
_logger.LogDebug(GetLogMessage("Existing customer account found already, was deleted: {0}"),
acctCandidate.IsDeleted);
// there is an existing account already
entity = await Get(
input.AccountManagerOrganizationId,
input.AccountManagerId,
input.CustomerOrganizationId,
input.CustomerId);
entity.ObjectState = ObjectState.Modified;
entity.UpdatedById = _userInfo.UserId;
entity.Updated = DateTimeOffset.UtcNow;
entity.IsDeleted = false;
records = await Repository.UpdateAsync(entity, true);
}
else
{
_logger.LogDebug(GetLogMessage("Ready to create new customer"));
// create a new account
entity.Number =
await GetNextAccountId(input.AccountManagerOrganizationId);
entity.BuyerNumber =
await GetNextBuyerAccountId(input.CustomerOrganizationId);
entity.ObjectState = ObjectState.Added;
records = await Repository.InsertAsync(entity, true);
}
_logger.LogDebug(GetLogMessage("{0} customer account records updated"), records);
if (records > 0)
{
retVal.Succeeded = true;
retVal.BuyerNumber = entity.BuyerNumber;
retVal.Number = entity.Number;
await Task.Run(() =>
{
RaiseEvent(new CustomerAccountCreatedEvent
{
CustomerId = retVal.CustomerId.Value,
AccountManagerId = retVal.AccountManagerId.Value,
AccountManagerOrganizationId = retVal.AccountManagerOrganizationId.Value,
CustomerOrganizationId = retVal.CustomerOrganizationId.Value,
});
});
}
else
{
_logger.LogWarning(GetLogMessage("Unable to create customer account"));
retVal.ErrorMessage = "Unable to create customer account";
}
return(retVal);
}
private async Task <CustomerAccountResult> CreateInternal(IOrganizationAccountManager am,
NewCustomerAccountInput model)
{
var retVal = new CustomerAccountResult();
_logger.LogInformation(GetLogMessage("AM: {0}; Input: {@input};"), am.OrganizationId, model);
model.AccountManagerId = am.AccountManagerId;
var person = await _personService
.CreatePerson(model, null, model.MarketerId, model.MarketerOrganizationId ?? am.OrganizationId);
if (person.Succeeded)
{
_logger.LogDebug(GetLogMessage("Person was created successfully"));
var result = await _organizationService.CreateOrganization(am, new OrganizationCreateInput()
{
Name = model.OrganizationName,
Description = string.Empty,
Iso2 = model.Iso2,
ProvinceState = model.ProvinceState,
}, person.PersonId.Value);
if (result.Succeeded)
{
_logger.LogWarning(GetLogMessage("Organization was created successfully"));
retVal.Succeeded = true;
retVal.AccountManagerId = model.AccountManagerId;
retVal.AccountManagerOrganizationId = am.OrganizationId;
retVal.CustomerId = person.PersonId.Value;
retVal.CustomerOrganizationId = result.OrganizationId.Value;
if (result?.OrganizationId != null)
{
var m = new CustomerAccountInput()
{
PaymentTermId = model.PaymentTermId.GetValueOrDefault(1),
AccountManagerId = am.AccountManagerId,
AccountManagerOrganizationId = am.OrganizationId,
CustomerId = person.PersonId.Value,
CustomerOrganizationId = result.OrganizationId.Value,
AutoApproveTimeEntries = model.AutoApproveTimeEntries,
};
return(await Create(m));
}
}
else
{
retVal.ErrorMessage = result.ErrorMessage;
_logger.LogWarning(GetLogMessage("unable to create organization"));
}
}
else
{
retVal.ErrorMessage = person.ErrorMessage;
_logger.LogWarning(GetLogMessage("unable to create person"));
}
return(retVal);
}
//public async Task<T> Update<T>(IOrganizationAccountManager am, int id, CustomerAccountInput model)
// where T : AccountManagerCustomerAccountOutput
//{
// var account = await GetAccount(am, id);
// account.InjectFrom(model);
// await Repository.UpdateAsync(account, true);
// var output = await GetAccount<T>(am, id);
// await Task.Run(() =>
// {
// RaiseEvent(new CustomerAccountUpdatedEvent()
// {
// Account = output
// });
// });
// return output;
//}
public async Task <CustomerAccountResult> Update(IProviderAgencyOwner ao, int id, CustomerAccountInput model)
{
var retVal = new CustomerAccountResult();
var am = await _accountManagerService
.Get(model.AccountManagerId, model.AccountManagerOrganizationId);
var cu = await _customerService
.Get(model.CustomerId, model.CustomerOrganizationId);
var isValid = am != null && cu != null;
if (isValid)
{
retVal.CustomerId = cu.CustomerId;
retVal.AccountManagerId = am.AccountManagerId;
retVal.CustomerOrganizationId = cu.OrganizationId;
retVal.AccountManagerOrganizationId = am.OrganizationId;
var account = await GetAccount(ao, id);
account.InjectFrom(model);
if (model.PaymentTermId.HasValue)
{
account.PaymentTermId = model.PaymentTermId.GetValueOrDefault(1);
}
var result = await Repository.UpdateAsync(account, true);
_logger.LogDebug(GetLogMessage("{0} records updated"));
if (result > 0)
{
retVal.Succeeded = true;
await Task.Run(() =>
{
RaiseEvent(new CustomerAccountUpdatedEvent()
{
CustomerId = retVal.CustomerId.Value,
CustomerOrganizationId = retVal.CustomerOrganizationId.Value,
AccountManagerId = retVal.AccountManagerId.Value,
AccountManagerOrganizationId = retVal.AccountManagerOrganizationId.Value
});
});
}
}
return(retVal);
}
