示例#1
0
        public async Task <ActionResult> UpdateAccountDetail(string AccountId, string Mainphone, string Fax, string Tollfree, string Webaddress, string Type, string Address1, string Address2,
                                                             string Suburb, string State, string PostalCode, string Billing_Method, string Billable_Rate, string Service_Rage)
        {
            ClaimTeamLoginModel client = (ClaimTeamLoginModel)Session[SessionHelper.claimTeamLogin];
            AccountUpdateModel  model  = new AccountUpdateModel();

            model.AccountId      = AccountId;
            model.Mainphone      = Mainphone;
            model.Fax            = Fax;
            model.Tollfree       = Tollfree;
            model.Webaddress     = Webaddress;
            model.Type           = Type;
            model.Address1       = Address1;
            model.Address2       = Address2;
            model.Suburb         = Suburb;
            model.State          = State;
            model.PostalCode     = PostalCode;
            model.Billing_Method = Billing_Method;
            model.Billable_Rate  = Billable_Rate;
            model.Service_Rage   = Service_Rage;
            AccountListRepo accountListRepo = new AccountListRepo();
            bool            result          = await accountListRepo.UpdateAccount(model, client.UserId);

            return(RedirectToAction("Index"));
        }
        public async Task UpdateAccountsAmount(AccountUpdateModel accountUpdateModel)
        {
            var transactionMessageModel = new TransactionMessageModel
            {
                TransactionId     = accountUpdateModel.TransactionId,
                SenderAccountId   = accountUpdateModel.SenderAccountId,
                ReceiverAccountId = accountUpdateModel.ReceiverAccountId,
                Amount            = accountUpdateModel.Amount
            };

            if (await IsTransactionPermitted(accountUpdateModel))
            {
                try
                {
                    var senderAccount = await _mediator.Send(
                        new GetAccountByIdQuery(accountUpdateModel.SenderAccountId)
                        );

                    var receiverAccount = await _mediator.Send(
                        new GetAccountByIdQuery(accountUpdateModel.ReceiverAccountId)
                        );

                    if (senderAccount != null && receiverAccount != null)
                    {
                        if (senderAccount.Amount >= accountUpdateModel.Amount)
                        {
                            senderAccount.Amount   -= accountUpdateModel.Amount;
                            receiverAccount.Amount += accountUpdateModel.Amount;

                            await _mediator.Send(new UpdateAccountCommand(senderAccount.Id, senderAccount));

                            await _mediator.Send(new UpdateAccountCommand(receiverAccount.Id, receiverAccount));

                            transactionMessageModel.Status = "Finished";
                            transactionMessageModel.Info   = "The transaction was successful";
                            _transactionUpdateSender.UpdateTransaction(transactionMessageModel);
                        }
                        else
                        {
                            transactionMessageModel.Status = "Failed";
                            transactionMessageModel.Info   = "The account balance is too low";
                            _transactionUpdateSender.UpdateTransaction(transactionMessageModel);
                        }
                    }
                }
                catch (Exception ex)
                {
                    transactionMessageModel.Status = "Failed";
                    transactionMessageModel.Info   = "Account number not found. The operation has failed";
                    _transactionUpdateSender.UpdateTransaction(transactionMessageModel);
                }
            }
            else
            {
                transactionMessageModel.Status = "Failed";
                transactionMessageModel.Info   = "Operation prohibited";
                _transactionUpdateSender.UpdateTransaction(transactionMessageModel);
            }
        }
示例#3
0
 public ActionResult Account(AccountUpdateModel model)
 {
     if (ModelState.IsValid)
     {
         accountInformation.UpdateAccount(model);
     }
     return(View());
 }
示例#4
0
        public async Task <IResultModel> Update(AccountUpdateModel model)
        {
            var entity = await _accountRepository.GetAsync(model.Id);

            if (entity == null)
            {
                return(ResultModel.Failed("账户不存在!"));
            }
            if (entity.IsLock)
            {
                return(ResultModel.Failed("账户锁定,不允许修改"));
            }

            var account = _mapper.Map(model, entity);

            var exists = await Exists(account);

            if (!exists.Successful)
            {
                return(exists);
            }

            using (var tran = _accountRepository.BeginTransaction())
            {
                var result = await _accountRepository.UpdateAsync(account, tran);

                if (result)
                {
                    result = await _accountRoleRepository.DeleteByAccount(account.Id, tran);

                    if (result)
                    {
                        if (model.Roles != null && model.Roles.Any())
                        {
                            var accountRoleList = model.Roles.Select(m => new AccountRoleEntity {
                                AccountId = account.Id, RoleId = m
                            }).ToList();
                            if (await _accountRoleRepository.AddAsync(accountRoleList, tran))
                            {
                                tran.Commit();
                                ClearPermissionListCache(account.Id);

                                return(ResultModel.Success());
                            }
                        }
                        else
                        {
                            tran.Commit();
                            ClearPermissionListCache(account.Id);

                            return(ResultModel.Success());
                        }
                    }
                }
            }

            return(ResultModel.Failed());
        }
