private async Task <List <Company> > GetCompaniesAsync(CompanySearchParameters csp)
{
string[] returnProps = { "Id", "Name", "Type", "Addresses", "EmailAddresses", "PhoneNumbers", "NickName", "OrganizationNumber", "VatNumber", "DateCreated", "DateChanged" };
var companies = await _companyService.GetCompaniesAsync(csp, returnProps);
return(companies.ToList());
}
public async Task <List <Company> > GetCompaniesAsync(DateTime from)
{
var csp = new CompanySearchParameters {
ChangedAfter = from.AddSeconds(-from.Second).AddSeconds(-1)
}; // this time manipulation is needed because 24so service is ROUNDING (not truncating) company creation time
return(await GetCompaniesAsync(csp));
}
public async Task <Company> GetCompanyAsync(string companyName)
{
var csp = new CompanySearchParameters {
CompanyName = companyName, ChangedAfter = _defaultSearchDate
};
var returnedCompanies = await GetCompaniesAsync(csp);
return(returnedCompanies.FirstOrDefault());
}
public ActionResult Search([FromBody] CompanySearchParameters parameters)
{
var(items, total, filtered) = Service.Company.Search(parameters);
return(Json(new
{
items,
total,
filtered
}));
}
public async Task <IEnumerable <Company> > GetCompaniesAsync(CompanySearchParameters parameters)
{
var companies = context.Companies as IQueryable <Company>;
if (!string.IsNullOrWhiteSpace(parameters?.CompanyName))
{
companies = companies.Where(c => c.Name.Contains(parameters.CompanyName));
}
return(await companies?.OrderBy(c => c.Name).ToListAsync());
}
public ResultList <CompanyBasicProfile> SearchCompanies([FromBody] CompanySearchParameters searchDetails)
{
throw new NotImplementedException();
}
public PagedResponse <CompanyBasicProfile, CompanySortColumn> SearchCompanies(CompanySearchParameters searchDetails)
{
return(Delegate.SearchCompanies(searchDetails));
}
public PagedResponse <CompanyBasicProfile, CompanySortColumn> SearchCompanies(CompanySearchParameters searchDetails)
{
//TODO:: Stub - Fetch
var response = new List <CompanyBasicProfile> {
};
return(PagedResponse <CompanyBasicProfile, CompanySortColumn> .Create(response, ResultCode.Success));
}
public async Task <ActionResult <IEnumerable <CompanySearchResDto> > > GetCompanies([FromQuery] CompanySearchParameters parameters)
{
var companies = await companyRepository.GetCompaniesAsync(parameters);
if (companies == null)
{
return(NotFound());
}
var companySearchDtos = mapper.Map <IEnumerable <CompanySearchResDto> >(companies);
return(Ok(companySearchDtos));
}
public IEnumerable<DataContracts.ICompany> Search(CompanySearchParameters parameters)
{
throw new NotImplementedException();
}
public (List <CompanyListItem> items, int total, int filtered) Search(CompanySearchParameters parameters)
{
var initialQuery = Db.Companies.AsQueryable();
if (parameters.PhoneNumbers.HasValue())
{
var numbers = parameters.PhoneNumbers.ToLower();
initialQuery = initialQuery.Where(x => x.Phones.Any(p => p.Number.Contains(numbers)));
}
var query = initialQuery
.Select(x => new CompanyListItem
{
Id = x.Id,
Name = x.Name,
StateId = x.StateId,
ActivityType = x.ActivityType,
Address = x.Address,
Remarks = x.Remarks,
WebSites = x.WebSites,
LastCallRecordDate = x.DateModify,
PhoneNumbersList = x.Phones
.Select(n => n.Number)
.ToList(),
});
var total = query.Count();
if (parameters.Id.HasValue)
{
query = query.Where(x => x.Id == parameters.Id);
}
if (parameters.Name.HasValue())
{
query = query.Where(x => x.Name.ToLower().Contains(parameters.Name.ToLower()));
}
if (parameters.ActivityType.HasValue())
{
query = query.Where(x => x.ActivityType.ToLower().Contains(parameters.ActivityType.ToLower()));
}
if (parameters.Remarks.HasValue())
{
query = query.Where(x => x.Remarks.ToLower().Contains(parameters.Remarks.ToLower()));
}
if (parameters.WebSites.HasValue())
{
query = query.Where(x => x.WebSites.ToLower().Contains(parameters.WebSites.ToLower()));
}
if (parameters.StateId.HasValue)
{
if (parameters.StateId == 0)
{
parameters.StateId = null;
}
query = query.Where(x => x.StateId == parameters.StateId);
}
var fromDate = parameters.LastCallRecordDateFrom.ToDateTime("dd.MM.yyyy HH:mm");
if (fromDate.HasValue)
{
query = query.Where(x => x.LastCallRecordDate >= fromDate);
}
var toDate = parameters.LastCallRecordDateTo.ToDateTime("dd.MM.yyyy HH:mm");
if (toDate.HasValue)
{
query = query.Where(x => x.LastCallRecordDate <= toDate);
}
var filtered = query.Count();
var items = query
.OrderBy(parameters.OrderBy, parameters.IsAsc)
.TakePage(parameters.Skip.Value, parameters.Take.Value)
.ToList();
return(items, total, filtered);
}
PagedResponse <CompanyBasicProfile, CompanySortColumn> ICompanyService.SearchCompanies(CompanySearchParameters searchDetails)
{
try
{
return(Delegator.SearchCompanies(searchDetails));
}
catch (Exception ex)
{
return(PagedResponse <CompanyBasicProfile, CompanySortColumn> .Create(null, ResultCode.GeneralFailure, ex.Message));
}
}
public IEnumerable<DataContracts.ICompany> Search(CompanySearchParameters parameters)
{
var companies = new List<ICompany>();
using (var connection = new SqlConnection(base.ConnectionString))
{
using(var command = new SqlCommand("sp_CompanySearch", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@companyName", (object)parameters.Name ?? DBNull.Value);
command.Parameters.AddWithValue("@address1", (object)parameters.Address1 ?? DBNull.Value);
command.Parameters.AddWithValue("@city", (object)parameters.City ?? DBNull.Value);
command.Parameters.AddWithValue("@stateId", (object)parameters.State ?? DBNull.Value);
command.Parameters.AddWithValue("@zip", (object)parameters.PostalCode ?? DBNull.Value);
command.Parameters.AddWithValue("@phoneNumber", (object)parameters.PhoneNumber ?? DBNull.Value);
var adapter = new CompanyAdapter();
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
companies.Add((Company)adapter.Resolve(new Company(), reader));
}
}
}
return companies;
}
