public ActionResult Register(Models.User user)
{
if (ModelState.IsValid)
{
using (var db = new TodoAppDbContext())
{
User userFound = db.Users.SingleOrDefault(u => u.Username == user.Username);
if (userFound != null)
{
ViewBag.Error("User exist");
return(RedirectToAction("Index", "Home"));
}
db.Users.Add(new Models.User
{
Email = user.Email,
Username = user.Username,
Password = Crypto.HashPassword(user.Password)
});
db.SaveChanges();
SignIn(user);
}
}
else
{
ModelState.AddModelError("", "Data is incorrect");
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Manage(Client client)
{
if (string.IsNullOrEmpty(client.Client_ID))
{
client.Client_ID = Guid.NewGuid().ToString();
}
if (string.IsNullOrEmpty(client.Client_Secret))
{
client.Client_Secret = Guid.NewGuid().ToString();
}
using (var db = new TodoAppDbContext())
{
User user = db.Users.SingleOrDefault(u => u.Username == User.Identity.Name);
db.Clients.Add(new Client
{
Client_ID = client.Client_ID,
Client_Secret = Guid.NewGuid().ToString(),
Redirect_URI = client.Redirect_URI,
Created_On = DateTime.Now,
User = user
});
db.SaveChanges();
}
return(RedirectToAction("Manage", "Home"));
}
public ActionResult AddClient(Client client)
{
if (ModelState.IsValid)
{
using (var db = new TodoAppDbContext())
{
db.Clients.Add(new Client
{
ClientID = client.ClientID,
Client_Secret = client.Client_Secret,
Redirect_URI = client.Redirect_URI,
Created_On = DateTime.Now,
UserID = User.Identity.GetUserId <int>()
});
db.SaveChanges();
}
}
else
{
ModelState.AddModelError("", "Data is incorrect");
}
return(RedirectToAction("Manage", "Home"));
}
private static async Task ResetTable <TEntity>(List <TEntity> entities) where TEntity : BaseEntity
{
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.Development.json")
.Build();
var connectionString = configuration.GetConnectionString("MySqlConnectionTest");
var options = new DbContextOptionsBuilder <TodoAppDbContext>()
.UseMySql(connectionString).Options;
using (var context = new TodoAppDbContext(options))
{
await context.Database.MigrateAsync().ConfigureAwait(false);
var dbSet = context.Set <TEntity>();
var allEntities = await dbSet.ToListAsync().ConfigureAwait(false);
dbSet.RemoveRange(allEntities);
//await context.SaveChangesAsync().ConfigureAwait(false);
await dbSet.AddRangeAsync(entities).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
public void Delete()
{
using (var db = new TodoAppDbContext())
{
db.Database.ExecuteSqlCommand("TRUNCATE TABLE [Tasks]");
db.SaveChanges();
}
}
/// <summary>
/// Gets all tasks
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <TaskModel> > GetAll()
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
IEnumerable <TaskModel> entities = await context.Set <TaskModel>().ToListAsync();
return(entities);
}
}
public void Delete(int id)
{
using (var db = new TodoAppDbContext())
{
var task = db.Tasks.SingleOrDefault(t => t.TaskID == id);
db.Tasks.Remove(task);
db.SaveChanges();
}
}
public void Put(int id, Task newTask)
{
using (var db = new TodoAppDbContext())
{
var task = db.Tasks.SingleOrDefault(t => t.TaskID == id);
task.Name = newTask.Name;
db.SaveChanges();
}
}
/// <summary>
/// Gets entity
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <T> Get(int id)
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
T entity = context.Set <T>().FirstOrDefault((e) => e.Id == id);
return(entity);
}
}
/// <summary>
/// Gets all entities
/// </summary>
/// <returns></returns>
public Task <IEnumerable <T> > GetAll()
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
IEnumerable <T> entities = context.Set <T>().ToList();
return((Task <IEnumerable <T> >)entities);
}
}
/// <summary>
/// Gets all entities
/// </summary>
/// <returns></returns>
public List <T> GetAllItems()
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
List <T> entities = context.Set <T>().ToList();
return(entities);
}
}
public Models.Task Get(int id)
{
Models.Task task = null;
using (var db = new TodoAppDbContext())
{
task = db.Tasks.SingleOrDefault(t => t.TaskID == id);
}
return(task);
}
public ActionResult Manage()
{
List <Models.Client> clients = null;
using (var db = new TodoAppDbContext())
{
clients = db.Clients.Where(c => c.User.Username == User.Identity.Name).ToList();
}
return(View(clients));
}
/// <summary>
/// Creates an entity
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <T> Create(T entity)
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
var createdEntity = context.Set <T>().Add(entity);
context.SaveChanges();
return(createdEntity);
}
}
public IEnumerable <Models.Task> Get()
{
List <Models.Task> tasks = null;
using (var db = new TodoAppDbContext())
{
tasks = db.Tasks.ToList();
}
return(tasks);
}
/// <summary>
/// Deletes entity
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <bool> Delete(int id)
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
T entity = context.Set <T>().FirstOrDefault((e) => e.Id == id);
context.Set <T>().Remove(entity);
await context.SaveChangesAsync();
return(true);
}
}
public async static Task EnsureSeedData(this TodoAppDbContext dbContext)
{
if (dbContext.TodoItems.Any())
{
return;
}
await dbContext.AddRangeAsync(_todoItems);
await dbContext.SaveChangesAsync();
}
protected void OnClick(object sender, EventArgs e)
{
var name = this.TbCategoryName.Text;
var cat = new Category()
{
Name = name
};
var ds = new TodoAppDbContext();
ds.Categories.Add(cat);
ds.SaveChanges();
}
/// <summary>
/// Updates entity
/// </summary>
/// <param name="id"></param>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <T> Update(int id, T entity)
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
entity.Id = id;
context.Set <T>().Add(entity);
await context.SaveChangesAsync();
return(entity);
}
}
/// <summary>
/// Updates task
/// </summary>
/// <param name="id"></param>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <TaskModel> Update(int id, TaskModel entity)
{
using (TodoAppDbContext context = _contextFactory.CreateDbContext())
{
var editedEntity = context.Tasks.Where(e => e.Id == entity.Id).First();
context.Entry(editedEntity).CurrentValues.SetValues(entity);
await context.SaveChangesAsync();
return(entity);
}
}
public void Post(Task task)
{
using (var db = new TodoAppDbContext())
{
db.Tasks.Add(new Task
{
Name = task.Name,
Created_On = DateTime.Now,
User = db.Users.SingleOrDefault(u => u.Username == User.Identity.Name)
});
db.SaveChanges();
}
}
public ActionResult Login(Models.User user)
{
using (var db = new TodoAppDbContext())
{
User userToFind = db.Users.Where(u => u.Username == user.Username).FirstOrDefault();
if (userToFind != null)
{
if (Crypto.VerifyHashedPassword(userToFind.Password, user.Password))
{
SignIn(userToFind);
}
}
else
{
ViewBag.Error = "User not found!";
}
}
return(RedirectToAction("Index", "Home"));
}
public SubCategoryRepository(TodoAppDbContext context) : base(context)
{
_subCategories = context.SubCategories;
}
public GenericRepository(TodoAppDbContext todoAppDbContext)
{
_todoAppDbContext = todoAppDbContext;
}
public TodoRepository(TodoAppDbContext context, ILogger <TodoRepository> logger)
{
_context = context;
_logger = logger;
}
public SubCategoryRepository(TodoAppDbContext context)
{
_context = context;
}
public NoteRepository(TodoAppDbContext context) : base(context)
{
_notes = context.Notes;
}
public FileRepository(TodoAppDbContext context) : base(context)
{
_files = context.Files;
}
//private readonly TodoAppDbContext _context;
public CategoryRepository(TodoAppDbContext context) : base(context)
{
_categories = context.Categories;
}
public LinkRepository(TodoAppDbContext context) : base(context)
{
_links = context.Links;
}
