public async Task <IActionResult> GetIndividualDetailsByNationalId(string nationalId)
{
if (string.IsNullOrEmpty(nationalId))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "National Id can't be empty.")));
}
var individual = await _individualRepository.GetIndividualByNationalIdAsync(nationalId);
if (individual is null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Individual isn't found.")));
}
var result = new IndividualDetailsOutputModel()
{
ContractInformation = Mapper.Map <ContractOutputModel>(individual.Contract),
IndividualInformation = Mapper.Map <IndividualOutputModel>(individual),
SummaryInformation = Mapper.Map <SummaryInformation>(individual.Contract.ContractData)
};
var subjectRole = await _subjectRoleRepository.GetSubjectRoleByCustomerAndContractCodeAsync(individual.CustomerCode,
individual.Contract.ContractCode);
result.ContractInformation.SubjectRole = subjectRole.RoleOfCustomer.ToString();
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> AddContactyAsync(ContactInputModel model)
{
if (string.IsNullOrEmpty(model.CompanyId))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Company id can't be empty.")));
}
if (string.IsNullOrEmpty(model.Name))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Contact name can't be empty.")));
}
var company = await _companyRepository.GetCompanyByIdAsync(model.CompanyId);
if (company is null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Company not found")));
}
var contact = Contact.New(model.Name, company.Id);
await _contactRepository.AddContactAsync(contact);
company.AddContact(contact.Id);
await _companyRepository.UpdateCompanyAsync(company);
var result = Mapper.Map <ContactOutputModel>(contact);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetCompanyByIdAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Company Id can't be empty.")));
}
var company = await _companyRepository.GetCompanyByIdAsync(id);
if (company is null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Company isn't found.")));
}
var result = Mapper.Map <CompanyOutputModel>(company);
if (company.ContactIds != null)
{
var contacts = await _contactRepository.GetContactsByListOfIdsAsync(company.ContactIds);
result.Contacts = Mapper.Map <List <ContactOutputModel> >(contacts);
}
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetAllDatasetsAsync()
{
var datasets = await _datasetRepository.GetAllDatasetsAsync();
var result = Mapper.Map <List <DatasetOutputModel> >(datasets);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> AddCountryAsync(PostCountryInputModel model)
{
var country = _mapper.Map <Country>(model);
var result = await _countryService.AddCountryAsync(country);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetAllCountriesAsync([FromQuery] PagingParams pagingParams,
string sortColumn = null,
string sortOrder = null,
string filterColumn = null,
string filterQuery = null)
{
var countries = await _countryService.GetCountriesAsync(pagingParams, sortColumn, sortOrder, filterColumn, filterQuery);
var countryModel = _mapper.Map <List <CountryModel> >(countries.Result);
var result = GetCountriesOutputModel.Create(countryModel, countries);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> CreateDatasetAsync(DatasetInputModel model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Dataset name can't be empty.")));
}
var dataset = Dataset.New(model.Name);
await _datasetRepository.AddDatasetAsync(dataset);
var result = Mapper.Map <DatasetOutputModel>(dataset);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetAllFriendshipsByDatasetIdAsync(long id)
{
var dataset = await _datasetRepository.GetDatasetByIdAsync(id);
if (dataset == null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Dataset isn't found.")));
}
var friendships = await _friendShipRepository.GetAllFriendshipsByDatasetIdAsync(id);
var result = Mapper.Map <List <FriendshipOutputModel> >(friendships);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> AddCityAsync(PostCityInoutModel model)
{
var city = _mapper.Map <City>(model);
var isDupeCity = await _cityService.IsDupeCityAsync(city);
if (isDupeCity)
{
string message = $"{city.Name} city is already exist";
return(BadRequest(ResponseResult.SucceededWithData(message)));
}
var result = await _cityService.AddCityAsync(city);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> AddCompanyAsync(CompanyInputModel model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Company name can't be empty.")));
}
var company = Company.New(model.Name, model.NumOfEmpolyees);
await _companyRepository.AddCompanyAsync(company);
var result = Mapper.Map <CompanyOutputModel>(company);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> SearchIndividualByNationalId(string nationalId)
{
if (string.IsNullOrEmpty(nationalId))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "National Id can't be empty.")));
}
var individual = await _individualRepository.GetIndividualByNationalIdAsync(nationalId);
if (individual is null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "no hit information")));
}
return(Ok(ResponseResult.SucceededWithData("One Single hit")));
}
public async Task <IActionResult> GetContactByIdAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Contact Id can't be empty.")));
}
var contact = await _contactRepository.GetContactByIdAsync(id);
if (contact is null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "no hit information")));
}
var result = Mapper.Map <ContactOutputModel>(contact);
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetAllUsersByDatasetIdAsync(long id)
{
var dataset = await _datasetRepository.GetDatasetByIdAsync(id);
if (dataset == null)
{
return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Dataset isn't found.")));
}
var users = await _friendShipRepository.GetAllUniqueUsersWithFriendsCountByDatasetIdAsync(id);
var result = new DatasetUsersOutputModel
{
Dataset = Mapper.Map <DatasetOutputModel>(dataset),
Users = Mapper.Map <List <UserOutputModel> >(users)
};
return(Ok(ResponseResult.SucceededWithData(result)));
}
public async Task <IActionResult> GetAllCompaniesAsync()
{
var companies = await _companyRepository.GetAllCompaniesAsync();
var result = Mapper.Map <List <CompanyOutputModel> >(companies);
int idx = 0;
foreach (var item in companies)
{
if (item.ContactIds != null)
{
var contacts = await _contactRepository.GetContactsByListOfIdsAsync(item.ContactIds);
result[idx].Contacts = Mapper.Map <List <ContactOutputModel> >(contacts);
}
idx++;
}
return(Ok(ResponseResult.SucceededWithData(result)));
}