示例#5
0
 public async Task <ActionResult> Update(
     [FromRoute] string id,
     [FromBody] AccountUpdateModel account)
 {
     return(await PatchResult(
                async() => await accountService.Update(id, account),
                nameof(account)
                ));
 }
        public async Task <IResultModel> Update(AccountUpdateModel model)
        {
            var user = _accountRepository.FindEntity(model.Uid);

            if (user == null)
            {
                return(ResultModel.Failed("账户不存在!"));
            }
            if (user.LoginName != model.LoginName)//改了用户名
            {
                if (await _accountRepository.ExistsLoginName(model.LoginName))
                {
                    return(ResultModel.Failed("用户名已存在"));
                }
            }
            if (user.Phone != model.Phone)//改了手机号码
            {
                if (await _accountRepository.ExistsPhone(model.Phone))
                {
                    return(ResultModel.Failed("手机号已存在"));
                }
            }
            var account = _mapper.Map(model, user);

            var exists = await Exists(account);

            if (!exists.Successful)
            {
                return(exists);
            }

            _accountRepository.BeginTrans();


            int result = await _accountRepository.UpdateAsync(account);

            if (result > 0)
            {
                result = _accountRoleRepository.Delete(a => a.Uid == account.Uid);
                if (result > 0)
                {
                    //插入角色绑定信息
                    if (model.RoleList != null && model.RoleList.Count > 0)
                    {
                        var accountRoleList = model.RoleList.Select(m => new AccountRoleEntity {
                            Uid = account.Uid, RoleId = m
                        }).ToList();
                        await _accountRoleRepository.InsertAsync(accountRoleList);
                    }

                    _accountRepository.Commit();
                    return(ResultModel.Success());
                }
            }

            return(ResultModel.Failed());
        }
示例#7
0
        public async Task <IResultModel> Update(AccountUpdateModel model)
        {
            var entity = await _accountRepository.GetAsync(model.Id);

            if (entity == null)
            {
                return(ResultModel.Failed("账户不存在!"));
            }
            if (entity.IsLock)
            {
                return(ResultModel.Failed("账户锁定,不允许修改"));
            }

            var account = _mapper.Map(model, entity);

            var exists = await Exists(account);

            if (!exists.Successful)
            {
                return(exists);
            }

            using (var uow = _dbContext.NewUnitOfWork())
            {
                var result = await _accountRepository.UpdateAsync(account, uow);

                if (result)
                {
                    result = await _accountRoleRepository.DeleteByAccount(account.Id, uow);

                    if (result)
                    {
                        if (model.Roles != null && model.Roles.Any())
                        {
                            var accountRoleList = model.Roles.Select(m => new AccountRoleEntity {
                                AccountId = account.Id, RoleId = m
                            }).ToList();
                            result = await _accountRoleRepository.AddAsync(accountRoleList, uow);
                        }

                        if (result)
                        {
                            uow.Commit();

                            await ClearPermissionListCache(account.Id);

                            await ClearCache(true, entity.Id);

                            return(ResultModel.Success());
                        }
                    }
                }
            }

            return(ResultModel.Failed());
        }
        private async Task <bool> IsTransactionPermitted(AccountUpdateModel accountUpdateModel)
        {
            var senderAccountByUserId = await _mediator.Send(
                new GetAccountByUserIdQuery(accountUpdateModel.UserId));

            var senderAccountBySenderId = await _mediator.Send(
                new GetAccountByIdQuery(accountUpdateModel.SenderAccountId));

            return(senderAccountByUserId.Id == senderAccountBySenderId.Id);
        }
