public ActionResult Register(User user)
{
var repo = new UserTaskRepository(Properties.Settings.Default.Constr);
repo.Register(user, user.PasswordHash);
return(RedirectToAction("index"));
}
public async Task AddAsyncTest()
{
try
{
Mapper.Initialize(m =>
{
var profiles = typeof(UserTaskProfile).Assembly.GetTypes().Where(x => typeof(Profile).IsAssignableFrom(x));
foreach (var profile in profiles)
{
m.AddProfile(Activator.CreateInstance(profile) as Profile);
}
});
var context = new DataContext();
var repository = new UserTaskRepository(context);
var manager = new UserTaskManager(repository, Mapper.Configuration.CreateMapper());
var obj = await manager.AddAsync(new UserTaskModel()
{
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow.AddDays(-1),
Title = "Test",
Description = "Test Description"
});
Assert.IsTrue(obj != null);
}
catch (Exception ex)
{
throw ex;
}
}
public void GetTasks()
{
var repo = new UserTaskRepository(_connectionString);
var result = repo.GetUserTasks();
Clients.All.SendAsync("refreshTasks", result);
}
public void Initialize()
{
UserTaskRepository repo = new UserTaskRepository();
mock_context = new Mock <UserTaskContext>();
mock_tasks = new Mock <DbSet <UserTask> >();
repo = new UserTaskRepository(mock_context.Object);
_listTasks = new List <UserTask>();
_listTasks = new List <UserTask>()
{
new UserTask()
{
Id = 1,
Name = "Write Financial Report",
Description = "End of Month Reporting",
Status = 0
},
new UserTask()
{
Id = 2,
Name = "Accounts Receivables",
Description = "Collect on overdue accounts",
Status = 0
}
};
ConnectToDatastore();
}
public void UpdateTask(UserTask task)
{
var repo = new UserTaskRepository(_connectionString);
var repo2 = new UserRepository(_connectionString);
var user = repo2.GetByEmail(User.Identity.Name);
task.UserName = $"{ user.FirstName} {user.LastName}";
repo.UpdateTask(task);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public List <UserTaskModel> GetUserTasks()
{
var items = UserTaskRepository.GetAll();
if (items != null)
{
return(items.Select(p => p.ToModel()).ToList());
}
return(new List <UserTaskModel>());
}
public async Task GetAllAsyncTest()
{
var context = new DataContext();
var mapper = new Mock <IMapper>();
var repository = new UserTaskRepository(context);
var manager = new UserTaskManager(repository, mapper.Object);
var obj = await manager.GetAsync(1);
Assert.IsTrue(obj != null);
}
public ActionResult Login(string email, string password)
{
var repo = new UserTaskRepository(Properties.Settings.Default.Constr);
var user = repo.Login(email, password);
if (user == null)
{
return(RedirectToAction("login"));
}
FormsAuthentication.SetAuthCookie(email, true);
return(Redirect("/home/Index"));
}
public ActionResult Index()
{
//var email = HttpContext.User.Identity.Name;
var repo = new UserTaskRepository(Properties.Settings.Default.Constr);
var user = repo.GetByEmail(HttpContext.User.Identity.Name);
var tasks = repo.GetTasks();
var hvm = new HomeVM {
Tasks = tasks, UserId = user.Id
};
return(View(hvm));
}
public async Task UpadteAsyncTest()
{
var context = new DataContext();
var mapper = new Mock <IMapper>();
var repository = new UserTaskRepository(context);
var manager = new UserTaskManager(repository, mapper.Object);
var obj = await manager.GetAsync(1);
obj.DateModified = DateTime.UtcNow;
var data = await manager.UpdateAsync(obj);
Assert.IsTrue(data != null);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public DatatablesView <UserTaskModel> GetUserTasksByPaging(DataTablesPaging request)
{
int total = 0;
var pagingItems = UserTaskRepository.GetItemsByPaging(request, out total);
var items = new List <UserTaskModel>();
foreach (var pagingItem in pagingItems)
{
var item = pagingItem.ToModel();
items.Add(item);
}
return(new DatatablesView <UserTaskModel>(request.Draw, total, pagingItems.Count, items));
}
public TestDataSeeder(IServiceScope scope)
{
citizenUserRepository = scope.ServiceProvider.GetService <CitizenUserRepository>();
roleRepository = scope.ServiceProvider.GetService <RoleRepository>();
friendshipRepository = scope.ServiceProvider.GetService <FriendshipRepository>();
userTaskRepository = scope.ServiceProvider.GetService <UserTaskRepository>();
messageRepository = scope.ServiceProvider.GetService <MessageRepository>();
if (citizenUserRepository == null || roleRepository == null || friendshipRepository == null ||
userTaskRepository == null || messageRepository == null)
{
throw new Exception("Cannot get services from ServiceProvider.");
}
}
public async Task DeleteByObjectAsyncTest()
{
var context = new DataContext();
var mapper = new Mock <IMapper>();
var repository = new UserTaskRepository(context);
var manager = new UserTaskManager(repository, mapper.Object);
var obj = await manager.GetAsync(1);
await manager.DeleteAsync(obj);
var result = await manager.GetAsync(1);
Assert.IsTrue(result == null);
}
public async Task SearchAsyncTest()
{
var context = new DataContext();
var mapper = new Mock <IMapper>();
var repository = new UserTaskRepository(context);
var manager = new UserTaskManager(repository, mapper.Object);
string id = "546542D6-59C3-4D8E-9C14-A550E0473885";
var filters = new List <FilterInfo>()
{
new FilterInfo()
{
Field = "Id", Op = FilterOperators.Equals, Value = new Guid(id)
}
};
var searchRequest = new SearchRequest()
{
Filters = filters, Page = 1, PageSize = 10, Sort = "Id"
};
var obj = await manager.SearchAsync(searchRequest);
Assert.IsTrue(obj != null);
}
public UserTaskService()
{
_userTaskRepository = new UserTaskRepository();
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public UserTaskModel GetUserTask(int id)
{
var item = UserTaskRepository.GetItem(id);
return(item.ToModel());
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Save(UserTaskModel model)
{
return(UserTaskRepository.Save(model.ToPO()));
}
public UserTasksController(UserTaskRepository userTaskRepository, IWebHostEnvironment webHostEnvironment, IMapper mapper)
{
this.userTaskRepository = userTaskRepository;
this.webHostEnvironment = webHostEnvironment;
this.mapper = mapper;
}
public void DeleteTask(DeleteUserTaskViewModel vm)
{
var repo = new UserTaskRepository(_connectionString);
repo.DeleteTask(vm.Id);
}
public UserTaskService(IUnitOfWork uow, UserTaskRepository repository, IMapper mapper)
{
Database = uow;
Repository = repository;
_mapper = mapper;
}
public void AddUserTask(UserTask task)
{
var repo = new UserTaskRepository(_connectionString);
repo.AddTask(task);
}
public UserTaskController(UserTaskRepository repository)
{
_repository = repository;
}
public TaskService(UserTaskRepository userTaskRepository)
{
this.userTaskRepository = userTaskRepository;
}
