public ActionResult AddRoles(Guid productId, string version, string error = null)
        {
            if(error != null)
            {
                ModelState.AddModelError("", error);
            }

            var product = _productRepository.Find(productId);

            var currentRoles = product.Versions.Single(x => x.Name == version).Roles.Select(x => x.Name);

            var baseImages = _baseImageRepository.FindAll().ToDictionary(x => x.Id, x => x.Name);
            var model = new RoleViewModel
            {
                ProductId = productId,
                ProductName = product.Name,
                VersionName = version,
                BaseImages = baseImages,
                Ports = new List<PortViewModel> {  new PortViewModel { DnsTtl = 3600}},
                CurrentRoles = currentRoles.ToList(),
                VolumeSize = 60,
                InstanceTypes = _stackItConfiguration.InstanceTypes.Select(x => x.Name).ToList()
            };

            return View(model);
        }

        public ActionResult ManageRole(RoleViewModel model)
        {
            if (model.Role == null)
            {
                model.Role = new Role();
            }

            if (!string.IsNullOrEmpty(model.Role.sort))
            {
                model.Role.SortExp = model.Role.sort + " " + model.Role.sortdir;
            }

            if (model.Role.PageSize == 0)
            {
                int PageSize = Convert.ToInt32(ConfigurationManager.AppSettings["PageSize"]);
                model.Role.PageSize = PageSize;
            }

            if (model.Role.PageIndex == 0)
            {
                model.Role.PageIndex = 1;
            }
            model.RoleList = new List<Role>();
            model.Role.TotalCount = 0;
            model.RoleList = _IRoleService.GetAll(model.Role).ToList();
            if (model.RoleList != null && model.RoleList.Count > 0)
            {
                int TotalCount = model.RoleList[0].TotalCount;
                model.Role.TotalCount = TotalCount;
            }

            return View(model);
        }

        public RoleViewModel getRoleFromId(string id)
        {
            var db = new BwareContext();
            var roleViewModel = new RoleViewModel();

            roleViewModel = db.AspNetRoles.Where(r => r.Name == id).Select(r => new RoleViewModel() { CurrentName = r.Name }).FirstOrDefault();
            return roleViewModel;
        }

 public static RoleViewModel ToViewModel(IdentityRole Role)
 {
     var roleViewModel = new RoleViewModel()
     {
         Id = Role.Id,
         Name = Role.Name
     };
     return roleViewModel;
 }

        /// <summary>
        /// 新增角色
        /// </summary>
        /// <returns></returns>
        public ActionResult Create()
        {
            var viewModel = new RoleViewModel
            {
                MenuCheckList = roleService.GetMenuByRoleId(null)
            };

            return View(viewModel);
        }

 public List<RoleViewModel> GetAllRoles()
 {
     var rolesList = new List<RoleViewModel>();
     foreach (var role in _db.Roles)
     {
         var roleModel = new RoleViewModel(ConvertRole(role));
         rolesList.Add(roleModel);
     }
     return rolesList;
 }

        public static RoleViewModel ToViewModel(this Model.Role rolePOCO)
        {
            var roleViewModel = new RoleViewModel();

            return new RoleViewModel()
            {
                roleID = rolePOCO.roleID,
                roleName = rolePOCO.roleName,
            };
        }

 public ActionResult Modify(int id, RoleViewModel viewmodel)
 {
     if (ModelState.IsValid)
     {
         viewmodel.roleID =id ;
         OperationContext.ServiceSession.RoleService.Update(viewmodel.ToPOCO(), "roleName",  "roleIsDeleted");
         OperationContext.ServiceSession.SaveChange();
         return OperationContext.SendAjaxMessage(AjaxMessageStatus.OperationSuccess, "", "", null);
     }
     return OperationContext.SendAjaxMessage(AjaxMessageStatus.OperationFailed, "Please enable javascript in the browser", "", null);
 }

        public ActionResult Edit(RoleViewModel vmChanged)
        {
            var vm = GetViewModelFromTempData<RoleViewModel>();
            if (vm == null) { return RedirectToReferrer(); }

            vm.DisplayName = Strings.RoleDetailView_Title;
            vm.LatestControllerAction = ControllerAction.Edit;
            vm.ApplyFormAttributes(vmChanged.SelectedItem);

            return StoreEntity(vm);
        }

        public async Task<ActionResult> Edit(string id)
        {
            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            var role = await IdentityRepository.RoleManager.FindByIdAsync(id);

            if (role == null) return HttpNotFound();

            RoleViewModel roleModel = new RoleViewModel { Id = role.Id, Name = role.Name };

            return View(roleModel);
        }

 public static RoleViewModel ToViewModel(this IdentityRole role)
 {
     string Editor = "<a class='btn btn-success' href='javascript:void(0);'><i class='fa fa-cog'></i> 编辑</a>";
     string Delete = "<a class='btn btn-danger' href='javascript:void(0);'><i class='fa fa-remove'></i> 删除</a></td>";
     RoleViewModel model = new RoleViewModel()
     {
         Id = role.Id,
         Name = role.Name,
         Other = string.Format(Delete+Editor),
     };
     return model;
 }

 public async Task<ActionResult> Create(RoleViewModel roleViewModel) {
     if (ModelState.IsValid) {
         var role = new IdentityRole(roleViewModel.Name);
         var roleresult = await RoleManager.CreateAsync(role);
         if (!roleresult.Succeeded) {
             ModelState.AddModelError("", roleresult.Errors.First());
             return View();
         }
         return RedirectToAction("Index");
     }
     return View();
 }

 public ActionResult Add(RoleViewModel viewModel)
 {
     if (ModelState.IsValid)
     {
         OperationContext.ServiceSession.RoleService.Add(viewModel.ToPOCO());
         OperationContext.ServiceSession.SaveChange();
         return OperationContext.SendAjaxMessage(AjaxMessageStatus.OperationSuccess, "", "", null);
     }
     else
     {
         return OperationContext.SendAjaxMessage(AjaxMessageStatus.OperationFailed, "Please enable javascript in browser.", "", null);
     }
 }

        public ActionResult Add(RoleViewModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            this.roles.Add(model.Name);

            this.SetTempDataSuccessMessage(string.Format("The role {0} was added successfully!", model.Name));

            return this.RedirectToAction("Index", "Roles");
        }

        public async Task<ActionResult> Create(RoleViewModel roleViewModel)
        {
            if (!ModelState.IsValid) return View();

            var role = new IdentityRole(roleViewModel.Name);

            IdentityResult result = await IdentityRepository.RoleManager.CreateAsync(role);

            IsResultNotSucceededAddModelError(result);

            if (result.Succeeded) return RedirectToAction("Index");

            return View();
        }

        /// <summary>
        /// 編輯角色
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public ActionResult Edit(Guid id)
        {
            var data = roleService.GetById(id);
            if (data == null)
                return HttpNotFound();

            var viewModel = new RoleViewModel
            {
                Role = data,
                MenuCheckList = roleService.GetMenuByRoleId(id)
            };

            return View(viewModel);
        }

 public ActionResult Delete(string id)
 {
     if (id == null)
     {
         return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
     }
     var role = _db.Roles.First(r => r.Name == id);
     var model = new RoleViewModel(role);
     if (role == null)
     {
         return HttpNotFound();
     }
     return View(model);
 }

 public async Task<ActionResult> Create(RoleViewModel roleViewModel)
 {
     if (ModelState.IsValid)
     {
         var role = Mapper.Map<ApplicationRole>(roleViewModel);
         var roleresult = await _roleManager.CreateAsync(role);
         if (!roleresult.Succeeded)
         {
             ModelState.AddModelError("", roleresult.Errors.First());
             return View();
         }
         return RedirectToAction("Index");
     }
     return View();
 }

        public ActionResult DeleteConfirmed(RoleViewModel roleViewModel)
        {
            IdentityRole role = db.Roles.Find(roleViewModel.Id);
            var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));

            var roleresult = roleManager.DeleteAsync(role);

            if (roleresult.Result != IdentityResult.Success)
            {
                ModelState.AddModelError("", roleresult.Result.Errors.First());
                return View();
            }

            return RedirectToAction("Index");
        }

 public bool Insert(RoleViewModel model)
 {
     bool result = false;
     var role = new ApplicationRole(model.RoleName, model.Description);
     if (_idman.RoleExists(model.RoleName))
     {
         result = false;
     }
     else
     {
         _idman.CreateRole(model.RoleName, model.Description);
         result = true;
     }
     return result;
 }