public async Task <IActionResult> GetClientsAsync(string filter = "", int page = 1, int pageSize = 15)
{
var response = new PagedResponse <Client>();
try
{
List <Client> clients;
long totalResults;
if (!string.IsNullOrEmpty(filter))
{
foreach (string item in filter.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
{
clients = await _context.Clients
.Where(c => c.Name.ToLower().StartsWith(item))
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync();
totalResults = await _context.Clients
.Where(c => c.Name.ToLower().StartsWith(item))
.LongCountAsync();
response.CurrentFilter = filter;
response.CurrentPage = page;
response.RegisterPerPages = pageSize;
response.TotalRegister = totalResults;
response.TotalPages = (int)Math.Ceiling((double)response.TotalRegister / pageSize);
response.Model = clients;
return(response.ToHttpResponse());
}
}
clients = await _context.Clients.Skip((page - 1) *pageSize)
.Take(pageSize)
.ToListAsync();
totalResults = await _context.Clients.LongCountAsync();
response.CurrentFilter = filter;
response.CurrentPage = page;
response.RegisterPerPages = pageSize;
response.TotalRegister = totalResults;
response.TotalPages = (int)Math.Ceiling((double)response.TotalRegister / pageSize);
response.Model = clients;
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.ToString();
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetProviders(int pageSize = 10, int pageNumber = 1)
{
var response = new PagedResponse <Provider>();
try
{
var query = _context.Providers.AsQueryable <Provider>();
response.PageSize = pageSize;
response.PageNumber = pageNumber;
response.ItemsCount = await query.CountAsync();
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of providers: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support. : " + ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetJobsAsync(int pageSize = 10, int pageNumber = 1, string location = null)
{
var response = new PagedResponse <Job>();
try
{
// Get the "proposed" query from repository
var query = DbContext.GetJobs();
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await query.CountAsync();
// Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total Number of Jobs: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error" + ex;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> SearchAccount([FromBody] SearchAccountRequest request)
{
string method = nameof(SearchAccount);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var query = await DbContext.GetAccounts(request).Paging(response, request.page_start, request.page_size)
.Include(x => x.fund).Include(x => x.accounter)
.ToListAsync();
var entity_list = query
.Select(x => new
{
x.id,
x.name,
x.fund_id,
x.fund_name,
x.accounter_id,
x.accounter_name
});
response.Model = entity_list;
response.ErrorCode = (int?)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> GetStockItemsAsync(int pageSize = 10, int pageNumber = 1, int?lastEditedBy = null, int?
colorID = null, int?outerPackageID = null, int?supplierID = null, int?unitPackageID = null)
{
Logger?.LogDebug("'{0}' has been invoked", nameof(GetStockItemsAsync));
var response = new PagedResponse <StockItem>();
try
{
//Get the propsoed query from repository
var query = DbContext.GetStockItems();
//Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
//Get the total rows
response.ItemsCount = await query.CountAsync();
//Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page '{0}' of '{1}', Total of products: '{2}' ",
response.PageNumber, response.PageCount, response.ItemsCount);
Logger?.LogInformation("The stock items have been retrived successfully");
} catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact technical support.";
Logger?.LogCritical("There was an error on '{0}' invocation: '{1}'", nameof(GetStockItemsAsync), ex);
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetProducts(int?providerId, bool toUpdate = false, int pageSize = 10, int pageNumber = 1)
{
var response = new PagedResponse <Product>();
try
{
IQueryable <Product> query = _context.Products.AsQueryable <Product>().Include(p => p.Family).Include(p => p.Provider);
if (providerId != null)
{
query = query.Where(p => p.ProviderId == providerId);
}
if (toUpdate)
{
query = query.Where(p => p.Quantity <= p.MinStockAvailable);
}
response.PageSize = pageSize;
response.PageNumber = pageNumber;
response.ItemsCount = await query.CountAsync();
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of families: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support. : " + ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> FindAsync(int pageSize = 10, int pageNumber = 1, string name = "")
{
var response = new PagedResponse <CategoryResource>();
try
{
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await categoryService.CountAsync(name);
// Get the specific page from database
var categories = await categoryService.FindAsync(pageSize, pageNumber, name);
response.Model = this.mapper.Map <IEnumerable <Category>, IEnumerable <CategoryResource> >(categories);
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
logger?.LogInformation("The stock items have been retrieved successfully.");
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support.";
logger?.LogCritical("There was an error on '{0}' invocation: {1}", nameof(FindAsync), ex);
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetProductsAsync(int pageSize = 10, int pageNumber = 1)
{
var response = new PagedResponse <Product>();
try
{
// Get the "proposed" query from repository
var query = DbContext.GetProducts();
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await query.CountAsync();
// Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
Logger?.LogInformation("The stock items have been retrieved successfully.");
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error: " + ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> SearchSetting()
{
string method = nameof(SearchSetting);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var query = await DbContext.GetSettings()
// .Include(x=>x.fund)
.ToListAsync();
var entity_list = query
.Select(x => new
{
x.id,
x.type,
x.key,
x.value
});
response.Model = entity_list;
response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> GetApplicantsAsync(int pageSize = 10, int pageNumber = 1)
{
Logger?.LogDebug("'{0}' has been invoked", nameof(GetApplicantsAsync));
var response = new PagedResponse <Applicants>();
try
{
// Get the "proposed" query from repository
var query = DbContext_.GetApplicants();
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await query.CountAsync();
// Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
Logger?.LogInformation("The stock items have been retrieved successfully.");
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support.";
Logger?.LogCritical("There was an error on '{0}' invocation: {1}", nameof(GetApplicantsAsync), ex);
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetFamilies(int pageSize = 100, int pageNumber = 1)
{
var response = new PagedResponse <Family>();
try
{
// Get the "proposed" query from repository
var query = _context.Families.AsQueryable <Family>();
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await query.CountAsync();
// Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support. : " + ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetProviderOrders(int?providerId, bool lastProviderOrder = false, int pageSize = 10, int pageNumber = 1)
{
var response = new PagedResponse <ProviderOrder>();
try
{
IQueryable <ProviderOrder> query = _context.ProviderOrders.AsQueryable <ProviderOrder>().Include(c => c.ProviderOrderItems).ThenInclude(c => c.Product).Include(c => c.Provider).OrderBy(c => c.Status);
if (providerId != null)
{
query = query.Where(c => c.ProviderId == providerId);
}
if (lastProviderOrder)
{
query = query.Where(po => po.Status == Models.Utils.OrderStatus.NONE).OrderByDescending(po => po.CreatedAt).Take(1);
}
response.PageSize = pageSize;
response.PageNumber = pageNumber;
response.ItemsCount = await query.CountAsync();
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of providerorders: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.StackTrace;
response.Message = ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetClientOrders(int?clientId, int pageSize = 10, int pageNumber = 1)
{
var response = new PagedResponse <ClientOrder>();
try
{
IQueryable <ClientOrder> query = _context.ClientOrders.AsQueryable <ClientOrder>().Include(c => c.ClientOrderItems).ThenInclude(ci => ci.Product).Include(c => c.Client).OrderBy(c => c.Status);
if (clientId != null)
{
query = query.Where(c => c.ClientId == clientId);
}
// Set paging values
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get the total rows
response.ItemsCount = await query.CountAsync();
// Get the specific page from database
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.StackTrace;
response.Message = ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetServicesAsync(string filter = "", int page = 1, int pageSize = 15)
{
var response = new PagedResponse <Service>();
try
{
List <Service> services;
long totalResults;
if (!string.IsNullOrEmpty(filter))
{
foreach (string item in filter.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
{
services = await _context.Services
.Where(c => c.Name.ToLower().StartsWith(item))
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync();
totalResults = await _context.Services
.Where(c => c.Name.ToLower().StartsWith(item))
.LongCountAsync();
response = await createResponsePaginated(filter, page, pageSize, totalResults, services);
return(response.ToHttpResponse());
}
}
services = await _context.Services.Skip((page - 1) *pageSize)
.Take(pageSize)
.ToListAsync();
totalResults = await _context.Services.LongCountAsync();
response = await createResponsePaginated(filter, page, pageSize, totalResults, services);
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.ToString();
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> SearchDeposit([FromBody] SearchDepositRequest request)
{
string method = nameof(SearchDeposit);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var query = await DbContext.GetDeposits(request).Paging(response, request.page_start, request.page_size)
.Include(x => x.account).ThenInclude(x => x.fund)
.Include(x => x.unit_cost)
.Include(x => x.purchases).ThenInclude(x => x.buyer)
.Include(x => x.purchases).ThenInclude(x => x.bank_copartner)
.ToListAsync();
var entity_list = query
.Select(x => new
{
x.account_id,
x.account_name,
x.cancel_cost,
x.count,
x.date,
x.fund_name,
x.id,
x.issue_cost,
x.purchases_count,
x.status,
x.unit_cost_id,
x.amount,
purchases = x.purchases.Select(i => new Purchase {
id = i.id, buyer_id = i.buyer_id, buyer = new User {
first_name = i.buyer.first_name, last_name = i.buyer.last_name
}, bank_copartner = new User {
first_name = i.bank_copartner?.first_name, last_name = i.bank_copartner?.last_name
}
}),
x.fund_id
}).OrderByDescending(x => x.date);
response.Model = entity_list;
response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> UserProfitLostDashboardSearch()
{
string method = nameof(UserProfitLostDashboardSearch);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var user_purchases = DbContext.GetPurchases();
var query = (await user_purchases
.Include(x => x.deposit).ThenInclude(x => x.unit_cost).ThenInclude(x => x.fund)
.Include(x => x.buyer)
// .Include(x => x.deposits).ThenInclude(x => x.account).ThenInclude(x => x.fund)
.GroupBy(x => new { x.buyer_id }).ToListAsync())
.Select(x => new
{
x.First().buyer_id,
x.First().buyer.first_name,
x.First().buyer.last_name,
total_amount_investment = x.Sum(y => y.amount),
current_investment_value = x.Sum(y => y.deposit.value_of_shares),
net_profit_to_loss_share_without_commission = x.Sum(y => y.deposit.profit_rate),
expected_bank_interest = x.Where(y => y.bank_copartner_id == x.First().buyer_id).Sum(z => z.expected_bank_interest)
});
var entity_list = query
.Select(x => new
{
x.buyer_id,
x.first_name,
x.last_name,
x.total_amount_investment, //کل مبلغ سرمایهگذاری
x.current_investment_value, //ارزش کنونی سرمایهگذاری
x.net_profit_to_loss_share_without_commission, //سهم خالص سود به زیان بدون کارمزد
x.expected_bank_interest //سود انتظاری بانکی
});
response.Model = entity_list;
response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> TestNoDb()
{
string method = nameof(TestNoDb);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method);
PagedResponse <Deposit> response = new PagedResponse <Deposit>();
try
{
response.ErrorCode = (int?)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> GetProductsPaged([FromQuery] PagedRequestModel filter)
{
var response = new PagedResponse <ProductResponseModel>();
try
{
var result = await _productService.GetPagedAsync(filter);
response.Data = result.Items;
response.ItemsCount = result.TotalCount;
}
catch (Exception ex)
{
response.Meta.Code = -1;
response.Meta.ErrorMessage = "Internal server error.";
_logger.Error("There was an error on 'GetProductsPaged' invocation.", ex);
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> Get(int pageIndex = 1, int pageSize = 100, int id = 0, int workState = 0, int gender = -1)
{
GlobalParamFilter filters = new GlobalParamFilter
{
Status = Constants.Status.Active,
PageIndex = pageIndex,
PageSize = pageSize > 0 ? pageSize : int.MaxValue,
WorkState = workState,
Gender = gender
};
var response = new PagedResponse <MISA.Common.Models.Employee> {
Success = true
};
try
{
if (id != 0)
{
var data = await _employeeService.GetById(id);
response.Data = data;
}
else
{
var entities = await _employeeService.GetAll(filters);
response.Data = entities.ToList();
response.PageIndex = pageIndex;
response.PageSize = pageSize;
response.TotalPages = entities.TotalPages;
response.TotalCount = entities.TotalCount;
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> SearchPurchase([FromBody] SearchPurchaseRequest request)
{
string method = nameof(SearchPurchase);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var entity_list = await DbContext.GetPurchaseList(response, request);
response.Model = entity_list;
response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> Test()
{
string method = nameof(Test);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var entity_query = DbContext.GetDeposits().Paging(response, 0, 100);
List <Deposit> entity_list = await entity_query.ToListAsync();
response.Model = entity_list;
response.ErrorCode = (int?)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
public async Task <IActionResult> GetProductsAsync(int?pageSize = 10, int?pageNumber = 1, string name = "", string sortBy = "popularity")
{
Logger?.LogDebug("'{0}' has been invoked", nameof(GetProductsAsync));
var response = new PagedResponse <Product>();
try
{
// Get query from repository
var query = Service.DbContext.GetProducts(name);
// Sorting list
if (sortBy == "popularity")
{
query = query.OrderByDescending(item => item.Likes);
}
else
{
query = query.OrderBy(item => item.ProductName);
}
// Set paging's information
response.PageSize = (int)pageSize;
response.PageNumber = (int)pageNumber;
response.ItemsCount = await query.CountAsync();
// Retrieve items by page size and page number, set model for response
response.Model = await query.Paging(response.PageSize, response.PageNumber).ToListAsync();
response.Message = string.Format("Page {0} of {1}, Total of products: {2}.", pageNumber, response.PageCount, response.ItemsCount);
Logger?.LogInformation(response.Message);
}
catch (Exception ex)
{
response.SetError(Logger, nameof(GetProductsAsync), ex);
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetAllBinsAsync([FromQuery] PagingParams pageParams = null)
{
var response = new PagedResponse <BinViewModel>();
try
{
var bins = await _binRepository.ReadAllAsync(pageParams);
response.Model = _mapper.Map <List <BinViewModel> >(bins);
response.PageNumber = pageParams.PageNumber;
response.PageSize = pageParams.PageSize;
response.ItemsCount = await _binRepository.GetCount();
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "Server Error";
response.ErrorDetails = $"{ex.Message}\n{ex.InnerException?.Message}\n{ex.InnerException?.InnerException?.Message}";
}
return(response.ToHttpResponse());
}
public async Task <IActionResult> GetStockItemsAsync(int pageSize = 10, int pageNumber = 1, int?lastEditedBy = null,
int?colorID = null, int?outerPackageID = null, int?supplierID = null, int?unitPackageID = null)
{
Logger?.LogDebug("'{0}' foi chamada", nameof(GetStockItemsAsync));
var response = new PagedResponse <StockItem>();
try
{
// Get da query "proposta" do repositório
var query = _context.GetStockItems();
// Seta o valor das páginas
response.PageSize = pageSize;
response.PageNumber = pageNumber;
// Get o total de linhas
response.ItemsCount = await query.CountAsync();
// Get a página expecífica do banco
response.Model = await query.Paging(pageSize, pageNumber).ToListAsync();
response.Message = string.Format("Página {0} de {1}, Total de produtos: {2}.", pageNumber, response.PageCount, response.ItemsCount);
Logger?.LogInformation("Os itens foram trazidos com sucesso.");
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "Houve um erro interno, por favor contate o suporte.";
Logger?.LogCritical("Houve um erro na chamada '{0}' invocando: {1} ", nameof(GetStockItemsAsync), ex);
}
return(response.ToHttpResponse());
}
