public async Task <ActionResult> LibraryUser(string id = null)
        {
            LibraryUserViewModel viewModel = null;

            if (!string.IsNullOrEmpty(id))
            {
                LibraryUserResponse result = await _libraryUserClient.GetLibraryUserByLibraryUserCode(id);

                if (result.StatusIsSuccessful)
                {
                    viewModel = LibraryUserViewModel.CreateLibraryUserViewModel(result.Data);
                }
                else
                {
                    AddResponseErrorsToModelState(result);
                }
            }

            if (viewModel == null)
            {
                viewModel = new LibraryUserViewModel();
            }

            viewModel.Counties  = Counties.PopulateCountySelectList(viewModel.County);
            viewModel.Countries = Countries.PopulateCountrySelectList(viewModel.Country);

            return(View(viewModel));
        }
        public async Task <ActionResult> SaveLibraryUser(LibraryUserViewModel viewModel)
        {
            if (viewModel.CountyIds != null && viewModel.CountyIds.Length > 0)
            {
                viewModel.County = viewModel.CountyIds[0];
            }
            if (viewModel.CountryIds != null && viewModel.CountryIds.Length > 0)
            {
                viewModel.Country = viewModel.CountryIds[0];
            }

            if (!ModelState.IsValid)
            {
                viewModel.Counties  = Counties.PopulateCountySelectList(viewModel.County);
                viewModel.Countries = Countries.PopulateCountrySelectList(viewModel.Country);
                return(View("LibraryUser", viewModel));
            }

            string currentCode = string.Empty;

            if (string.IsNullOrEmpty(viewModel.LibraryUserCode))
            {
                var insertResponse = await _libraryUserClient.Insert(viewModel.GetApiModel());

                if (!insertResponse.StatusIsSuccessful)
                {
                    AddResponseErrorsToModelState(insertResponse);
                }
                else
                {
                    //viewModel.Id = insertResponse.ResponseResult;
                    currentCode = insertResponse.ResponseResult;
                    TempData["SuccessMessage"] = "Record Inserted";
                }
            }
            else
            {
                currentCode = viewModel.LibraryUserCode;
                var response = await _libraryUserClient.Update(viewModel.GetApiModel());

                if (!response.StatusIsSuccessful)
                {
                    AddResponseErrorsToModelState(response);
                }
                else
                {
                    TempData["SuccessMessage"] = "Record Updated";
                }
            }

            viewModel.Counties  = Counties.PopulateCountySelectList(viewModel.County);
            viewModel.Countries = Countries.PopulateCountrySelectList(viewModel.Country);

            return(View("LibraryUser", viewModel));
        }
        private void CreateSiteUser(ApplicationUser user)
        {
            var libUser = new LibraryUserViewModel
            {
                UserName = user.Email,
                UserRole = "Customer",
                Status   = Enums.UserStatus.Active
            };

            var libUserCmd = new LibraryUserCommand();

            libUserCmd.Execute(libUser);
        }
示例#4
0
        public async Task <ActionResult> RemoveLockOutConfirmed(int id)
        {
            if (ModelState.IsValid)
            {
                if (id > 0)
                {
                    var user = await UserManager.FindByIdAsync(id);

                    if (user == null)
                    {
                        return(HttpNotFound());
                    }

                    user.LockoutEndDateUtc = DateTime.Now.AddDays(-1);

                    var result = await UserManager.UpdateAsync(user);

                    if (!result.Succeeded)
                    {
                        ModelState.AddModelError("", result.Errors.First());
                        return(View());
                    }

                    var userModel = new LibraryUserViewModel
                    {
                        UserName = user.UserName,
                        Status   = Enums.UserStatus.Active
                    };

                    var userCommand = new LibraryUserCommand();
                    userCommand.Execute(userModel);

                    return(RedirectToAction("Index"));
                }
                else
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
            }
            return(View());
        }
        public async Task <ActionResult> GetLibraryUsers(LibraryUserViewModel param)
        {
            int    sortDirection    = 0;
            string strSortDirection = Request.Query["sSortDir_0"]; // asc or desc

            if (strSortDirection == "asc")
            {
                sortDirection = 0;
            }
            else
            {
                sortDirection = 1;
            }

            int       sortColumnIndex  = Convert.ToInt32(Request.Query["iSortCol_0"]);
            int       pageNumber       = (param.iDisplayStart / param.iDisplayLength) + 1;
            PagedBase filterParameters = new PagedBase()
            {
                SearchText = param.sSearch,
                PageNum    = pageNumber,
                PageSize   = param.iDisplayLength,
                OrderBy    = sortColumnIndex,
                SortOrder  = sortDirection
            };

            LibraryUserPagedListResponse response = await _libraryUserClient.GetLibraryUsersPaged(filterParameters);

            if (response.ResponseCode == HttpStatusCode.Unauthorized)
            {
                //return new HttpStatusCodeResult(HttpStatusCode.Unauthorized, Url.Action("Logout", "UserAccount", new { area = "" }));
                return(new StatusCodeResult((int)HttpStatusCode.Unauthorized));
            }

            IEnumerable <string[]> result = new List <string[]>();
            int TotalDisplayRecords       = 0;

            if (response.StatusIsSuccessful)
            {
                if (response.Data.Results != null)
                {
                    result = from c in response.Data.Results
                             select new[] {
                        c.LibraryUserCode,
                        c.LibraryUserName,
                        c.Address,
                        c.PhoneNumber,
                        c.MobilePhoneNumber,
                        c.Email,
                        c.ModifiedBy,
                        c.DateModified.ToString()
                    };

                    TotalDisplayRecords = response.Data.Results.Count();
                }
            }
#pragma warning disable IDE0037
            return(Json(new
            {
                sEcho = param.sEcho,
                iTotalRecords = response.Data.SearchResultCount,
                iTotalDisplayRecords = response.Data.SearchResultCount,
                aaData = result
            }));

#pragma warning restore IDE0037
        }
 // GET: /<controller>/
 public IActionResult Index(LibraryUserViewModel viewModel)
 {
     return(View(viewModel));
 }