public async Task <OrganizationPersonResult> ShowOrganization(IOrganizationPerson person)
{
_logger.LogInformation(GetLogMessage("Org: {0}"), person.OrganizationId);
var entity = await Repository.Queryable().Where(x =>
x.OrganizationId == person.OrganizationId && x.PersonId == person.PersonId)
.FirstOrDefaultAsync();
var retVal = new OrganizationPersonResult
{
OrganizationId = person.OrganizationId,
PersonId = person.PersonId
};
entity.IsHidden = false;
var result = Repository.Update(entity, true);
_logger.LogDebug(GetLogMessage("{0} records updated"));
if (result > 0)
{
retVal.Succeeded = true;
}
return(retVal);
}
private bool CheckValidation(CreateOrganizationPersonInput model, out OrganizationPersonResult retVal)
{
bool isPhoneExists = false;
bool isEmailExists = false;
if (!string.IsNullOrEmpty(model.PhoneNumber?.Trim()))
{
_logger.LogInformation(GetLogMessage("Phone Number validation : {0}"), model.PhoneNumber);
isPhoneExists = _applicationUsers.Queryable().Any(a => a.PhoneNumber == model.PhoneNumber);
}
if (!string.IsNullOrEmpty(model.EmailAddress?.Trim()))
{
_logger.LogInformation(GetLogMessage("Email validation : {0}"), model.EmailAddress);
isEmailExists = _applicationUsers.Queryable().Any(a => a.Email == model.EmailAddress);
}
retVal = new OrganizationPersonResult();
if (!isPhoneExists && !isEmailExists)
{
return(false);
}
retVal.Succeeded = false;
retVal.ErrorMessage = GetErrorMessage(isPhoneExists, isEmailExists);
_logger.LogInformation(GetLogMessage(retVal.ErrorMessage));
return(true);
}
public async Task <OrganizationPersonResult> AddExistingPerson(IAgencyOwner agencyOwner, AddExistingPersonInput input)
{
_logger.LogInformation(GetLogMessage("Organization: {0}; Email: {1}"), agencyOwner.OrganizationId, input.EmailAddress);
var retVal = new OrganizationPersonResult()
{
OrganizationId = agencyOwner.OrganizationId
};
var foundPerson = await _accountManager.FindByEmailAsync(input.EmailAddress);
if (foundPerson != null)
{
_logger.LogDebug(GetLogMessage("Person Found: {0}"), foundPerson.Id);
var orgPersonInput = new OrganizationPersonInput()
{
PersonId = foundPerson.Id
}.InjectFrom(input) as OrganizationPersonInput;
retVal = await Create(orgPersonInput, agencyOwner.OrganizationId);
_logger.LogDebug(GetLogMessage("Person Result: {@result}"), retVal);
}
else
{
_logger.LogWarning(GetLogMessage("User does not exist"));
}
return(retVal);
}
public async Task <OrganizationPersonResult> Update(OrganizationPersonInput input, Guid organizationId)
{
_logger.LogInformation(GetLogMessage($@"For Person: {input.PersonId}, For Organization: {organizationId}"));
var retVal = new OrganizationPersonResult()
{
PersonId = input.PersonId,
OrganizationId = organizationId
};
return(await Task.FromResult(retVal));
}
private async Task <OrganizationPersonResult> Remove(Guid person, Guid organizationId)
{
_logger.LogInformation(GetLogMessage($@"For Person: {person}, For Organization: {organizationId}"));
var retVal = new OrganizationPersonResult()
{
PersonId = person,
OrganizationId = organizationId
};
var orgPerson = Repository.Queryable()
.Include(x => x.AccountManager)
.ThenInclude(x => x.Accounts)
.Include(x => x.AccountManager)
.ThenInclude(x => x.Leads)
.Include(x => x.Recruiter)
.ThenInclude(x => x.Candidates)
.Include(x => x.Recruiter)
.ThenInclude(x => x.Contractors)
.Include(x => x.Marketer)
.ThenInclude(x => x.Leads)
.Include(x => x.Marketer)
.ThenInclude(x => x.Customers)
.Include(x => x.ProjectManager)
.ThenInclude(x => x.Projects)
.Include(x => x.ProjectManager)
.ThenInclude(x => x.Candidates)
.Include(x => x.Contractor)
.ThenInclude(x => x.Contracts)
.FirstOrDefault(x => x.PersonId == person && x.OrganizationId == organizationId);
if (orgPerson == null)
{
retVal.Succeeded = false;
return(retVal);
}
var organization = await _orgService.Repository.Queryable()
.Include(x => x.MarketingOrganization)
.Include(x => x.RecruitingOrganization)
.Include(x => x.ProviderOrganization)
.Include(x => x.AccountManagers)
.Include(x => x.ProjectManagers)
.Include(x => x.Contractors)
.Include(x => x.Recruiters)
.Include(x => x.Marketers)
.Where(x => x.Id == organizationId)
.FirstOrDefaultAsync();
var totalUpdated = 0;
var keepPerson = false;
if (orgPerson.Contractor != null)
{
if (orgPerson.Contractor.Contracts.Count > 0)
{
var activeContracts = orgPerson.Contractor.Contracts.Where(x => x.IsPaused == false && x.IsEnded == false);
if (!activeContracts.Any())
{
orgPerson.Contractor.IsDeleted = true;
orgPerson.Contractor.UpdatedById = _userInfo.UserId;
orgPerson.Contractor.Updated = DateTimeOffset.UtcNow;
orgPerson.Contractor.ObjectState = ObjectState.Modified;
}
else
{
retVal.ErrorMessage = "Cannot remove person that has active contracts";
return(retVal);
}
}
// how many contracts do they have?
}
if (orgPerson.AccountManager != null)
{
if (!orgPerson.AccountManager.DefaultOrganizations.Any())
{
if (orgPerson.AccountManager.Accounts.Count > 0)
{
foreach (var account in orgPerson.AccountManager.Accounts)
{
account.AccountManagerId = organization.ProviderOrganization.DefaultAccountManagerId;
account.ObjectState = ObjectState.Modified;
account.Updated = DateTimeOffset.UtcNow;
account.UpdatedById = _userInfo.UserId;
}
}
if (orgPerson.AccountManager.Leads.Count > 0)
{
foreach (var lead in orgPerson.AccountManager.Leads)
{
lead.AccountManagerId = organization.ProviderOrganization.DefaultAccountManagerId;
lead.Updated = DateTimeOffset.UtcNow;
lead.UpdatedById = _userInfo.UserId;
lead.ObjectState = ObjectState.Modified;
}
}
orgPerson.AccountManager.IsDeleted = true;
orgPerson.AccountManager.Updated = DateTimeOffset.UtcNow;
orgPerson.AccountManager.UpdatedById = _userInfo.UserId;
orgPerson.AccountManager.ObjectState = ObjectState.Modified;
}
}
if (orgPerson.ProjectManager != null)
{
// how many projects do they have?
if (orgPerson.ProjectManager.Projects.Count > 0)
{
foreach (var project in orgPerson.ProjectManager.Projects)
{
project.ProjectManagerId = organization.ProviderOrganization.DefaultProjectManagerId;
project.ObjectState = ObjectState.Modified;
project.Updated = DateTimeOffset.UtcNow;
project.UpdatedById = _userInfo.UserId;
}
}
if (orgPerson.ProjectManager.Candidates.Count > 0)
{
foreach (var candidate in orgPerson.ProjectManager.Candidates)
{
candidate.ProjectManagerId = organization.ProviderOrganization.DefaultProjectManagerId;
candidate.ObjectState = ObjectState.Modified;
candidate.Updated = DateTimeOffset.UtcNow;
candidate.UpdatedById = _userInfo.UserId;
}
}
orgPerson.ProjectManager.IsDeleted = true;
orgPerson.ProjectManager.Updated = DateTimeOffset.UtcNow;
orgPerson.ProjectManager.UpdatedById = _userInfo.UserId;
orgPerson.ProjectManager.ObjectState = ObjectState.Modified;
}
if (orgPerson.Customer != null)
{
// you cannot delete the customer record without deactivating the account
}
if (orgPerson.Recruiter != null)
{
if (orgPerson.Recruiter.Candidates.Count > 0)
{
foreach (var candidate in orgPerson.Recruiter.Candidates)
{
candidate.RecruiterId = organization.RecruitingOrganization.DefaultRecruiterId;
candidate.UpdatedById = _userInfo.UserId;
candidate.Updated = DateTimeOffset.UtcNow;
candidate.ObjectState = ObjectState.Modified;
}
}
// any active candidates?
orgPerson.Recruiter.IsDeleted = true;
orgPerson.Recruiter.ObjectState = ObjectState.Modified;
orgPerson.UpdatedById = _userInfo.UserId;
orgPerson.Updated = DateTimeOffset.UtcNow;
}
if (orgPerson.Marketer != null)
{
// any active leads?
orgPerson.Marketer.IsDeleted = true;
orgPerson.Marketer.ObjectState = ObjectState.Modified;
orgPerson.UpdatedById = _userInfo.UserId;
orgPerson.Updated = DateTimeOffset.UtcNow;
if (orgPerson.Marketer.Leads.Any())
{
foreach (var lead in orgPerson.Marketer.Leads)
{
lead.MarketerId = organization.MarketingOrganization.DefaultMarketerId;
lead.ObjectState = ObjectState.Modified;
lead.UpdatedById = _userInfo.UserId;
lead.Updated = DateTimeOffset.UtcNow;
}
}
if (orgPerson.Marketer.Customers.Any())
{
foreach (var customer in orgPerson.Marketer.Customers)
{
// deal with these customers
customer.MarketerId = organization.RecruitingOrganization.DefaultRecruiterId;
customer.ObjectState = ObjectState.Modified;
customer.Updated = DateTimeOffset.UtcNow;
}
}
}
orgPerson.IsDeleted = !keepPerson;
orgPerson.Status = PersonStatus.Inactive;
orgPerson.UpdatedById = _userInfo.UserId;
orgPerson.ObjectState = ObjectState.Modified;
totalUpdated = Repository.InsertOrUpdateGraph(orgPerson, true);
if (totalUpdated > 0)
{
retVal.Succeeded = true;
}
return(retVal);
}
public async Task <OrganizationPersonResult> Create(OrganizationPersonInput input, Guid organizationId)
{
_logger.LogTrace(GetLogMessage($@"For Person: {input.PersonId}, For Organization: {organizationId}"));
var retVal = new OrganizationPersonResult()
{
OrganizationId = organizationId,
PersonId = input.PersonId
};
var person = _personService.Get(input.PersonId);
var organization = _organizationRepository.Queryable()
.FirstOrDefaultAsync(x => x.Id == organizationId);
await Task.WhenAll(person, organization);
if (person.Result == null || organization.Result == null)
{
retVal.ErrorMessage = "Person or Organization is invalid";
return(retVal);
}
var organizationPerson = await Repository.Queryable()
.IgnoreQueryFilters()
.FirstOrDefaultAsync(x => x.PersonId == input.PersonId && x.OrganizationId == organizationId);
var records = 0;
if (organizationPerson != null)
{
if (organizationPerson.IsDeleted)
{
organizationPerson.IsDeleted = false;
organizationPerson.UpdatedById = _userInfo.UserId;
organizationPerson.CreatedById = _userInfo.UserId;
Repository.Update(organizationPerson);
records = Repository.Commit();
}
}
else
{
organizationPerson = Repository.CreateOrgPerson(input, organizationId);
records = Repository.Commit();
}
_logger.LogDebug(GetLogMessage("{0} records updated"), records);
if (records > 0)
{
retVal.Succeeded = true;
retVal.PersonId = organizationPerson.PersonId;
await Task.Run(() =>
{
RaiseEvent(new OrganizationPersonCreatedEvent
{
OrganizationId = organizationPerson.OrganizationId,
PersonId = organizationPerson.PersonId
});
});
}
else
{
_logger.LogWarning(GetLogMessage("Unable to create organization person"));
}
return(retVal);
}