示例#9
0
        public ActionResult UpdateAccount(int Id)
        {
            AccountService     service = new AccountService();
            AccountUpdateModel model   = new AccountUpdateModel();

            model          = service.GetAccountUpdateById(Id);
            model.ListRole = DefaultValues.ListRole();

            return(View(model));
        }
示例#10
0
        public async Task <ActionResult> UpdateAccount([FromBody] AccountUpdateModel account)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest());
                }
                if (string.IsNullOrWhiteSpace(account.title))
                {
                    throw new Exception("first name is required");
                }

                var cus = await _dBRepository.accounts.Where(l => l.id == account.id).FirstOrDefaultAsync();

                if (cus == null)
                {
                    throw new Exception("there is no account with this id that passed in.");
                }


                cus.title                   = account.title;
                cus.first_name              = account.first_name;
                cus.last_name               = account.last_name;
                cus.birth_date              = account.birth_date;
                cus.gender                  = account.Gender;
                cus.mobile                  = account.mobile;
                cus.tel                     = account.tel;
                cus.postal_code             = account.postal_code;
                cus.email                   = account.email;
                cus.telegram                = account.telegram;
                cus.instagram               = account.instagram;
                cus.address                 = account.address;
                cus.membership_join_type_id = account.membership_join_type_id;
                cus.jobinfo_id              = account.jobinfo_id;
                cus.contract_file_path      = account.contract_file_path;

                await _dBRepository.SaveChangesAsync();

                return(Ok(new CoreResponse()
                {
                    is_success = true, data = cus
                }));
            }
            catch (Exception ex)
            {
                return(Ok(new CoreResponse()
                {
                    is_success = false, data = null, dev_message = ex.Message
                }));
            }
        }
