protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.profile_view);
// hide keyboard when last editText lost focus
FieldsService.LostFocusFromField(Resource.Id.zip_code_editText);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.registration_view);
// hide keyboard when last editText lost focus
FieldsService.LostFocusFromField(Resource.Id.phoneNumber_editText);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.license_view);
// hide keyboard when last field lost focus
FieldsService.LostFocusFromField(Resource.Id.license_spinner_vehicle_class);
}
public IHttpActionResult ChangeUserData(UpdateUserDataRequest model)
{
GeneralResponse oResponse = new GeneralResponse();
FieldsService oFieldService = new FieldsService();
Dictionary <string, string> oErrors = oFieldService.ValidateModel(ModelState);
try
{
if (oErrors.Count != 0)
{
throw new ArgumentException("Error, campos invalidos");
}
var claims = ClaimsPrincipal.Current.Identities.First().Claims.ToList();
string UserId = claims?.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Sid, StringComparison.OrdinalIgnoreCase))?.Value;
UserManager oUserManager = new UserManager();
oUserManager.UpdateDataByUserId(UserId, model.PhoneNumber, model.Email);
User oUser = oUserManager.GetByUserId(UserId);
var oUserResponse = new
{
Cuil = oUser.Cuil,
Name = oUser.Name,
Surname = oUser.Surname,
Email = oUser.Email,
PhoneNumber = oUser.PhoneNumber,
};
oResponse.Success = 1;
oResponse.Message = "Exito - se han registrado los nuevos datos del usuario";
oResponse.Data = oUserResponse;
return(Content(HttpStatusCode.OK, oResponse));
} catch (ArgumentException ex)
{
oResponse.Success = 0;
oResponse.Message = ex.Message;
oResponse.Data = oErrors;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
catch (Exception ex)
{
oResponse.Success = 0;
oResponse.Message = "Error - no se ha podido registrar los nuevos datos del usuario";
oResponse.Data = ex.Message;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
}
public void FieldExistsByNameShouldReturnFalse()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "FieldExists_Fields_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var fieldsService = new FieldsService(dbContext, townsService);
fieldsService.CreateField("Field", "Address", true, "Burgas");
var fieldNameForTest = "Field1";
var fieldExists = fieldsService.FieldExistsByName(fieldNameForTest);
Assert.False(fieldExists);
}
public void CreateFieldShouldReturnCorrectCountOfFields()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreateField_Fields_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var fieldsService = new FieldsService(dbContext, townsService);
for (int i = 1; i <= 20; i++)
{
fieldsService.CreateField($"Field{i}", $"Address{i}", false, "Sofia");
}
var fieldsCount = dbContext.Fields.CountAsync().Result;
var expectedFieldsCount = 20;
Assert.AreEqual(expectedFieldsCount, fieldsCount);
}
public void AllFieldsShouldReturnCorrectFieldsCount()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AllFields_Fields_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var fieldsService = new FieldsService(dbContext, townsService);
for (int i = 1; i <= 10; i++)
{
fieldsService.CreateField($"Field{i}", $"Address{i}", false, "Sofia");
}
var fields = fieldsService.AllFields <FieldViewModel>().ToList();
var expectedFieldsCount = 10;
Assert.AreEqual(expectedFieldsCount, fields.Count);
}
public IHttpActionResult Post(CreditCardDepositRequest model)
{
GeneralResponse oResponse = new GeneralResponse();
DepositManager oDepositManager = new DepositManager();
AccountManager oAccountManager = new AccountManager();
FieldsService oFieldsService = new FieldsService();
try
{
Dictionary <string, string> oErrors = oFieldsService.ValidateModel(ModelState);
if (oErrors.Count != 0)
{
oResponse.Success = 0;
oResponse.Message = "Error, campos invalidos";
oResponse.Data = oErrors;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
var claims = ClaimsPrincipal.Current.Identities.First().Claims.ToList();
string UserId = claims?.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Sid, StringComparison.OrdinalIgnoreCase))?.Value;
List <Account> oAccounts = oAccountManager.GetUserAccountsByUserId(Convert.ToInt32(UserId));
if (!oAccounts.Where(m => m.AccountId == model.DebitAccountId).Select(c => c).Any())
{
throw new ArgumentException("La cuenta a la que desea depositar no pertenece al usuario logeado");
}
;
CreditCardDetector detector = new CreditCardDetector(model.CreditCardNumber);
if (!detector.IsValid())
{
throw new ArgumentException("Los datos de la tarjeta de credito no son valdios");
}
oDepositManager.DepositWithCreditCard(model.Amount, model.DebitAccountId, model.FullName, model.CreditCardNumber.Substring(model.CreditCardNumber.Length - 4), model.DocumentNumber, model.ExpirationDate);
oAccountManager.UpdateAccountBalance(model.DebitAccountId, model.Amount);
oResponse.Success = 1;
oResponse.Message = "Exito - se ha realizado el deposito correctamente";
return(Content(HttpStatusCode.OK, oResponse));
}
catch (ArgumentException ex)
{
oResponse.Success = 0;
oResponse.Message = "Error - no se ha podido realizar el deposito";
oResponse.Data = ex.Message;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
catch (Exception ex)
{
oResponse.Success = 0;
oResponse.Message = "Error - no se ha podido realizar el deposito";
oResponse.Data = ex.Message;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
}
public void RefereeAttendToMatchShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AttendToMatch_Referees_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Burgas");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Referee",
UserName = $"footeoReferee",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var userHT = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(userHT);
dbContext.SaveChanges();
var userAT = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer2",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(userAT);
dbContext.SaveChanges();
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.RemoveFromRoleAsync(userHT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.RemoveFromRoleAsync(userAT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var fieldsService = new FieldsService(dbContext, townsService);
var leaguesService = new LeaguesService(dbContext, townsService);
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
var teamLeaguesService = new TeamLeaguesService(dbContext, teamsService, leaguesService);
var fixturesService = new FixturesService(dbContext, leaguesService);
var matchesService = new MatchesService(dbContext, fixturesService, teamsService);
var refereesService = new RefereesService(dbContext, matchesService, teamLeaguesService);
var referee = new Referee
{
FullName = $"Footeo Referee"
};
refereesService.CreateReferee(user, referee);
townsService.CreateTown("Sofia");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow, DateTime.UtcNow.AddMonths(3), "Sofia");
teamsService.CreateTeam("Home Team", "HT", userHT.UserName);
teamsService.CreateTeam("Away Team", "AT", userAT.UserName);
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League");
teamLeaguesService.JoinLeague(userHT.UserName, league.Id);
teamLeaguesService.JoinLeague(userAT.UserName, league.Id);
fixturesService.CreateFixture("Matchday", DateTime.UtcNow.AddDays(7), league.Id);
var fixture = dbContext.Fixtures.FirstOrDefault(n => n.Name == "Matchday");
fieldsService.CreateField("Field", "Address", true, "Sofia");
var field = dbContext.Fields.FirstOrDefault(n => n.Name == "Field");
matchesService.CreateMatch(userHT.Player.Team.Id, userAT.Player.Team.Id, field.Id, fixture.Id);
var match = dbContext.Matches.FirstOrDefault();
refereesService.AttendAMatch(user.UserName, match.Id);
Assert.NotNull(match.Referee);
}
public IHttpActionResult Post([FromBody] TransferRequest model)
{
GeneralResponse oResponse = new GeneralResponse();
AccountManager oAccountManager = new AccountManager();
TransferManager oTransferManager = new TransferManager();
FieldsService oFieldsService = new FieldsService();
var claims = ClaimsPrincipal.Current.Identities.First().Claims.ToList();
string UserId = claims?.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Sid, StringComparison.OrdinalIgnoreCase))?.Value;
try
{
Dictionary <string, string> oErrors = oFieldsService.ValidateModel(ModelState);
if (oErrors.Count != 0)
{
oResponse.Success = 0;
oResponse.Message = "Error, campos invalidos";
oResponse.Data = oErrors;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
Account oDebitAccount = new Account();
oDebitAccount = oAccountManager.GetAccountById(model.DebitAccountId);
if (oDebitAccount.AccountId == null)
{
throw new ArgumentException("Cuenta de debito no existente");
}
;
if (Convert.ToString(oDebitAccount.User.UserId) != UserId)
{
throw new ArgumentException("No se puede transferir dinero desde una cuenta que no pertenece al usuario logeado");
}
;
if (oDebitAccount.Balance < model.Amount)
{
throw new ArgumentException("No tiene el saldo suficiente para realizar esta transferencia");
}
;
Account oCreditAccount = new Account();
oCreditAccount = oAccountManager.GetAccountById(model.CreditAccountId);
if (oCreditAccount.AccountId == null)
{
throw new ArgumentException("Cuenta de credito no existente");
}
;
oTransferManager.MakeTransfer(oDebitAccount, model.CreditAccountId, model.Amount, model.Concept);
oAccountManager.UpdateAccountBalance((int)oDebitAccount.AccountId, -model.Amount);
oAccountManager.UpdateAccountBalance(model.CreditAccountId, model.Amount);
oResponse.Success = 1;
oResponse.Message = "Exito - Transferencia realizada";
return(Content(HttpStatusCode.OK, oResponse));
} catch (ArgumentException ex)
{
oResponse.Success = 0;
oResponse.Message = "Error - " + ex.Message;
return(Content(HttpStatusCode.BadRequest, oResponse));
} catch (Exception ex)
{
oResponse.Success = 0;
oResponse.Message = ex.Message;
return(Content(HttpStatusCode.BadRequest, oResponse));
}
}
