public async Task InsertUsersSampleData()
{
const int userCount = 5;
var roleNames = RoleConstants.GetRoleNames();
if (await _databaseContext.Users.AnyAsync())
{
return;
}
foreach (var roleName in roleNames)
{
for (var i = 0; i < userCount; i++)
{
var username = string.Format(roleName + "{0}", i);
var user = User.Create(username, username, username, username + "@gmail.com", username);
var result = await _userManager.CreateAsync(user, user.PasswordHash);
if (!result.Succeeded)
{
throw new Exception(string.Format("Failed creating user with username {0} ", username));
}
await _userManager.AddToRoleAsync(user, roleName);
}
}
await _databaseContext.SaveChangesAsync();
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
BirthDate = model.BirthDate.ToString("yyyy/MM/dd")
};
var result = await UserManager.CreateAsync(user, RoleConstants.Password(model.RoleName));
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, model.RoleName);
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
model.Roles = new RolesRepository().Roles().ToList();
return(View(model));
}
public async Task <IHttpActionResult> Register([FromBody] RegisterExternalBindingModel id)
{
if (ModelState.IsValid)
{
var user = new User
{
UserName = id.UserName,
FirstName = id.FirstName,
LastName = id.LastName,
Email = id.Email,
BirthDate = id.BirthDate.ToString("yyyy/MM/dd")
};
var result = await UserManager.CreateAsync(user, RoleConstants.Password(id.RoleName));
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, id.RoleName);
return(Ok());
}
return(GetErrorResult(result));
}
return(InternalServerError());
}
public async Task <IActionResult> GetPaymentMethodsAsync(int sellerId)
{
MUser user = await usersRepository.GetUserPrivateAsync(sellerId);
if (!RoleConstants.IsSeller(user.Role))
{
return(BadRequest());
}
return(Ok(user.GetSellerPaymentProviders(configuration.GetValue <bool>("IsMockEnabled"))));
}
public async Task <IActionResult> GetUserSellerAsync(int userId)
{
Seller seller = await usersRepository.GetUserAsync <Seller>(userId);
if (!RoleConstants.IsSeller(seller.Role))
{
return(BadRequest());
}
return(Ok(seller));
}
public async Task InsertRolesData()
{
var roleNames = RoleConstants.GetRoleNames();
foreach (var roleName in roleNames)
{
if (!await _roleManager.RoleExistsAsync(roleName))
{
await _roleManager.CreateAsync(Role.Create(roleName));
}
}
await _databaseContext.SaveChangesAsync();
}
/// <summary>
/// Retourne la durée effective de l'altération d'état en prenant en compte les différents
/// bonus des altérations.
/// </summary>
public float GetDuration(EntityBase source)
{
float duration = BaseDuration;
// Application des bonus de rôles.
if (source is EntityHero)
{
RoleConstants constants = GameServer.GetScene().Constants.Roles;
EntityHero hero = (EntityHero)source;
switch (hero.Role)
{
case EntityHeroRole.Fighter:
if (Type.HasFlag(StateAlterationType.Stealth))
{
duration *= constants.FighterStealthDurationMultiplier;
}
break;
case EntityHeroRole.Mage:
if (Type.HasFlag(StateAlterationType.Silence))
{
duration *= constants.MageSilenceDurationMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Root))
{
duration *= constants.MageRootDurationMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Sight) | Type.HasFlag(StateAlterationType.TrueSight))
{
duration *= constants.MageSightDurationMultiplier;
}
break;
case EntityHeroRole.Tank:
if (Type.HasFlag(StateAlterationType.Stun))
{
duration *= constants.TankStunDurationMultiplier;
}
break;
}
}
return(duration);
}
/// <summary>
/// Allows the user to change their password or reset someone else's password
/// </summary>
/// <param name="userId">User ID which password is to be changed</param>
/// <param name="newPassword">New password, or if empty, default password</param>
/// <returns></returns>
public async Task ChangePassword(string userId, string newPassword = "")
{
User user = UserById(userId);
if (user != null)
{
UserStore <User> store = new UserStore <User>(db);
UserManager <User> userManager = new UserManager <User>(store);
if (newPassword.Length == 0)
{
newPassword = RoleConstants.Password(userManager.GetRoles(userId).First());
}
string hashedNewPassword = userManager.PasswordHasher.HashPassword(newPassword);
await store.SetPasswordHashAsync(user, hashedNewPassword);
await store.UpdateAsync(user);
}
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
return(InternalServerError());
}
var user = new User {
UserName = id.UserName, Email = id.Email, FirstName = id.FirstName, LastName = id.LastName, BirthDate = id.BirthDate.ToString("yyyy/MM/dd")
};
IdentityResult result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await UserManager.CreateAsync(user, RoleConstants.Password(id.RoleName));
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, id.RoleName);
}
return(Ok());
}
/// <summary>
/// Calcule la valeur totale de l'altération d'état en fonction des différents scalings passés en
/// paramètres au moyen de "ratios".
///
/// Cette fonction garantit que les ratios ne seront calculés que pour les scalings demandés.
///
/// Par exemple, si scaling ratios ne contient pas SrcAd, source.GetAttackDamage() ne sera pas appelé.
/// </summary>
public float GetValue(EntityBase source, EntityBase destination, ScalingRatios ratios)
{
float totalValue = FlatValue;
if ((ratios & ScalingRatios.SrcAd) == ScalingRatios.SrcAd && SourcePercentADValue != 0)
{
totalValue += SourcePercentADValue * source.GetAttackDamage();
}
if ((ratios & ScalingRatios.SrcArmor) == ScalingRatios.SrcArmor && SourcePercentArmorValue != 0)
{
totalValue += SourcePercentArmorValue * source.GetArmor();
}
if ((ratios & ScalingRatios.SrcHP) == ScalingRatios.SrcHP && SourcePercentHPValue != 0)
{
totalValue += SourcePercentHPValue * source.GetHP();
}
if ((ratios & ScalingRatios.SrcMaxHP) == ScalingRatios.SrcMaxHP && SourcePercentMaxHPValue != 0)
{
totalValue += SourcePercentMaxHPValue * source.GetMaxHP();
}
if ((ratios & ScalingRatios.SrcAP) == ScalingRatios.SrcAP && SourcePercentAPValue != 0)
{
totalValue += SourcePercentAPValue * source.GetAbilityPower();
}
if ((ratios & ScalingRatios.SrcMR) == ScalingRatios.SrcMR && SourcePercentRMValue != 0)
{
totalValue += SourcePercentRMValue * source.GetMagicResist();
}
/*
* if ((ratios & ScalingRatios.DstAd) == ScalingRatios.DstAd)
* totalValue += DestPercentADValue * destination.GetAttackDamage();
* if ((ratios & ScalingRatios.DstArmor) == ScalingRatios.DstArmor)
* totalValue += DestPercentArmorValue * destination.GetArmor();
* if ((ratios & ScalingRatios.DstHP) == ScalingRatios.DstHP)
* totalValue += DestPercentHPValue * destination.GetHP();
* if ((ratios & ScalingRatios.DstMaxHP) == ScalingRatios.DstMaxHP)
* totalValue += DestPercentMaxHPValue * destination.GetMaxHP();
* if ((ratios & ScalingRatios.DstAP) == ScalingRatios.DstAP)
* totalValue += DestPercentAPValue * destination.GetAbilityPower();
* if ((ratios & ScalingRatios.SrcMR) == ScalingRatios.SrcMR)
* totalValue += DestPercentRMValue * destination.GetMagicResist();*/
// Application des bonus.
if (destination.Type.HasFlag(EntityType.Structure))
{
totalValue *= StructureBonus;
}
if (destination.Type.HasFlag(EntityType.Monster))
{
totalValue *= MonsterBonus;
}
if (destination.Type.HasFlag(EntityType.Virus))
{
totalValue *= VirusBonus;
}
// Application des bonus de rôles.
if (source is EntityHero)
{
RoleConstants constants = GameServer.GetScene().Constants.Roles;
EntityHero hero = (EntityHero)source;
switch (hero.Role)
{
case EntityHeroRole.Fighter:
if (Type.HasFlag(StateAlterationType.AttackSpeed))
{
totalValue *= constants.FighterAttackSpeedMultiplier;
}
else if (Type.HasFlag(StateAlterationType.AttackDamage))
{
totalValue *= constants.FighterAttackDamageMultiplier;
}
else if (Type.HasFlag(StateAlterationType.MagicDamageBuff))
{
totalValue *= constants.FighterMagicDamageMultiplier;
}
else if (Type.HasFlag(StateAlterationType.TrueDamage))
{
totalValue *= constants.FighterTrueDamageMultiplier;
}
break;
case EntityHeroRole.Mage:
if (Type.HasFlag(StateAlterationType.Heal))
{
totalValue *= constants.MageHealValueMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Shield))
{
totalValue *= constants.MageShieldValueMultiplier;
}
break;
case EntityHeroRole.Tank:
if (Type.HasFlag(StateAlterationType.MoveSpeed))
{
totalValue *= constants.TankMoveSpeedBonusMultiplier;
}
else if (Type.HasFlag(StateAlterationType.ArmorBuff))
{
totalValue *= constants.TankArmorBonusMultiplier;
}
else if (Type.HasFlag(StateAlterationType.MagicResistBuff))
{
totalValue *= constants.TankRMBonusMultiplier;
}
break;
}
// Application du bonus des passifs uniques
switch (hero.UniquePassive)
{
case EntityUniquePassives.Altruistic:
// Soins augmentés
if (Type.HasFlag(StateAlterationType.Heal))
{
totalValue *= 1 + GameServer.GetScene().Constants.UniquePassives.AltruistHealBonus;
}
break;
}
}
return(totalValue);
// Note : ceci n'est pas équivalent au code ci dessous.
// Dans cette version les fonctions source.GetAttackDamage(), etc... sont toujours appelées.
/*
* return FlatValue +
* SourcePercentADValue * source.GetAttackDamage() * (int)(ratios & ScalingRatios.SrcAd) +
* SourcePercentArmorValue * source.GetArmor() * (int)(ratios & ScalingRatios.SrcArmor)+
* SourcePercentHPValue * source.HP * (int)(ratios & ScalingRatios.SrcHP) +
* SourcePercentMaxHPValue * source.MaxHP * (int)(ratios & ScalingRatios.SrcMaxHP) +
*
* DestPercentADValue * destination.GetAttackDamage() * (int)(ratios & ScalingRatios.DstAd) +
* DestPercentArmorValue * destination.GetArmor() * (int)(ratios & ScalingRatios.DstArmor) +
* DestPercentHPValue * destination.HP * (int)(ratios & ScalingRatios.DstHP) +
* DestPercentMaxHPValue * destination.MaxHP * (int)(ratios & ScalingRatios.DstMaxHP);*/
}
