public async Task <ActionResult <List <ContractReport_CompanyDTO> > > FilterListCompany([FromBody] ContractReport_CompanyFilterDTO ContractReport_CompanyFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CompanyFilter CompanyFilter = new CompanyFilter();
CompanyFilter.Skip = 0;
CompanyFilter.Take = int.MaxValue;
CompanyFilter.OrderBy = CompanyOrder.Id;
CompanyFilter.OrderType = OrderType.ASC;
CompanyFilter.Selects = CompanySelect.ALL;
CompanyFilter.Id = ContractReport_CompanyFilterDTO.Id;
CompanyFilter.Name = ContractReport_CompanyFilterDTO.Name;
CompanyFilter.Phone = ContractReport_CompanyFilterDTO.Phone;
CompanyFilter.FAX = ContractReport_CompanyFilterDTO.FAX;
CompanyFilter.PhoneOther = ContractReport_CompanyFilterDTO.PhoneOther;
CompanyFilter.Email = ContractReport_CompanyFilterDTO.Email;
CompanyFilter.EmailOther = ContractReport_CompanyFilterDTO.EmailOther;
List <Company> Companys = await CompanyService.List(CompanyFilter);
List <ContractReport_CompanyDTO> ContractReport_CompanyDTOs = Companys
.Select(x => new ContractReport_CompanyDTO(x)).ToList();
return(ContractReport_CompanyDTOs);
}
public IEnumerable <CompanyListView> FilterCompanies(CompanyFilter companyFilter)
{
var companies = _context.Companies.AsQueryable();
companies = companies.Include(company => company.CurrentStock);
companies = companies.Include(company => company.Representatives);
if (companyFilter.Product != null)
{
companies = companies.Where(
company =>
company.CurrentStock
.SingleOrDefault(stock => stock.Merchandise.Name.StartsWith(companyFilter.Product, StringComparison.Ordinal)) != null);
}
if (companyFilter.CompanyName != null)
{
companies = companies.Where(company => company.Name.StartsWith(companyFilter.CompanyName, StringComparison.Ordinal));
}
return(companies.Select(company => new CompanyListView
{
CompanyId = company.Id,
CompanyName = company.Name,
Representatives = company.Representatives,
HasNegotiation = false
}).ToList());
}
public async Task <IEnumerable <Company> > GetCompaniesAsync(CompanyFilter filter)
{
var response = await httpClient.PostAsJsonAsync <CompanyFilter>("api/company/getcompanies", filter);
System.Console.WriteLine("RES : " + await response.Content.ReadAsStringAsync());
return(await response.Content.ReadFromJsonAsync <IEnumerable <Company> >());
}
/// <summary>
/// Restores parameters that were passed on to this dialog.
/// </summary>
private void RestoreParameters()
{
// Validate parameters
if (!QueryHelper.ValidateHash("hash"))
{
throw new Exception("[DataComSelectCompanyPage.RestoreParameters]: Invalid query hash.");
}
Hashtable parameters = WindowHelper.GetItem(QueryHelper.GetString("pid", null)) as Hashtable;
if (parameters == null)
{
throw new Exception("[DataComSelectCompanyPage.RestoreParameters]: The dialog page parameters are missing, the session might have been lost.");
}
// Restore filter
string content = parameters["Filter"] as string;
if (String.IsNullOrEmpty(content))
{
FilterParameter = new CompanyFilter();
}
else
{
JsonSerializer serializer = new JsonSerializer();
FilterParameter = serializer.Unserialize <CompanyFilter>(content);
}
// Restore site identifier
SiteIdentifierParameter = ValidationHelper.GetInteger(parameters["SiteID"], 0);
}
public IEnumerable <Company> GetCompanies(CompanyFilter filter)
{
//FormattableString SQL = $"SELECT * FROM UserLocations,LocationInfo WHERE UserLocations.ID_Location = LocationInfo.ID_Location AND ID_User = {ID_User}";
// FormattableString SQL = $@"SELECT * FROM LocationInfo
// WHERE ID_Location %{filter.filterLocations}%
// AND Latitude>={filter.filterLatitudeStart}
// AND Latitude<={filter.filterLatitudeEnd}
// AND Longitude>={filter.filterLongitudeStart}
// AND Longitude<={filter.filterLongitudeEnd}";
FormattableString SQL = $@"SELECT * FROM LocationInfo WHERE STATUS <> 0";
DataSet data = db.Query(SQL);
foreach (DataRow dr in data.Tables[0].Rows)
{
yield return(new Company()
{
IdLocation = dr.Field <int>("ID_Location"),
BusinessName = dr.Field <string>("Business_Name"),
Address = dr.Field <string>("Address"),
PostalCode = dr.Field <string>("PostalCode"),
City = dr.Field <string>("City"),
Latitude = dr.Field <double>("Latitude"),
Longitude = dr.Field <double>("Longitude"),
Opening = dr.Field <int>("Opening"),
Closing = dr.Field <int>("Closing")
});
}
}
/// <summary>
/// Creates and initializes a new instance of the CompanyFilter class with the UI element values, and returns it.
/// </summary>
/// <returns>A new instance of the CompanyFilter class initialized with the UI element values.</returns>
private CompanyFilter GetFilter()
{
CompanyFilter filter = new CompanyFilter();
filter.Name.Add(TrimFilterValue(NameTextBox.Text));
return filter;
}
public async Task <bool> ValidatePhone(Company Company)
{
if (!string.IsNullOrWhiteSpace(Company.Phone))
{
if (Company.Phone.Length > 20)
{
Company.AddError(nameof(CompanyValidator), nameof(Customer.Phone), ErrorCode.PhoneOverLength);
}
else
{
CompanyFilter CompanyFilter = new CompanyFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = Company.Id
},
Phone = new StringFilter {
Equal = Company.Phone
}
};
int count = await UOW.CompanyRepository.Count(CompanyFilter);
if (count != 0)
{
Company.AddError(nameof(CompanyValidator), nameof(Company.Phone), ErrorCode.PhoneExisted);
}
}
}
return(Company.IsValidated);
}
public List <ViewCompany> GetCompanies(CompanyFilter filter)
{
IQueryable <ViewCompany> comp = db.ViewCompanies;
comp = GetByCountry(filter.countryId, comp);
return(comp.ToList());
}
/// <summary>
/// Creates and initializes a new instance of the CompanyFilter class with the UI element values, and returns it.
/// </summary>
/// <returns>A new instance of the CompanyFilter class initialized with the UI element values.</returns>
private CompanyFilter GetFilter()
{
CompanyFilter filter = new CompanyFilter();
filter.Name.Add(TrimFilterValue(NameTextBox.Text));
return(filter);
}
public async Task<IEnumerable<Company>> Find(CompanyFilter filter)
{
var companies = GetCollection().Find(x => true);
var list = await companies.ToListAsync();
_logger.DebugFormat("List count: {0}", list.Count);
return list;
}
public IEnumerable <Company> GetCompanies(CompanyFilter filter)
{
var companies = companyService.GetCompanies(filter);
foreach (var company in companies)
{
var appoggio = probeprocessor.CalculatePeopleCount(company);
yield return(appoggio);
}
}
protected void Page_Load(object sender, EventArgs e)
{
AccountInfo account = EditedObject as AccountInfo;
AuthorizeReadRequest(account);
IDataComConfiguration configuration = DataComHelper.GetConfiguration(AccountSiteID);
if (configuration.GetToken() == null)
{
ShowWarning(GetString("datacom.notoken"), null, null);
}
else
{
try
{
if (!String.IsNullOrEmpty(CompanyHiddenField.Value))
{
JsonSerializer serializer = new JsonSerializer();
Company freshCompany = serializer.Unserialize <Company>(CompanyHiddenField.Value);
if (Company == null || Company.CompanyId != freshCompany.CompanyId)
{
CompanyForm.MergeHint = true;
}
Company = freshCompany;
}
if (Company == null)
{
AccountInfo accountInfo = EditedObject as AccountInfo;
CompanyIdentity identity = DataComHelper.CreateCompanyIdentity(accountInfo);
DataComClient client = DataComHelper.CreateClient(configuration);
ICompanyProvider provider = DataComHelper.CreateCompanyProvider(client, configuration);
CompanyFinder finder = DataComHelper.CreateCompanyFinder(provider);
CompanyFilter filterHint = null;
Company match = finder.Find(identity, out filterHint);
if (match != null)
{
ShowInformation(GetString("datacom.companymatch"));
Company = match;
CompanyForm.MergeHint = true;
}
else
{
ShowInformation(GetString("datacom.nocompanymatch"));
}
Filter = filterHint;
}
InitializeHeaderActions();
InitializeDataComForm();
}
catch (Exception exception)
{
HandleException(exception);
}
}
}
public async Task <CompanyFilter> ToFilter(CompanyFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <CompanyFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
List <Organization> Organizations = await OrganizationService.List(new OrganizationFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = OrganizationSelect.ALL,
OrderBy = OrganizationOrder.Id,
OrderType = OrderType.ASC
});
foreach (var currentFilter in CurrentContext.Filters)
{
CompanyFilter subFilter = new CompanyFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.AppUserId))
{
subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter);
}
//if (FilterPermissionDefinition.Name == nameof(subFilter.OrganizationId))
//{
// var organizationIds = FilterOrganization(Organizations, FilterPermissionDefinition.IdFilter);
// IdFilter IdFilter = new IdFilter { In = organizationIds };
// subFilter.OrganizationId = FilterBuilder.Merge(subFilter.OrganizationId, IdFilter);
//}
//if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null)
//{
// if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id)
// {
// if (subFilter.UserId == null) subFilter.UserId = new IdFilter { };
// subFilter.UserId.Equal = CurrentContext.UserId;
// }
// if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id)
// {
// if (subFilter.UserId == null) subFilter.UserId = new IdFilter { };
// subFilter.UserId.NotEqual = CurrentContext.UserId;
// }
//}
}
}
return(filter);
}
public CompaniesListModel List(CompanyFilter filter, ListRequest <CompanyOrder> list)
{
list = list ?? new ListRequest <CompanyOrder>();
var model = new CompaniesListModel
{
TotalCount = _companyReader.GetCount(filter),
Items = _companyReader.GetList <CompanyInfo>(filter, list.SkipCount, list.TakeCount, list.SortOrder, list.SortDesc)
};
return(model);
}
public FileResult Export(CompanyFilter filter)
{
var response = _companyService.Filter(filter);
var csv = new CsvExport();
csv.ConcatRow(0, "COMPAÑÍA,ESTADO");
csv.ConcatRows(0, "Name,Status", response.Companies);
var stream = csv.RetrieveFile();
return(new StreamFactory().Csv(stream, "Compañías"));
}
public CompanyForm(DataFormDTO dto)
{
this.dto = dto;
dto.caller.Hide();
checkBoxData = new CheckBoxDataInit(dto.db);
filter = new CompanyFilter();
controller = new CompanyController(dto.db);
crud = new CompanyCrud(dto.db);
formDTO = new CUCompanyFormDTO();
InitializeComponent();
}
/// <inheritdoc />
public async Task <PagingResult <CompanyModel> > GetCompanies(CompanyFilter filter = null, Sortable sortable = null, Paginable paginable = null)
{
_logger.LogInformation("GET Companies requested with filters: {filter}, sort params {sortable}, paging params {paginable}", filter, sortable, paginable);
IQueryable <Company> query = await _companyRepository.GetAsync();
if (filter != null)
{
query = Filtering(filter, query);
}
var queryableCount = query;
int totalCount = queryableCount.Count();
if (sortable != null)
{
query = Sorting(sortable, query);
}
if (paginable != null)
{
query = Pagination(paginable, query);
}
var companies = query.ToList();
var companyModelList = new List <CompanyModel>();
var allUsersQuery = await _userRepository.GetAsync(x => !string.IsNullOrEmpty(x.Role)?x.Role.Trim().Equals(salesRoleId) : false);
var allUsers = allUsersQuery.GroupBy(x => x.CompanyId).ToList();
var Tenants = (await _TenantRep.GetAsync()).ToHashSet();
foreach (var company in companies)
{
var companyModel = company.Adapt <CompanyModel>();
var Tenant = Tenants.FirstOrDefault(x => x.Companies.Select(c => c.CompanyId).ToHashSet().Contains(company.Id));
companyModel.CountSalesRep = allUsers.FirstOrDefault(x => x.Key == company.Id)?.Count();
companyModel.CountBranch = company.Branches.Count;
companyModel.Tenant = Tenant?.Adapt <TenantSingleModel>();
companyModelList.Add(companyModel);
}
_logger.LogInformation("GET Companies ended, total companies fetched: {total}", totalCount);
return(new PagingResult <CompanyModel>
{
Total = totalCount,
ItemsPerPage = paginable?.Take ?? default,
Data = companyModelList
});
public IEnumerable <CompanyModel> FindCompanies(CompanyFilter filter, [Required] int page, int countPerPage = 10)
{
try
{
var companies = _companyManager.GetCompanies(filter)
.Skip((page - 1) * countPerPage)
.Take(countPerPage)
.Select(c => new CompanyModel(c, c.Person))
.ToList();
return(companies);
}
catch (Exception ex)
{
throw new Exception($"Не удалось найти компанию из - за ошибки { ex.Message }");
}
}
public IQueryable <Company> GetCompanies(CompanyFilter filter)
{
var query = from company in _context.Companies
where filter.Address == null || company.Address.ToLower().Contains(filter.Address.ToLower()) &&
(filter.BusinessSubject == null || company.BusinessSubject.ToLower()
.Contains(filter.BusinessSubject.ToLower())) &&
(!filter.FormKindId.HasValue || company.FormKindId == filter.FormKindId) &&
(filter.Inn == null || company.Inn.Contains(filter.Inn)) &&
(filter.Kpp == null || company.Kpp.Contains(filter.Kpp)) &&
(filter.Name == null || company.FullName.ToLower().Contains(filter.Name) ||
company.ShortName.ToLower().Contains(filter.Name.ToLower())) &&
(filter.Ogrn == null || company.Ogrn.Contains(filter.Ogrn))
orderby company.Inn
select company;
return(query);
}
public IActionResult Get([FromQuery] CompanyFilter filter)
{
try
{
var result = _service.Get(filter);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
catch (Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex)); }
return(StatusCode(503, e));
}
}
public IActionResult Search([FromBody] CompanyFilterRequest model)
{
if (!model.RangeOfBirthDateIsCorrect())
{
return(new BadRequestObjectResult("Range of date is incorrect"));
}
var filter = new CompanyFilter();
mapper.Map(model, filter);
var result = companyService.SearchCompany(filter);
var companyRequest = new List <CompanyRequest>();
mapper.Map(result, companyRequest);
return(Ok(JsonConvert.SerializeObject(companyRequest)));
}
//public List<AddressInfo> Addresslist { get; set; }
//public List<TeleponeInfo> Contactlist { get; set; }
//public List<ContactPersonInfo> ContactPersonlist { get; set; }
//public List<CityInfo> Cities { get; set; }
public CompanyViewModel()
{
Company = new CompanyInfo();
Companylist = new List <CompanyInfo>();
Filter = new CompanyFilter();
Pager = new PaginationInfo();
FriendlyMessage = new List <FriendlyMessage>();
AddressViewModelList = new AddressViewModel();
ContactViewModelList = new ContactViewModel();
AddressViewModelList.Address.AddressFor = AddressFor.Company.ToString();
ContactViewModelList.ContactDetails.ContactFor = AddressFor.Company.ToString();
//Addresslist = new List<AddressInfo>();
//Contactlist = new List<TeleponeInfo>();
//ContactPersonlist = new List<ContactPersonInfo>();
//Cities = new List<CityInfo>();
}
public async Task <bool> ValidateId(Company Company)
{
CompanyFilter CompanyFilter = new CompanyFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Company.Id
},
Selects = CompanySelect.Id
};
int count = await UOW.CompanyRepository.Count(CompanyFilter);
if (count == 0)
{
Company.AddError(nameof(CompanyValidator), nameof(Company.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <IActionResult> Filter([FromBody] CompanyFilter filter)
{
if (!ModelState.IsValid)
{
return(Ok(GetModelValidationResponse <object>()));
}
try
{
var result = await companyService.GetByFilterAsync(filter);
return(Ok(GetResponse(result)));
}
catch (System.Exception ex)
{
log.Error(ex.Message, ex);
return(Ok(GetExceptionResponse <object>(ex)));
}
}
public IActionResult Find([Bind("CompanyName", "Product")] CompanyFilter companyFilter)
{
var companies = _companyRepository.FilterCompanies(companyFilter);
if (User.Claims.SingleOrDefault(claim => claim.Type.Equals("CompanyId")) != null)
{
var companyId = int.Parse(User.Claims.SingleOrDefault(claim => claim.Type.Equals("CompanyId")).Value);
companies = companies.Where(company => company.CompanyId != companyId).ToList();
var companyIds = _negotiationRepository.GetNegotitationsForCompany(companyId)
.Select(n => n.OtherCompanyId);
companies = companies.Select(c => new CompanyListView
{
CompanyId = c.CompanyId,
CompanyName = c.CompanyName,
HasNegotiation = companyIds.Contains(c.CompanyId),
Representatives = c.Representatives
}).ToList();
}
return(View(companies));
}
public async Task <IActionResult> Get(
[FromQuery] CompanyFilter filterModel,
[FromQuery] Sortable sortable,
[FromQuery] Paginable paginable)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = new PagingResult <CompanyModel>();
if (filterModel.CompanyIds.Any())
{
return(Ok(await _companyManager.GetCompanyNameById(filterModel.CompanyIds)));
}
result = await _companyManager.GetCompanies(filterModel, sortable, paginable);
return(Ok(result));
}
private async Task <bool> ValidateCompany(Customer Customer)
{
if (Customer.CompanyId.HasValue == false)
{
Customer.AddError(nameof(CustomerValidator), nameof(Customer.Company), ErrorCode.CompanyEmpty);
}
else
{
CompanyFilter CompanyFilter = new CompanyFilter
{
Id = new IdFilter {
Equal = Customer.CompanyId.Value
}
};
var count = await UOW.CompanyRepository.Count(CompanyFilter);
if (count == 0)
{
Customer.AddError(nameof(CustomerValidator), nameof(Customer.Company), ErrorCode.CompanyNotExisted);
}
}
return(Customer.IsValidated);
}
public BlogQuery(CompanyRepository repositorio)
{
Field <ListGraphType <CompanyType> >("company",
arguments: new QueryArguments(new QueryArgument[]
{
new QueryArgument <IdGraphType> {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
}
}),
resolve: contexto =>
{
var filtro = new CompanyFilter()
{
Id = contexto.GetArgument <int>("id"),
Name = contexto.GetArgument <string>("name"),
};
return(repositorio.Get(filtro));
}
);
}
public List <Company> GetCompany(CompanyFilter filterValue)
{
var querry = session.Query <Company>();
if (!String.IsNullOrEmpty(filterValue.Keyword))
{
var keyword = filterValue.Keyword;
querry = querry.Where(c => c.Name.Contains(keyword) ||
c.Employees.Any(e => e.FirstName.Contains(keyword) || e.LastName.Contains(keyword)));
}
var dateTimeFrom = filterValue.EmployeeDateOfBirthFrom ?? DateTime.MinValue;
var dateTimeTo = filterValue.EmployeeDateOfBirthTo ?? DateTime.Now;
querry = querry.Where(c => c.Employees.Any(e => e.DateOfBirth >= dateTimeFrom && e.DateOfBirth <= dateTimeTo));
if (filterValue.EmployeeJobTitles != null && filterValue.EmployeeJobTitles.Any())
{
querry = querry.Where(c => c.Employees.Any(e => filterValue.EmployeeJobTitles.Contains(e.JobTitle)));
}
return(querry.ToList());
}
public async Task <bool> ValidateCompany(Contact Contact)
{
if (Contact.CompanyId.HasValue)
{
CompanyFilter CompanyFilter = new CompanyFilter
{
Id = new IdFilter {
Equal = Contact.CompanyId
}
};
var count = await UOW.CompanyRepository.Count(CompanyFilter);
if (count == 0)
{
Contact.AddError(nameof(ContactValidator), nameof(Contact.Company), ErrorCode.CompanyNotExisted);
}
}
else
{
Contact.AddError(nameof(ContactValidator), nameof(Contact.Company), ErrorCode.CompanyEmpty);
}
return(Contact.IsValidated);
}
public async Task <int> Count(CompanyFilter CompanyFilter)
{
try
{
int result = await UOW.CompanyRepository.Count(CompanyFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(CompanyService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(CompanyService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <List <Company> > List(CompanyFilter CompanyFilter)
{
try
{
List <Company> Companys = await UOW.CompanyRepository.List(CompanyFilter);
return(Companys);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(CompanyService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(CompanyService));
throw new MessageException(ex.InnerException);
}
}
}
/// <summary>
/// Restores parameters that were passed on to this dialog.
/// </summary>
private void RestoreParameters()
{
// Validate parameters
if (!QueryHelper.ValidateHash("hash"))
{
throw new Exception("[DataComSelectCompanyPage.RestoreParameters]: Invalid query hash.");
}
Hashtable parameters = WindowHelper.GetItem(QueryHelper.GetString("pid", null)) as Hashtable;
if (parameters == null)
{
throw new Exception("[DataComSelectCompanyPage.RestoreParameters]: The dialog page parameters are missing, the session might have been lost.");
}
// Restore filter
string content = parameters["Filter"] as string;
if (String.IsNullOrEmpty(content))
{
FilterParameter = new CompanyFilter();
}
else
{
JsonSerializer serializer = new JsonSerializer();
FilterParameter = serializer.Unserialize<CompanyFilter>(content);
}
// Restore site identifier
SiteIdentifierParameter = ValidationHelper.GetInteger(parameters["SiteID"], 0);
}
/// <summary>
/// Updates the UI element values with the specified Data.com company filter values.
/// </summary>
/// <param name="filter">A Data.com company filter.</param>
private void SetFilter(CompanyFilter filter)
{
NameTextBox.Text = filter.Name.FirstOrDefault();
}
