Example #1
0
        // GET: Account
        public ActionResult Index(AccountSearchViewModel viewModel)
        {
            IQueryable <AccountViewModel> result = null;

            if (ModelState.IsValid)
            {
                var query = SearchAccountsByCriteria(viewModel);

                result = from a in query
                         select new AccountViewModel
                {
                    Id            = a.Id,
                    AccountNumber = a.AccountNumber,
                    Title         = a.Title,
                    Balance       = a.Balance,
                    CurrencyId    = a.CurrencyId,
                    ClientId      = a.ClientId,
                    ClientName    = a.Client.Name,
                    CreatedDate   = a.CreatedDate,
                    ModifiedDate  = a.ModifiedDate
                };
            }
            else
            {
                var emptyList = new List <AccountViewModel>();
                result = emptyList.AsQueryable();
            }

            viewModel.AccountList = result.ToPagedList(viewModel.page ?? 1, viewModel.pageSize ?? 10);

            ViewBag.CurrencyId = new SelectList(db.Currencies, "Id", "CurrencyCode", null);

            return(View(viewModel));
        }
Example #2
0
        private IQueryable <Account> SearchAccountsByCriteria(AccountSearchViewModel viewModel)
        {
            var query = from a in db.Accounts
                        select a;

            if (viewModel.AccountNumber != null)
            {
                query = from a in query
                        where a.AccountNumber == viewModel.AccountNumber
                        select a;
            }

            if (!string.IsNullOrEmpty(viewModel.Title))
            {
                query = from a in query
                        where a.Title.ToLower().Contains(viewModel.Title.ToLower())
                        select a;
            }

            if (!string.IsNullOrEmpty(viewModel.ClientName))
            {
                query = from a in query
                        where a.Client.Name.ToLower().Contains(viewModel.ClientName.ToLower())
                        select a;
            }

            if (viewModel.MinBalance != null)
            {
                query = from a in query
                        where a.Balance >= viewModel.MinBalance
                        select a;
            }

            if (viewModel.MaxBalance != null)
            {
                query = from a in query
                        where a.Balance <= viewModel.MaxBalance
                        select a;
            }

            if (viewModel.CurrencyId != null)
            {
                query = from a in query
                        where a.CurrencyId == viewModel.CurrencyId
                        select a;
            }

            if (!string.IsNullOrEmpty(viewModel.ClientName))
            {
                query = from a in query
                        join c in db.Clients
                        on a.ClientId equals c.Id
                        where c.Name.ToLower().Contains(viewModel.ClientName.ToLower())
                        select a;
            }

            query = ApplySortOrder(viewModel, query);

            return(query);
        }
 public ActionResult Search(AccountSearchViewModel bind)
 {
     if (ModelState.IsValid)
     {
         return(this.RedirectToAction("Show", new { Username = bind.Username }));
     }
     return(View(bind));
 }
        public JsonResult GetAccountManageList(AccountSearchViewModel SearchViewModel)
        {
            if (SessionAccountSearchViewModel != null)
            {
                if (SearchViewModel != SessionAccountSearchViewModel)
                {
                    SessionAccountSearchViewModel = SearchViewModel;
                }
                else
                {
                    SearchViewModel = SessionAccountSearchViewModel;
                }
            }

            ResponseViewModel result = new ResponseViewModel();

            if (User.Identity.IsAuthenticated)
            {
                try
                {
                    var user = _aspNetUsersService.GetUserModelByName(User.Identity.Name);
                    result.Data           = _aspNetUsersService.GetAccountManageList(SearchViewModel, user);
                    result.IsOk           = true;
                    result.Message        = string.Format("Success");
                    result.HttpStatusCode = HttpStatusCode.OK;
                    _logger.Information($"GetAccountManageList_Success : { result.Message}");
                }
                catch (Exception ex)
                {
                    result.IsOk           = false;
                    result.Exception      = ex;
                    result.Message        = string.Format("False");
                    result.HttpStatusCode = HttpStatusCode.InternalServerError;
                    result.Data           = new List <AccountManageViewModel>();

                    _logger.Information($"GetAccountManageList_Exception : { JsonConvert.SerializeObject(result)}");
                }
            }
            else
            {
                result.IsOk           = false;
                result.Message        = MessageResource.Unauthorized;
                result.HttpStatusCode = HttpStatusCode.Unauthorized;
            }
            result.ResponseTime = string.Format("{0:yyyy/MM/dd HH:mm:ss}", DateTime.Now);
            return(Json(result, JsonRequestBehavior.DenyGet));
        }