示例#11
0
    public IActionResult Update(int id, [FromBody] AccountUpdateModel model)
    {
        var account = _accounts.FirstOrDefault(account => account.Id == id);

        if (account == null)
        {
            return(NotFound());
        }

        account.Name = model.Name;

        return(Ok());
    }
 private void HandleMessage(AccountUpdateModel accountUpdateModel)
 {
     if (accountUpdateModel.Message == "ExecuteTransaction")
     {
         _accountUpdateService.UpdateAccountsAmount(accountUpdateModel);
     }
     else if (accountUpdateModel.Message == "DeleteAccount")
     {
         _accountUpdateService.DeleteAccount(accountUpdateModel);
     }
     else if (accountUpdateModel.Message == "CreateAccount")
     {
         _accountUpdateService.CreateAccount(accountUpdateModel);
     }
 }
        public async Task DeleteAccount(AccountUpdateModel accountUpdateModel)
        {
            try
            {
                var accountToDelete = await _mediator.Send(
                    new GetAccountByUserIdQuery(accountUpdateModel.UserId)
                    );

                await _mediator.Send(
                    new DeleteAccountCommand(accountToDelete.Id));
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
        }
 public async Task CreateAccount(AccountUpdateModel accountUpdateModel)
 {
     try
     {
         await _mediator.Send(new CreateAccountCommand
         {
             Amount = 3000,
             UserId = accountUpdateModel.UserId
         });
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
         throw;
     }
 }
示例#15
0
        public async Task<ActionResult> UpdateAccount(AccountUpdateModel accountUM)
        {
            try
            {
                if (accountUM.Roles.Contains(nameof(UserRoles.Admin)))
                {
                    return BadRequest("Can not update to role Admin!");
                }
                MyUser user = await _userManager.FindByNameAsync(accountUM.UserName);
                if (user != null)
                {
                    user = accountUM.Adapt(user); //Chuyen data tu View -> Model
                    var roles = await _userManager.GetRolesAsync(user);
                    if(roles.Contains(nameof(UserRoles.Doctor)))
                    {
                        accountUM.Roles.Add(nameof(UserRoles.Doctor));
                    }
                    if (roles.Contains(nameof(UserRoles.Nurse)))
                    {
                        accountUM.Roles.Add(nameof(UserRoles.Nurse));
                    }

                    await _userManager.RemoveFromRolesAsync(user, roles);
                    await _userManager.AddToRolesAsync(user, accountUM.Roles);
                    user.DateUpdated = DateTime.Now;
                    var currentAccount = await _userManager.UpdateAsync(user);
                    if (currentAccount.Succeeded)
                    {
                        return Ok();
                    }
                    else
                    {
                        return BadRequest(currentAccount.Errors);
                    }
                }
                else
                {
                    return NotFound();
                }

            }
            catch (Exception e)
            {
                return BadRequest(e.Message);
            }
        }
        public async Task <IActionResult> UpdateAccount(int accountId, [FromBody] AccountUpdateModel body)
        {
            var account = await _accountRepository.GetAsync(accountId);

            if (account == null)
            {
                return(NotFound($"Account {accountId} not found."));
            }

            account.Name  = body.Name;
            account.Email = body.Email;

            await _accountRepository.UpdateAsync(account);

            await _accountRepository.UnitOfWork.SaveEntitiesAsync();

            return(Ok());
        }
示例#17
0
        public ActionResult UpdateAccount(AccountUpdateModel model)
        {
            model.ListRole = DefaultValues.ListRole();
            if (!IsAdmin())
            {
                model.Message  = Configs.ALERT_NOT_ALLOW;
                model.Code     = (int)EnumError.ROLE_WRONG;
                model.Result   = false;
                model.Redirect = Url.Action("Index", "Word");
                return(Redirect("~"));
            }
            if (ModelState.IsValid)
            {
                AccountService service  = new AccountService();
                AccountModel   accModel = new AccountModel();
                model.Mapping(model, ref accModel);
                int result = service.UpdateAccount(accModel);
                if (result > 0)
                {
                    model.Result   = true;
                    model.Message  = Configs.SUCCESS_UPDATE;
                    model.Redirect = Url.Action("ListAccount", "User");
                    SetTempData(model.Message, model.Redirect);
                    return(View(model));
                }
                else
                {
                    model.Result  = false;
                    model.Message = GetErrorMessage(result);
                    SetTempData(model.Message);
                    return(View(model));
                }
            }
            else
            {
                var errors = ModelState.Select(x => x.Value.Errors)
                             .Where(y => y.Count > 0)
                             .ToList();
            }

            return(View(model));
        }
示例#18
0
        public virtual async Task <(AccountViewModel, ServiceModelState)> Update(
            string id, AccountUpdateModel model)
        {
            var edit = await context.Accounts
                       .WhereById(id)
                       .SingleOrDefaultAsync();

            if (edit == null)
            {
                return(null, null);
            }

            model.Attach(edit);

            await UpdateUsuallyUsed(edit);

            await context.SaveChangesAsync();

            return(AccountViewModel.Of(edit), null);
        }
 public bool UpdateAccount(AccountUpdateModel model)
 {
     using (var context = new HallAutomationSystemEntities())
     {
         AddressInformation addressInformation = new AddressInformation();
         int id      = addressInformation.GetStudentId(model.UserName);
         var account = context.Account.FirstOrDefault(x => x.StudentId == id);
         if (account != null)
         {
             if (account.Due > 0)
             {
                 int minus = Math.Min((int)account.Due, (int)model.Balance);
                 model.Balance -= minus;
                 account.Due   -= minus;
             }
             account.Balance += model.Balance;
         }
         context.SaveChanges();
         return(true);
     }
 }
示例#20
0
 public Task <IResultModel> Update(AccountUpdateModel model)
 {
     return(_service.Update(model));
 }
示例#21
0
        public async Task <IActionResult> UpdateAccountAsync([FromRoute] string accountId, [FromBody] AccountUpdateModel model)
        {
            var functions = GetCurrentAccountFunctionCodes();

            if (!functions.Contains("Account_Full"))
            {
                if (accountId != CurrentAccountId)
                {
                    throw new ForbiddenException();
                }
            }

            var account = await _accountRepository.GetAccountByIdAsync(accountId);

            if (account == null)
            {
                throw new NotFound404Exception("account");
            }

            if (model.Password != null)
            {
                if (model.Password.Length < 8 || model.Password.Length > 20)
                {
                    throw new PasswordIsInvalidException();
                }
            }

            if (model.Name != null)
            {
                if (model.Name.Length > 50)
                {
                    throw new NameIsInvalidException();
                }
            }

            if (model.BirthDate.HasValue)
            {
                if (model.BirthDate.Value.Year < Constants.MinBirthDate.Year || model.BirthDate.Value.Year > DateTime.Now.Year - Constants.MinAge)
                {
                    throw new BirthDateIsInvalidException();
                }
            }

            if (model.Email != null)
            {
                if (!model.Email.IsEmail())
                {
                    throw new EmailIsInvalidException();
                }

                if (model.Email != account.Email && await _accountRepository.AnyByEmailAsync(model.Email))
                {
                    throw new AlreadyExistsException("email");
                }
            }

            if (model.Phone != null)
            {
                if (!model.Phone.IsMobile())
                {
                    throw new PhoneIsInvalidException();
                }

                if (model.Phone != account.Phone && await _accountRepository.AnyByPhoneAsync(model.Phone))
                {
                    throw new AlreadyExistsException("phone");
                }
            }

            if (model.WardId.HasValue)
            {
                if (!await _wardRepository.AnyByIdAsync(model.WardId.Value))
                {
                    throw new NotFound400Exception("ward");
                }
            }

            // bind data
            account.WardId      = model.WardId.HasValue ? model.WardId.Value : account.WardId;
            account.Password    = model.Password != null ? model.Password : account.Password;
            account.Name        = model.Name != null ? model.Name : account.Name;
            account.Gender      = model.Gender.HasValue ? model.Gender.Value : account.Gender;
            account.BirthDate   = model.BirthDate.HasValue ? model.BirthDate : account.BirthDate;
            account.Address     = model.Address != null ? model.Address : account.Address;
            account.Email       = model.Email != null ? model.Email : account.Email;
            account.Phone       = model.Phone != null ? model.Phone : account.Phone;
            account.Avatar      = model.Avatar != null ? model.Avatar : account.Avatar;
            account.Description = model.Description != null ? model.Description : account.Description;
            account.UpdatedDate = DateTime.Now;

            await _accountRepository.UpdateAccountAsync(account);

            return(Ok(AccountDTO.GetFrom(account)));
        }
        public async Task <JsonResult> UpdateUser(AccountUpdateModel model)
        {
            var tenant = await this._dbContext.Tenants.FindAsync(model.TenantId);

            var user = this._dbContext.Users.Find(model.Id);

            this.saveToAvatar(model.Avatar, user.UserName);
            user.GivenName   = model.GivenName;
            user.Email       = model.Email;
            user.PhoneNumber = model.PhoneNumber;
            user.TenantId    = model.TenantId;
            user.TenantName  = tenant.Name;
            user.TenantDb    = tenant.ConnectionStrings;
            user.AvatarUrl   = $"{user.UserName}.png";


            await this._dbContext.SaveChangesAsync();

            var clamins = await this._userManager.GetClaimsAsync(user);

            var tenantclamin = clamins.Where(x => x.Type == "http://schemas.microsoft.com/identity/claims/tenantid").FirstOrDefault();

            if (tenantclamin != null)
            {
                await this._userManager.RemoveClaimAsync(user, tenantclamin);
            }
            var emailclamin = clamins.Where(x => x.Type == System.Security.Claims.ClaimTypes.Email).FirstOrDefault();

            if (emailclamin != null)
            {
                await this._userManager.RemoveClaimAsync(user, emailclamin);
            }
            var phoneclamin = clamins.Where(x => x.Type == System.Security.Claims.ClaimTypes.MobilePhone).FirstOrDefault();

            if (phoneclamin != null)
            {
                await this._userManager.RemoveClaimAsync(user, phoneclamin);
            }
            var nameclamin = clamins.Where(x => x.Type == System.Security.Claims.ClaimTypes.GivenName).FirstOrDefault();

            if (nameclamin != null)
            {
                await this._userManager.RemoveClaimAsync(user, nameclamin);
            }
            var avatarclamin = clamins.Where(x => x.Type == "http://schemas.microsoft.com/identity/claims/avatarurl").FirstOrDefault();

            if (avatarclamin != null)
            {
                await this._userManager.RemoveClaimAsync(user, avatarclamin);
            }

            await this._userManager.AddClaimAsync(user, new System.Security.Claims.Claim("http://schemas.microsoft.com/identity/claims/tenantid", user.TenantId.ToString()));

            await this._userManager.AddClaimAsync(user, new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.GivenName, user.GivenName ?? ""));

            await this._userManager.AddClaimAsync(user, new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.Email, user.Email));

            await this._userManager.AddClaimAsync(user, new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.MobilePhone, user.PhoneNumber ?? ""));

            await this._userManager.AddClaimAsync(user, new System.Security.Claims.Claim("http://schemas.microsoft.com/identity/claims/avatarurl", user.AvatarUrl ?? ""));

            return(Json(new { success = true }));
        }