// -------------------------------------------------------------------------------------
// Methods
// -------------------------------------------------------------------------------------
public FacadeResult CancelAccount(long id) {
#if DEBUG
using (MiniProfiler.Current.Step("AccountFacade.CancelAccount")) {
#endif
using (var context = new UnitOfWorkScope(TransactionMode.New)) {
var account = Account.GetById(id);
var validationResults = new AccountValidator()
.Validate(account);
if (validationResults.IsValid == true) {
account.IsActive = false;
User.GetAllByAccountId(id).ForEach(user => {
user.IsActive = false;
UserCacheManager.Put(user);
});
context.Commit();
AccountCacheManager.Put(account);
return new FacadeResult();
}
var error = validationResults.Errors
.First().ErrorMessage
.GetError();
return new FacadeResult(error);
#if DEBUG
}
#endif
}
}
public AccountsModule(
GetAll getAll,
GetById getById,
CreateCommand create,
UpdateCommand update,
ExcludeCommand exclude,
AccountValidator validator,
IMapper mapper)
: base("accounts")
{
_getAll = getAll;
_getById = getById;
_create = create;
_update = update;
_exclude = exclude;
_validator = validator;
_mapper = mapper;
this.RequiresAuthentication();
Get["/", true] = All;
Get["/{id}", true] = ById;
Post["/", true] = Create;
Put["/{id}", true] = Update;
Delete["/{id}", true] = Exclude;
}
public void SetUp()
{
_validator = new AccountValidator();
_modelStub = new Mock<Account>();
_modelStub.Setup(m => m.Name).Returns("Junior Oliveira");
_modelStub.Setup(m => m.Email).Returns("*****@*****.**");
_modelStub.Setup(m => m.Password).Returns("123456");
_modelStub.Setup(m => m.ConfirmPassword).Returns("123456");
}
public object Post(AccountModel request)
{
var session = this.GetSession();
ValidationResult validations = new AccountValidator().Validate(request);
if (!validations.IsValid)
{
request.ResponseResult.ResultStatus = ResultStatuses.Error;
foreach (var item in validations.Errors)
{
request.ResponseResult.Messages.Add(item.ErrorMessage);
}
return request;
}
string hash, salt;
new SaltedHash().GetHashAndSaltString(request.Password, out hash, out salt);
try
{
var roles = new List<string>();
if (request.IsMember)
{
roles.Add("Member");
}
else
{
roles.Add("Author");
}
var newUser = UserAuthRepository.CreateUserAuth(new UserAuth
{
DisplayName = request.UserName,
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
PrimaryEmail = request.Email,
UserName = request.UserName,
Salt = salt,
PasswordHash = hash,
FullName = "{0} {1}".Fmt(request.FirstName, request.LastName),
Roles = roles
}, request.Password);
}
catch (ArgumentException ex)
{
request.ResponseResult.ResultStatus = ResultStatuses.Error;
request.ResponseResult.Messages.Add(ex.Message);
return request;
}
request.ResponseResult.ResultStatus = ResultStatuses.Success;
return request;
}
public (bool isValid, IEnumerable <ValidationResult> errors) Validate()
{
var validator = new AccountValidator();
var result = validator.Validate(this);
if (result.IsValid)
{
return(true, null);
}
return(false, result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new [] { item.PropertyName })));
}
public void SetUp()
{
_existingCustomers = new List <Customer>()
{
new CustomerBuilder(_random).WithId().Build(),
new CustomerBuilder(_random).WithId().Build(),
new CustomerBuilder(_random).WithId().Build()
};
_customerRepositoryMock = new Mock <ICustomerRepository>();
_customerRepositoryMock.Setup(repo => repo.GetAllWithAccounts()).Returns(_existingCustomers);
_validator = new AccountValidator(_customerRepositoryMock.Object);
}
public AccountValidatorTests()
{
context = new TestingContext();
hasher = Substitute.For <IHasher>();
hasher.VerifyPassword(Arg.Any <String>(), Arg.Any <String>()).Returns(true);
validator = new AccountValidator(new UnitOfWork(new TestingContext(context)), hasher);
context.Add(account = ObjectsFactory.CreateAccount());
context.SaveChanges();
validator.CurrentAccountId = account.Id;
}
public AccountValidatorTests()
{
context = new TestingContext();
hasher = Substitute.For <IHasher>();
hasher.VerifyPassword(Arg.Any <String>(), Arg.Any <String>()).Returns(true);
context.DropData();
SetUpData();
validator = new AccountValidator(new UnitOfWork(context), hasher);
validator.CurrentAccountId = account.Id;
}
public void SetUp()
{
context = new TestingContext();
hasher = Substitute.For <IHasher>();
hasher.Verify(Arg.Any <String>(), Arg.Any <String>()).Returns(true);
validator = new AccountValidator(new UnitOfWork(context), hasher);
validator.ModelState = new ModelStateDictionary();
HttpContext.Current = new HttpMock().HttpContext;
TearDownData();
SetUpData();
}
public void GivenFasterPaymentsRequest_AndAccountWithChaps_WhenValidatingAccount_ThenResultSuccessIsFalse()
{
MakePaymentRequest request = new MakePaymentRequest {
PaymentScheme = PaymentScheme.FasterPayments
};
Account account = new Account()
{
AllowedPaymentSchemes = AllowedPaymentSchemes.Chaps
};
var result = AccountValidator.ValidateAccountCanSatisfyPaymentRequest(request, account);
Assert.False(result.Success);
}
public void GivenBacsRequest_AndAccountWithBACSPermissions_WhenValidatingAccount_ThenResultSuccessIsTrue()
{
MakePaymentRequest request = new MakePaymentRequest {
PaymentScheme = PaymentScheme.Bacs
};
Account account = new Account()
{
AllowedPaymentSchemes = AllowedPaymentSchemes.Bacs
};
var result = AccountValidator.ValidateAccountCanSatisfyPaymentRequest(request, account);
Assert.True(result.Success);
}
public void CustomerId_Is_One_Is_Valid()
{
// Arrange
var validator = new AccountValidator <Account>();
var account = new Account {
CustomerId = 1
};
// Act
var result = validator.Validate(account);
// Assert
Assert.False(result.Errors.Any(e => e.ErrorMessage == "CustomerId is required"));
}
private void CreateAccount()
{
var results = AccountValidator.Validate(ViewModel);
if (!results.IsValid)
{
Android.Support.V7.App.AlertDialog alertDialog = null;
Android.Support.V7.App.AlertDialog.Builder builder = new Android.Support.V7.App.AlertDialog.Builder(this)
.SetTitle("Invalid Model")
.SetMessage("- " + string.Join(" \n -", results.Errors.Select(x => x.ErrorMessage).ToList()))
.SetPositiveButton("Ok", (object s, Android.Content.DialogClickEventArgs dialogClickEventArgs) =>
{
alertDialog.Hide();
});
alertDialog = builder.Create();
alertDialog.Show();
}
else
{
try
{
var db = new SQLiteConnection(DBPath);
var insert = db.Insert(new Account()
{
Password = ViewModel.Password,
UserName = ViewModel.UserName,
FirstName = ViewModel.FirstName,
LastName = ViewModel.LastName,
PhoneNumber = ViewModel.PhoneNumber,
ServiceDate = ViewModel.ServiceStartDate.Value
});
if (insert == 1)
{
var intent = new Intent(this, typeof(ConfirmationActivity));
StartActivity(intent);
}
else
{
//TODO: Let the user know the database wasn't updated
}
}
catch (Exception ex)
{
//TODO: Let the user know something went wrong
}
}
}
/// <summary>
/// Insert a new Account
/// </summary>
public Account Insert(Account account)
{
// hash the given password
account.Password = GetPasswordHash(account.Password);
// validate the new account
var validator = new AccountValidator(m_accounts);
var validationresults = validator.Validate(account, ruleSet: "default,Insert");
if (!validationresults.IsValid)
throw new ValidationException(validationresults.Errors);
return m_accounts.Insert(account);
}
public void CustomerId_Is_Zero_Generates_Error()
{
// Arrange
var validator = new AccountValidator <Account>();
var account = new Account {
CustomerId = 0
};
// Act
var result = validator.Validate(account);
// Assert
Assert.True(result.Errors.Any(e => e.ErrorMessage == "CustomerId is required"));
}
public void GivenFasterPaymentsRequest_AndAccountWithFasterPermissions_AndBalanceLessThatnAmount_WhenValidatingAccount_ThenResultSuccessIsFalse()
{
MakePaymentRequest request = new MakePaymentRequest {
PaymentScheme = PaymentScheme.FasterPayments, Amount = 10
};
Account account = new Account()
{
AllowedPaymentSchemes = AllowedPaymentSchemes.FasterPayments, Balance = 9
};
var result = AccountValidator.ValidateAccountCanSatisfyPaymentRequest(request, account);
Assert.False(result.Success);
}
public OpResult UpdateAccount(string userName, AccountUpdateRequest dto)
{
var account = _repo.GetFirst <Account>(a => a.UserName == userName, null, "Profiles");
if (account == null)
{
return(OpResult.FailureResult("Account not found"));
}
var profile = account.GetProfile();
if (profile == null)
{
if (!(string.IsNullOrEmpty(dto.FirstName) && string.IsNullOrWhiteSpace(dto.LastName)))
{
profile = new Profile();
account.Profiles.Add(profile);
}
}
if (profile != null)
{
profile.FirstName = dto.FirstName;
profile.LastName = dto.LastName;
}
if (account.Email != dto.Email)
{
var anotherAccount = _repo.GetFirst <Account>(a => a.ID != dto.Id && a.Email == dto.Email, null, "Profiles");
if (anotherAccount != null)
{
return(OpResult.FailureResult("eMail already exists"));
}
account.Email = dto.Email;
}
AccountValidator validator = new AccountValidator();
var validationResult = validator.Validate(account);
if (!validationResult.IsValid)
{
return(OpResult.FailureResult(validationResult.Errors.Select(e => e.ErrorMessage).ToList()));
}
_repo.Update <Account>(account);
_repo.Save();
return(OpResult.SuccessResult());
}
public void GivenChapsRequest_AndAccountWithChapsPermissions_AndDISABLEDAccount_WhenValidatingAccount_ThenResultSuccessIsFalse()
{
MakePaymentRequest request = new MakePaymentRequest {
PaymentScheme = PaymentScheme.Chaps
};
Account account = new Account()
{
AllowedPaymentSchemes = AllowedPaymentSchemes.Chaps,
Status = AccountStatus.Disabled
};
var result = AccountValidator.ValidateAccountCanSatisfyPaymentRequest(request, account);
Assert.False(result.Success);
}
/// <summary>
///
/// </summary>
/// <param name="userid"></param>
/// <param name="info"></param>
/// <returns></returns>
public async Task <dynamic> ChangeIntroduction(long userid, DTOAPI_ChangeIntroduction info)
{
if (!AccountValidator.bValidIntroduction(info.introduction))
{
throw new Exception("简介不符合规则");
}
await this.publishEndpoint.Publish(new ChangeAccountIntroductionCommand
{
id = userid,
introduction = info.introduction
});
return("");
}
private bool IsValidAccountPassword()
{
BCryptHashGenerator bCryptHashGenerator = new BCryptHashGenerator();
string hashedPassword = bCryptHashGenerator.GenerateHashedString(accountCurrent.Password, accountReceived.Salt);
accountCurrent.Password = hashedPassword;
_password = hashedPassword;
AccountValidator accountValidator = new AccountValidator(accountReceived);
ValidationResult dataValidationResult = accountValidator.Validate(accountCurrent);
IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);
userFeedback.ShowFeedback();
return(dataValidationResult.IsValid);
}
/// <summary>
///
/// </summary>
/// <param name="userid"></param>
/// <param name="info"></param>
/// <returns></returns>
public async Task <dynamic> ChangeNickName(long userid, DTOAPI_ChangeNickName info)
{
if (!AccountValidator.bValidDisplayName(info.nickName))
{
throw new Exception("昵称不符合规则");
}
await this.publishEndpoint.Publish(new ChangeAccountNickNameCommand
{
id = userid,
nickName = info.nickName
});
return("");
}
public void TestFasterPaymentsAccountAndPaymentSchemeIsFasterPaymentsInsufficientFundsIsValid()
{
// Get Live Bacs Account
Account account = GetDummyAccount(AccountStatus.Live, AllowedPaymentSchemes.FasterPayments, Convert.ToDecimal(25.42));
// Get Bacs Request
MakePaymentRequest request = new MakePaymentRequest
{
Amount = Convert.ToDecimal(30.50),
PaymentScheme = PaymentScheme.FasterPayments
};
var result = AccountValidator.CheckAccountIsValid(account, request);
Assert.IsFalse(result);
}
public void TestBacsAccountAndPaymentSchemeIsNotBacsIsValid()
{
// Get Live Bacs Account
Account account = GetDummyAccount(AccountStatus.Live, AllowedPaymentSchemes.Bacs, Convert.ToDecimal(200.43));
// Get Bacs Request
MakePaymentRequest request = new MakePaymentRequest
{
Amount = Convert.ToDecimal(30.50),
PaymentScheme = PaymentScheme.Chaps
};
var result = AccountValidator.CheckAccountIsValid(account, request);
Assert.IsFalse(result);
}
public void TestNullAccountAndPaymentSchemeIsBacsIsValid()
{
// Get Null Account
Account account = null;
// Get Bacs Request
MakePaymentRequest request = new MakePaymentRequest
{
Amount = Convert.ToDecimal(30.50),
PaymentScheme = PaymentScheme.Bacs
};
var result = AccountValidator.CheckAccountIsValid(account, request);
Assert.IsFalse(result);
}
//private RepositoryPlaceholder _repo = new RepositoryPlaceholder();
public OpResult CreateAccount(AccountCreateRequest dto)
{
Account account = new Account
{
UserName = dto.Username,
Password = dto.Password,
Email = dto.Email,
EmailVerificationCode = Guid.NewGuid().ToString("N")
};
AccountValidator validator = new AccountValidator();
var validationResult = validator.Validate(account);
if (!validationResult.IsValid)
{
return(OpResult.FailureResult(validationResult.Errors.Select(e => e.ErrorMessage).ToList()));
}
var existingAccount = _repo.GetFirst <Account>(a => a.UserName == dto.Username || a.Email == dto.Email);
if (existingAccount != null)
{
if (existingAccount.UserName == dto.Username)
{
return(OpResult.FailureResult("username already exists"));
}
if (existingAccount.Email == dto.Email)
{
return(OpResult.FailureResult("eMail already exists"));
}
}
var salt = EncryptionUtil.GenerateRandomSaltString();
var hashedPass = EncryptionUtil.GeneratePBKDF2Hash(dto.Password, salt);
account.PasswordHash = hashedPass;
account.PasswordSalt = salt;
_repo.Create <Account>(account);
_repo.Save();
_emailService.SendEmail(_configService.GetFromEmailAddress(), _configService.GetFromEmailName(),
account.Email, "Verify Account", "Your verification code is " + account.EmailVerificationCode);
return(OpResult.SuccessResult());
}
public async Task Validate_OneAccount()
{
using (var provider = await CreateProvider())
{
var access = provider.GetRequiredService <IContextLock>();
var accounts = provider.GetRequiredService <IAccountRepository>();
IValidator <Account> validator = new AccountValidator(accounts);
var account = new Account();
using (await access.Read())
{
var target = new ValidationTarget <Account>(account);
validator.Validate(target);
Assert.False(target.GetResult().HasErrors);
}
}
}
public async Task <Guid> Handle(CreateAccountCommand command, CancellationToken cancellationToken)
{
var user = await _userRepository.Get(command.UserId);
var account = new Account(user);
var validator = new AccountValidator();
var result = await validator.ValidateAsync(account, default);
if (!result.IsValid)
{
throw new Exception("Model invalid.");
}
await _accountRepository.Insert(account);
return(account.Id);
}
/// <summary>
///
/// </summary>
/// <param name="registerInfo"></param>
/// <returns></returns>
public async Task <long> RegisterByEmailVerifyCode(DTOAPI_RegisterByEmailVerifyCode registerInfo)
{
if (!EmailHepler.IsValid(registerInfo.email))
{
throw new Exception("邮箱格式不正确");
}
if (!AccountValidator.bValidPassword(registerInfo.pwd))
{
throw new Exception("密码格式错误");
}
string key_captcha = $"RegisterCaptcha_{registerInfo.email.ToLower()}";
string captcha = this.captchaHelper.GetCaptcha(key_captcha);
if (String.IsNullOrEmpty(captcha) ||
!String.Equals(captcha, registerInfo.verifyCode, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("验证码错误");
}
var account = this.accesser.Get(email: registerInfo.email).Item1;
if (account != null)
{
throw new Exception("用户已存在");
}
var newId = this.IDGenerator.GetNewID <Account>();
await this.publishEndpoint.Publish(new RegisterAccountByEmailCommand
{
id = newId,
email = registerInfo.email.ToLower(),
password = registerInfo.pwd
});
await this.publishEndpoint.Publish(new DeleteAccountCaptchaCommand
{
key = key_captcha
});
return(newId);
}
protected override void OnStartup(StartupEventArgs e)
{
var context = new BankContext();
context.CreateOrUpdateDatabase();
var customerRepository = new CustomerRepository(context);
var cityRepository = new CityRepository(context);
var accountRepository = new AccountRepository(context);
var customerValidator = new CustomerValidator(cityRepository);
var accountValidator = new AccountValidator(customerRepository);
var dialogService = new WindowDialogService(accountRepository, accountValidator);
var customersWindow = new CustomersWindow(customerRepository, customerValidator, cityRepository, dialogService);
customersWindow.Show();
}
public ActionResult Signin(SigninViewModel model)
{
var validator = new AccountValidator();
validator.LogEventHandler += HandleLogEvents;
if (!validator.IsValidCredentials(model.Username, model.Password))
{
LogError($"Login validation failed for {nameof(model.Username)}: {model.Username} using {nameof(model.Password)}: {model.Password}.");
return(View(new SigninViewModel {
IsFailedAuthentication = true
}));
}
LogMessage($"Login validation succeded for {nameof(model.Username)}: {model.Username} using {nameof(model.Password)}: {model.Password}.");
CurrentLoginData = model;
TsUserName = model.Username;
LogMessage($"Redirecting to {Url.Action("SelectSite", "Account")}.");
return(RedirectToAction("SelectSite", "Account"));
}
static void Main(string[] args)
{
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
TripRepository tripRepository = new TripRepository();
TripValidator tripValidator = new TripValidator();
AccountRepository accountRepository = new AccountRepository();
AccountValidator accountValidator = new AccountValidator();
BookingRepository bookingRepository = new BookingRepository();
BookingValidator bookingValidator = new BookingValidator();
ITripServices tripServices = new TripServicesImpl(accountRepository, tripRepository, bookingRepository,
accountValidator, tripValidator, bookingValidator);
TripServicesGrpcImpl tripServicesGrpc = new TripServicesGrpcImpl(tripServices);
GrpcServer server = new GrpcServer(int.Parse(ConfigurationManager.AppSettings["port"]),
ConfigurationManager.AppSettings["host"], tripServicesGrpc);
server.Start();
}
static void Main(string[] args)
{
LOGGER.Info("loading application context");
try
{
AccountRepository accountRepository = new AccountRepository();
TripRepository tripRepository = new TripRepository();
BookingRepository bookingRepository = new BookingRepository();
BookingValidator bookingValidator = new BookingValidator();
AccountValidator accountValidator = new AccountValidator();
TripValidator tripValidator = new TripValidator();
ITripServices tripServices = new TripServicesImpl(accountRepository, tripRepository, bookingRepository, accountValidator, tripValidator, bookingValidator);
AbstractServer server = new RpcConcurrentServer(ConfigurationManager.AppSettings["host"],
Int32.Parse(ConfigurationManager.AppSettings["port"]), tripServices);
server.Start();
}
catch (Exception ex)
{
LOGGER.Warn(ex.StackTrace);
}
}
public Account Save(Account entity)
{
;
var errorList = new List <ValidationFailure>();
SetLogInfo(entity);
var errorEntity = AccountValidator.GetInstance().Validate(entity);
errorList.AddRange(errorEntity.Errors);
if (errorList.Count != 0)
{
throw new SpadException(string.Join(",", errorList.Select(s => s.ErrorMessage)));
}
var result = _repository.Save(entity);
return(entity);
}
public string ValidateCredentials([FromBody] UserInfoDTO data)
{
var DTO = new UserInfoDTO();
int status = AccountValidator.compareCredentials(data.email, data.password);
if (status == 1) //valid credentials
{
string token;
// check to see if user has a token already
if (SessionController.sm.ifUserExists(data.email))
{
token = SessionController.sm.getToken(data.email);
}
else
{
// generate token for user
SessionController.sm.updateToken(data.email);
token = SessionController.sm.getToken(data.email);
}
DTO.status = "200"; //Set the status
DTO = DTO.getUserInfo(data.email, token); //Get the user info for return
string output = JsonConvert.SerializeObject(DTO);
return(output);
}
else if (status == 0) //invalid credentials
{
DTO.status = "400";
string output = JsonConvert.SerializeObject(DTO);
return(output);
}
else //Null error
{
DTO.status = "404";
string output = JsonConvert.SerializeObject(DTO);
return(output);
}
}
public StatusCodeResult ChangePassword([FromBody] UserInfoDTO data)
{
string email = "";
// get users email from the token sent
email = SessionController.sm.getEmail(data.authToken);
// make sure user is authenticated
if (SessionController.sm.ifTokenValid(data.authToken))
{
AccountCreator c = new AccountCreator();
// check that passwords match and length is 8 or more
if (data.password.Equals(data.password2) && data.password.Length > 7)
{
// check that old password was correct
int status = AccountValidator.compareCredentials(email, data.currentPassword);
// if current password was valid, go through with password change
if (status == 1)
{
c.changePassword(data.password, email);
return(StatusCode(200));
}
else
{
return(StatusCode(400));
}
}
else
{
return(StatusCode(400));
}
}
else
{
return(StatusCode(401));
}
}
public override IEnumerable<BusinessRule> Validate()
{
AccountValidator validator = new AccountValidator();
ValidationResult results = validator.Validate(this);
foreach (var item in results.Errors)
{
yield return new BusinessRule(item.PropertyName, item.ErrorMessage);
}
}