Example #5
0
        public JsonResult Search(AccountSearchViewModel model)
        {
            Response response;

            try
            {
                List <UserListViewModel> userList;
                int dataCount;
                using (var db = new KiaGalleryContext())
                {
                    var query = db.User.Select(x => x);

                    if (!string.IsNullOrEmpty(model.term?.Trim()))
                    {
                        query = query.Where(x => x.FirstName.Contains(model.term.Trim()) || x.LastName.Contains(model.term.Trim()) || x.Username.Contains(model.term.Trim()) || x.FirstName.Contains(model.term.Trim().Replace("ی", "ي").Replace("ک", "ك")) || x.LastName.Contains(model.term.Trim().Replace("ی", "ي").Replace("ک", "ك")));
                    }

                    if (model.branchId != null && model.branchId > 0)
                    {
                        query = query.Where(x => x.BranchId == model.branchId);
                    }

                    if (model.workshopId != null && model.workshopId > 0)
                    {
                        query = query.Where(x => x.WorkshopId == model.workshopId);
                    }


                    //if (model.active != null)
                    //{
                    //    query = query.Where(x => x.Active == model.active);
                    //}
                    if (model.deactive == true)
                    {
                        query = query.Where(x => x.Active == false);
                    }
                    dataCount = query.Count();
                    query     = query.OrderBy(x => x.Branch.Name).Skip(model.page * model.count).Take(model.count);

                    userList = query.Select(user => new UserListViewModel()
                    {
                        id           = user.Id,
                        firstName    = user.FirstName,
                        lastName     = user.LastName,
                        username     = user.Username,
                        branchName   = user.Branch.Name,
                        workshopName = user.Workshop.Name,
                        active       = user.Active
                    }).ToList();
                }

                response = new Response()
                {
                    status = 200,
                    data   = new
                    {
                        list      = userList,
                        pageCount = Math.Ceiling((double)dataCount / model.count),
                        count     = dataCount,
                        page      = model.page + 1
                    }
                };
            }
            catch (Exception ex)
            {
                response = Core.GetExceptionResponse(ex);
            }

            return(Json(response, JsonRequestBehavior.AllowGet));
        }
Example #6
0
        private IQueryable <Account> ApplySortOrder(AccountSearchViewModel viewModel, IQueryable <Account> query)
        {
            #region Apply sort order

            switch (viewModel.SortParameter)
            {
            case "AccountNumberSortParameter":
                query = query.OrderBy(q => q.AccountNumber);
                viewModel.AccountNumberSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "AccountNumberSortParameter_desc":
                query = query.OrderByDescending(q => q.AccountNumber);
                viewModel.AccountNumberSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "TitleSortParameter":
                query = query.OrderBy(q => q.Title);
                viewModel.TitleSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "TitleSortParameter_desc":
                query = query.OrderByDescending(q => q.Title);
                viewModel.TitleSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "ClientNameSortParameter":
                query = query.OrderBy(q => q.Client.Name);
                viewModel.ClientNameSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "ClientNameSortParameter_desc":
                query = query.OrderByDescending(q => q.Client.Name);
                viewModel.ClientNameSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "BalanceSortParameter":
                query = query.OrderBy(q => q.Balance);
                viewModel.BalanceSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "BalanceSortParameter_desc":
                query = query.OrderByDescending(q => q.Balance);
                viewModel.BalanceSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "CreatedDateSortParameter":
                query = query.OrderBy(q => q.CreatedDate);
                viewModel.CreatedDateSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "CreatedDateSortParameter_desc":
                query = query.OrderByDescending(q => q.CreatedDate);
                viewModel.CreatedDateSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "ModifiedDateSortParameter":
                query = query.OrderBy(q => q.ModifiedDate);
                viewModel.ModifiedDateSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            case "ModifiedDateSortParameter_desc":
                query = query.OrderByDescending(q => q.ModifiedDate);
                viewModel.ModifiedDateSortParameter = MVCStringHelper.ConvertSortDirection(viewModel.SortParameter);
                break;

            default:
                query = query.OrderBy(q => q.AccountNumber);
                break;
            }

            #endregion

            return(query);
        }