//Get customers
public ActionResult GetClientList()
{
ClientListModel clientListModel = new ClientListModel();
var clients = _context.Client.AsQueryable().Include(c => c.Checklist);
return(View(clients));
}
public IActionResult each_admin_ClientList([FromBody] ClientListModel model)
{
TranStatus transaction = new TranStatus();
Dictionary <String, Object> dctData = new Dictionary <string, object>();
HttpStatusCode statusCode = HttpStatusCode.OK;
try
{
List <ClientListModel> each_admin_ClientList = new List <ClientListModel>();
int rowcount = 0;
each_admin_ClientList = iclient.each_admin_ClientList(model, out rowcount);
dctData.Add("each_admin_ClientList", each_admin_ClientList);
dctData.Add("RowCount", rowcount);
//var clientList = await iclient.each_admin_ClientList(model);
//dctData.Add("each_admin_ClientList", clientList);
}
catch (Exception ex)
{
transaction = CommonHelper.TransactionErrorHandler(ex);
statusCode = HttpStatusCode.BadRequest;
}
dctData.Add("Status", transaction);
return(this.StatusCode(Convert.ToInt32(statusCode), dctData));
}
//Update
public async Task <TranStatus> updateClient(int ID, ClientListModel model)
{
using (clientRepository = new ClientRepository())
{
return(await clientRepository.updateClient(ID, model));
}
}
//Update
public async Task<TranStatus> updateClient(int ID, ClientListModel model)
{
using (var connection = new SqlConnection(ConnectionString))
{
await connection.OpenAsync();
TranStatus transaction = new TranStatus();
DynamicParameters parameter = new DynamicParameters();
parameter.Add("@ID", ID);
parameter.Add("@ClientName", model.ClientName);
parameter.Add("@Email", model.Email);
parameter.Add("@Contact", model.Contact);
parameter.Add("@Gender", model.Gender);
parameter.Add("@Address", model.Address);
parameter.Add("@Street", model.Street);
parameter.Add("@Cid", model.Cid);
parameter.Add("@Sid", model.Sid);
parameter.Add("@Cityid", model.Cityid);
parameter.Add("@PostalCode", model.PostalCode);
parameter.Add("@Latitude", model.Latitude);
parameter.Add("@Longitude", model.Longitude);
parameter.Add("@Modifiedby", model.Modifiedby);
parameter.Add("@Message", dbType: DbType.String, direction: ParameterDirection.Output, size: 500);
parameter.Add("@Code", dbType: DbType.Int32, direction: ParameterDirection.Output);
await connection.QueryAsync("updateClient", parameter, commandType: CommandType.StoredProcedure);
transaction.returnMessage = parameter.Get<string>("@Message");
transaction.code = parameter.Get<int>("@Code");
return transaction;
}
}
public List <ClientListModel> each_user_ClientList(ClientListModel model, out int RowCount)
{
using (clientRepository = new ClientRepository())
{
return(clientRepository.each_user_ClientList(model, out RowCount));
}
}
public async Task <IActionResult> PutClientListModel([FromRoute] int id, [FromBody] ClientListModel clientListModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != clientListModel.ClientId)
{
return(BadRequest());
}
_context.Entry(clientListModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientListModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Create([Bind("GameId", "GameFormat")] ClientListModel ClientListModel)
{
if (ModelState.IsValid)
{
ClientListModel.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
bool alreadyExists = _unitOFWork.ClientRepo.Get(filter: x => x.GameId == ClientListModel.GameId && x.UserId == ClientListModel.UserId).Any();
if (alreadyExists)
{
return(StatusCode(403, "Game Already Exists in Database"));
}
_unitOFWork.ClientRepo.Insert(ClientListModel);
_unitOFWork.Commit();
return(StatusCode(200, "Game successfully added to database"));
}
string modalStateErrors = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
return(StatusCode(500, modalStateErrors));
}
public JsonResult List(string search, string sort, string order, int offset, int limit)
{
IEnumerable <ClientListModel> tableData = new List <ClientListModel>();
tableData = ClientListModel.ConvertFromEntity(_clientRepository.GetPaging(search, sort, order).ToList());
var rows = tableData.ToList().GetRange(offset, Math.Min(limit, tableData.Count() - offset));
return(Json(new { rows = rows, total = tableData.Count() }, JsonRequestBehavior.AllowGet));
}
public ActionResult Clients()
{
PharmacyEntities entities = new PharmacyEntities();
ClientListModel model = new ClientListModel();
model.ClientList = entities.MainClientDatas.ToList();
return(View(model));
}
public ActionResult Index(ClientListFiltersModel filters)
{
int pageTotal;
var clients = _clientService.GetAll("CreatedDate", "DESC", filters.Criteria, filters.Page, DefaultPageSize, out pageTotal);
var pagedList = new StaticPagedList <ClientDto>(clients, filters.Page, DefaultPageSize, pageTotal);
var listModel = new ClientListModel(pagedList, filters);
return(View(listModel));
}
public async Task <IActionResult> PostClientListModel([FromBody] ClientListModel clientListModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
clientListModel.UserId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
_context.ClientListModel.Add(clientListModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetClientListModel", new { id = clientListModel.ClientId }, clientListModel));
}
public async Task <IActionResult> updateClient(int ID, [FromBody] ClientListModel model)
{
Dictionary <String, Object> dctData = new Dictionary <string, object>();
HttpStatusCode statusCode = HttpStatusCode.OK;
TranStatus transaction = new TranStatus();
try
{
transaction = await iclient.updateClient(ID, model);
}
catch (Exception ex)
{
transaction = CommonHelper.TransactionErrorHandler(ex);
statusCode = HttpStatusCode.BadRequest;
}
dctData.Add("Status", transaction);
return(this.StatusCode(Convert.ToInt32(statusCode), dctData));
}
public List<ClientListModel> each_user_ClientList(ClientListModel model, out int RowCount)
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
DynamicParameters parameter = new DynamicParameters();
parameter.Add("@UserID", model.userId);
parameter.Add("@pageIndex", model.pageIndex);
parameter.Add("@pageSize", model.pageSize);
parameter.Add("@RowCount", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = connection.Query<ClientListModel>("each_user_ClientList", parameter, commandType: CommandType.StoredProcedure);
RowCount = parameter.Get<int>("@RowCount");
return result.ToList();
}
}
/// <summary>
/// View a list of clients
/// </summary>
/// <returns>Returns default list of clients</returns>
public ActionResult Index()
{
ClientListModel m = new ClientListModel();
if (TempData["ClientVisitSaveDataModel"] != null)
{
m.SearchCriteriaModel = (ClientSearchCriteriaModel)TempData["ClientVisitSaveDataModel"];
DataPage <ClientBaseInfo> clients = clientBusinessLogic.Client_Find(
m.SearchCriteriaModel.GetClientSearchCriteria(),
new List <SortCriteria <ClientSortField> >(),
new PageRequest()
{
PageNumber = 1, PageSize = 100
});
m.Items = clients.Data
.Select(item => new ClientBaseInfoModel(item));
}
return(Index(m));
}
public ActionResult Index(ClientListModel clientListModel)
{
ClientSearchCriteria criteria = clientListModel.SearchCriteriaModel.GetClientSearchCriteria();
DataPage <ClientBaseInfo> clients = clientBusinessLogic.Client_Find(
criteria,
new List <SortCriteria <ClientSortField> >(),
new PageRequest()
{
PageNumber = clientListModel.PageNumber, PageSize = clientListModel.PageSize
});
ClientListModel model = new ClientListModel()
{
Items = clients.Data
.Select(item => new ClientBaseInfoModel(item)),
SearchCriteriaModel = new ClientSearchCriteriaModel(
criteria),
PageNumber = clientListModel.PageNumber,
PageSize = clientListModel.PageSize,
TotalCount = clients.TotalCount
};
return(View(model));
}
public ActionResult List(DataTablesParam dataTableParam, ClientListModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageCatalog))
{
return(AccessDeniedView());
}
var clients = _clientService.GetAllClients(model.SearchClientName,
dataTableParam.PageIndex, dataTableParam.PageSize, true);
var total = clients.Count();
var result = new DataTablesData
{
iTotalRecords = total,
iTotalDisplayRecords = total,
sEcho = dataTableParam.sEcho,
aaData = clients.Select(x => x.ToModel()).Cast <object>().ToArray(),
};
return(new JsonResult
{
Data = result
});;
}
public void DeleteClient(ClientListModel game) => _clientContext.ClientListModel.Remove(game);
public void UpdateClient(ClientListModel game) => _clientContext.Update(game);
public void InsertClient(ClientListModel game) => _clientContext.Add(game);
