public async void Insert_ValidateOk()
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await repo.InsertAsync(entity);
await context.SaveChangesAsync();
Assert.Equal(1, context.Set <TEntity>().Count());
_baseRepository.AssertAllProperties(entity, context.Set <TEntity>().First());
}
}
public async void SelectById_ObtainOne()
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await context.Set <TEntity>().AddAsync(entity);
await context.SaveChangesAsync();
var entityById = await repo.SelectByIdAsync(entity.GetIds);
Assert.NotNull(entityById);
_baseRepository.AssertAllProperties(entity, context.Set <TEntity>().First());
}
}
/// <summary>
/// initializing Acl tables, remove after using
/// for using in Hillavas.BaseProject_MaterialPro.Data.Migrations.Configuration.cs
/// just add "AclSeed.Init(context);" to seed method
/// </summary>
/// <param name="db">project context</param>
public bool Init()
{
using (var bt = _db.Database.BeginTransaction())
{
var rep = AddAdminUserAndRole();
if (!rep.Success)
{
return(false);
}
#region UserInRole
var userInRole = new UserInRole()
{
UserId = rep.UserId,
RoleId = rep.RoleId
};
_db.Set <UserInRole>().Add(userInRole);
if (_db.SaveChanges() == 0)
{
bt.Rollback();
return(false);
}
#endregion
var actionsRep = AddActions();
if (!actionsRep.Success)
{
bt.Rollback();
return(false);
}
_db.Set <ActionInRole>().AddRange(actionsRep.actions.Select(x => new ActionInRole
{
RoleId = rep.RoleId,
ActionId = x.ActionId,
IsDefault = x.ActionName == "ProfileInfo" ? true : false
}));
if (_db.SaveChanges() == 0)
{
bt.Rollback();
return(false);
}
bt.Commit();
return(true);
}
}
public async void Update_ValidateOk()
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await context.Set <TEntity>().AddAsync(entity);
await context.SaveChangesAsync();
_baseRepository.ChangeNotIdProperties(ref entity);
repo.Update(entity);
await context.SaveChangesAsync();
_baseRepository.AssertAllProperties(entity, context.Set <TEntity>().First());
}
}
public IActionResult RemoveSong()
{
try
{
var playlistId = Int32.Parse(Request.Form["playlistId"]);
var songId = Int32.Parse(Request.Form["songId"]);
var song = _context.Set <SongPlaylist>().Where(x => x.PlaylistId == playlistId && x.SongId == songId).FirstOrDefault();
if (song != null)
{
_context.Set <SongPlaylist>().Remove(song);
_context.SaveChanges();
}
return(RedirectToAction("Edit", new { id = playlistId }));
}
catch
{
Index();
return(View("Index"));
}
}
public async void Delete_ValidateOk()
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await context.Set <TEntity>().AddAsync(entity);
await context.SaveChangesAsync();
repo.Delete(entity);
await context.SaveChangesAsync();
Assert.Empty(context.Systems);
}
}
public async void SelectByFilter_ValidateBasicPredicates(bool expressionFilterResult, int expectedCant)
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await context.Set <TEntity>().AddAsync(entity);
await context.SaveChangesAsync();
Expression <Func <TEntity, bool> > expressionFunctionFilter = (s) => expressionFilterResult;
var entities = repo.SelectByFilter(expressionFunctionFilter);
Assert.NotNull(entities);
Assert.Equal(expectedCant, entities.Count());
}
}
public async void Insert_Existent_Id_ThrowException()
{
using (var context = new AuthDbContext(CreateNewContextOptions()))
{
TRepository repo = _baseRepository.GetNewRepository(context);
TEntity entity = _baseRepository.GetNewValidEntity();
await context.Set <TEntity>().AddAsync(entity);
await context.SaveChangesAsync();
_baseRepository.ChangeNotIdProperties(ref entity);
Func <Task> insertFunction = async() =>
{
await repo.InsertAsync(entity);
await context.SaveChangesAsync();
};
await Assert.ThrowsAsync <ArgumentException>(insertFunction);
}
}
public InformalEducationService(IServiceProvider serviceProvider, AuthDbContext dbContext)
{
DbContext = dbContext;
this.DbSet = dbContext.Set <InformalEducation>();
this.IdentityService = serviceProvider.GetService <IIdentityService>();
}
public virtual async Task <IList <TEntity> > GetAllAsync()
{
return(await _dbContext.Set <TEntity>().AsNoTracking().ToListAsync());
}
public ValueTask <TEntity> SelectByIdAsync(params object[] keyValues)
{
return(Context.Set <TEntity>().FindAsync(keyValues));
}
public Repository(AuthDbContext context)
{
this._set = context.Set <T>();
this._context = context;
}
//This methos should be used to Create a new User
public bool CreateUser(User user)
{
authDbContext.Set <User>().Add(user);
authDbContext.SaveChanges();
return(true);
}
public FamilyDataService(IServiceProvider serviceProvider, AuthDbContext dbContext)
{
DbContext = dbContext;
this.DbSet = dbContext.Set <FamilyData>();
this.IdentityService = serviceProvider.GetService <IIdentityService>();
}
public GenericRepository()
{
dbContext = new AuthDbContext();
dbSet = dbContext.Set <T>();
}
public WorkingExperienceService(IServiceProvider serviceProvider, AuthDbContext dbContext)
{
DbContext = dbContext;
this.DbSet = dbContext.Set <WorkingExperience>();
this.IdentityService = serviceProvider.GetService <IIdentityService>();
}
public async Task <int> UpdateAsync(int id, Account model)
{
var data = await ReadByIdAsync(id);
data.Username = model.Username;
if (!string.IsNullOrEmpty(model.Password))
{
data.Password = SHA1Encrypt.Hash(model.Password);
}
data.IsLocked = model.IsLocked;
data.AccountProfile.Dob = model.AccountProfile.Dob;
data.AccountProfile.Email = model.AccountProfile.Email;
data.AccountProfile.Firstname = model.AccountProfile.Firstname;
data.AccountProfile.Gender = model.AccountProfile.Gender;
data.AccountProfile.Lastname = model.AccountProfile.Lastname;
var updatedRoles = model.AccountRoles.Where(x => data.AccountRoles.Any(y => y.RoleId == x.RoleId));
var addedRoles = model.AccountRoles.Where(x => !data.AccountRoles.Any(y => y.RoleId == x.RoleId));
var deletedRoles = data.AccountRoles.Where(x => !model.AccountRoles.Any(y => y.RoleId == x.RoleId));
var updatedstore = model.Stores.Where(x => data.Stores.Any(y => y.Id == x.Id));
var addedstore = model.Stores.Where(x => !data.Stores.Any(y => y.Id == x.Id));
var deletedstore = data.Stores.Where(x => !model.Stores.Any(y => y.Id == x.Id));
foreach (var item in updatedRoles)
{
var role = data.AccountRoles.SingleOrDefault(x => x.RoleId == item.RoleId);
EntityExtension.FlagForUpdate(role, IdentityService.Username, UserAgent);
}
foreach (var item in addedRoles)
{
item.AccountId = id;
item.Role = null;
EntityExtension.FlagForCreate(item, IdentityService.Username, UserAgent);
data.AccountRoles.Add(item);
}
foreach (var item in deletedRoles)
{
EntityExtension.FlagForDelete(item, IdentityService.Username, UserAgent, true);
}
foreach (var item in updatedstore)
{
var store = data.Stores.SingleOrDefault(x => x.Id == item.Id);
EntityExtension.FlagForUpdate(store, IdentityService.Username, UserAgent);
}
foreach (var item in addedstore)
{
item.AccountId = id;
item.Id = 0;
EntityExtension.FlagForCreate(item, IdentityService.Username, UserAgent);
DbContext.Set <Store>().Add(item);
}
foreach (var item in deletedstore)
{
EntityExtension.FlagForDelete(item, IdentityService.Username, UserAgent, true);
}
EntityExtension.FlagForUpdate(data, IdentityService.Username, UserAgent);
DbSet.Update(data);
return(await DbContext.SaveChangesAsync());
}
public AccountService(IServiceProvider serviceProvider, AuthDbContext dbContext)
{
DbContext = dbContext;
this.DbSet = dbContext.Set <Account>();
this.IdentityService = serviceProvider.GetService <IIdentityService>();
}
public async Task <IActionResult> Register(RegisterViewModel model, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
var vm = await BuildRegisterViewModelAsync(model);
return(View(vm));
}
var user = await _context.Set <AppUser>().FirstOrDefaultAsync(r => r.UserName == model.Username);
if (user != null)
{
ModelState.AddModelError("Username", "Un utilisateur avec cette adresse email existe déjà.");
var vm = await BuildRegisterViewModelAsync(model);
return(View(vm));
}
user = new AppUser()
{
UserName = model.Username,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, result.Errors.ToString());
var vm = await BuildRegisterViewModelAsync(model);
return(View(vm));
}
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Email, user.Email));
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.FamilyName, user.LastName));
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.GivenName, user.FirstName));
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Name, $"{user.FirstName} {user.LastName}"));
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Role, _configuration.GetValue <string>("Roles:Anonymous:value")));
await _userManager.AddToRoleAsync(user, _configuration.GetValue <string>("Roles:AppUser:value"));
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var url = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, token = token, returnUrl = model.ReturnUrl }, Url.ActionContext.HttpContext.Request.Scheme);
var msg = new SendEmailRequest();
msg.Destination = new Destination
{
ToAddresses = new List <string> {
$"{user.FirstName}<{user.Email}>"
}
};
msg.Source = $"{_configuration.GetValue<string>("mailer:sender:name")}<{_configuration.GetValue<string>("mailer:sender:email")}>";
msg.ReturnPath = _configuration.GetValue <string>("mailer:bounces");
msg.Message = new Message
{
Subject = new Content("Confirmation de votre adresse mail")
};
var content = await _templateEngine.CompileRenderAsync("ConfirmEmailEvent.cshtml", new { UserName = $"{user.FirstName} {user.LastName}", Url = url });
msg.Message.Body = new Body {
Html = new Content(content)
};
var response = await _mailer.SendEmailAsync(msg, cancellationToken);
return(await Login(new LoginInputModel
{
Username = model.Username,
Password = model.Password,
ReturnUrl = model.ReturnUrl
}, "login"));
}