public IActionResult Add(ToDoListModel model)
{
model.NewItems.Add(model.NewItem);
model.NewItem = null;
return(ViewIndex(model, true));
}
private void buttonPickDate_Click(object sender, EventArgs e)
{
Action <DateTime> pickToDoListForDateAction = (pickedDate) =>
{
//Pick date and find 'ToDo List' for that date
var listByDate = _toDoListDao.GetOneByDate(pickedDate);
//If 'ToDo List' doesn't exist, create new one
if (listByDate == null)
{
var newList = _toDoListDao.Insert(ToDoList.New(pickedDate));
listByDate = newList;
_toDoListService.AddListToCache(listByDate);
}
// Create model for 'ToDoList' and display it
flowLayoutPanel1.Controls.Clear();
var listByDateModel = new ToDoListModel(listByDate);
_currentToDoList = listByDateModel;
var toDoListControl = new ToDoListControl(listByDateModel, _toDoListService, _toDoListDao, _toDoTaskDao);
flowLayoutPanel1.Controls.Add(toDoListControl);
};
var datePickerForm = new DatePickerForm(pickToDoListForDateAction);
datePickerForm.Show();
}
public RawResponseModel <ToDoListModel> Save(ToDoListModel model)
{
if (model != null)
{
}
else
{
model = new ToDoListModel();
}
var entity = new ToDo();
if (model.Id > 0)
{
entity.Id = model.Id;
}
if (!string.IsNullOrEmpty(model.TaskName))
{
entity.TaskName = model.TaskName;
}
entity.CreatedAt = DateTime.UtcNow;
if (model.Id == 0)
{
_repository.Create(entity);
}
else
{
_repository.Update(entity);
}
_repository.Save();
model.Id = entity.Id;
return(new RawResponseModel <ToDoListModel>(model));
}
public IActionResult Save(int id, [FromBody] ToDoListModel model)
{
model.Id = id;
var row = this.SaveRow(model);
return(this.Ok(row));
}
public MainForm(IToDoListService toDoListService,
IToDoListDao toDoListDao, IToDoTaskDao toDoTaskDao)
{
InitializeComponent();
_toDoListService = toDoListService;
_toDoListDao = toDoListDao;
_toDoTaskDao = toDoTaskDao;
Text = Constants.AppName;
Icon = Properties.Resources.List;
buttonPrevious.Image = Properties.Resources.Left.ResizeTo(Constants.Sizes.DefaultNavigationImageSize);
var rightArrowImage = Properties.Resources.Left.ResizeTo(Constants.Sizes.DefaultNavigationImageSize);
rightArrowImage.RotateFlip(RotateFlipType.Rotate180FlipY);
buttonNext.Image = rightArrowImage;
buttonPickDate.Text = Constants.Interface.Main.PickDate;
_toDoListModels = _toDoListService.PopulateToDoListCache()
.Select(tdl => new ToDoListModel(tdl)).ToList();
var currentList = _toDoListModels
.FirstOrDefault(tdlm => tdlm.Date.ToShortDateString() == DateTime.Now.ToShortDateString())
?? _toDoListModels.OrderByDescending(tdlm => tdlm.Date).FirstOrDefault();
_currentToDoList = currentList;
var toDoListControl = new ToDoListControl(currentList, _toDoListService, _toDoListDao, _toDoTaskDao);
flowLayoutPanel1.Controls.Add(toDoListControl);
}
public void UpdateToDoList(ToDoListModel toDoList)
{
Guard.WhenArgument(toDoList, "ToDoList").IsNull().Throw();
this.toDoListModelRepository.Update(toDoList);
unitOfWork.Commit();
}
public void Add(ToDoListModel model)
{
using (var db = new ToDoListDbContext())
{
db.ToDoTasks.Add(model);
db.SaveChanges();
}
}
private IActionResult ViewIndex(ToDoListModel model, bool clearModelstate)
{
if (clearModelstate)
{
ModelState.Clear();
}
return(View("Index", model));
}
public void Update(ToDoListModel model)
{
using (var db = new ToDoListDbContext())
{
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
}
}
public UpcomingTaskControl(ToDoListModel toDoListModel)
{
InitializeComponent();
_toDoListModel = toDoListModel;
labelTitleDate.Text = _toDoListModel.TitleDate;
labelTasks.Text = GenerateTaskList(_toDoListModel.ToDoTasks);
}
public ActionResult Index(int id)
{
_todoListResponse = _todoListService.All();
if (_todoListResponse.Success)
{
todoListModel = new ToDoListModel(_todoListResponse.ToDoLists.Where(x => x.ID == id).SingleOrDefault());
}
return(View(todoListModel));
}
// GET: ToDoList
public ActionResult Index()
{
ToDoListBLL todoListBLL = new ToDoListBLL();
List <ContentEntity> contentList = todoListBLL.GetListContentEntity();
ToDoListModel model = new ToDoListModel();
model.entityList = contentList;
return(View(model));
}
public IActionResult Index()
{
var model = new ToDoListModel();
model.NewItems = Program.ToDoLanes[0];
model.BusyItems = Program.ToDoLanes[1];
model.DoneItems = Program.ToDoLanes[2];
return(ViewIndex(model, true));
}
public IActionResult Get([FromQuery] ToDoListModel model = null)
{
if (model == null)
{
model = new ToDoListModel();
}
var results = _logic.Get(model);
return(this.Ok(results));
}
public ToDoListModel Create(ToDoListModel model, string login)
{
var user = _dbContext.Users.Include(x => x.ToDoLists).SingleOrDefault(x => x.Login == login);
var newToDo = _mapper.Map <DAL.Entities.ToDoList>(model);
newToDo.CreationDate = DateTime.Now;
user?.ToDoLists.Add(newToDo);
_dbContext.SaveChanges();
return(model);
}
public ListModel(ToDoListModel dbList)
{
this.Id = dbList.Id;
this.Name = dbList.Name;
this.Date = dbList.Date;
this.Category = dbList.Category;
this.IsPublic = dbList.IsPublic;
this.ApplicationUserId = dbList.ApplicationUserId.Id;
this.tasks = dbList.Tasks.Select(t => new TaskModel(t)).ToList();
}
public ToDoListViewModel(ToDoListModel dbLists)
{
this.Id = dbLists.Id;
this.Name = dbLists.Name;
this.Date = dbLists.Date;
this.Category = dbLists.Category;
this.IsPublic = dbLists.IsPublic;
this.ApplicationUserId = dbLists.ApplicationUserId.Id;
this.Tasks = dbLists.Tasks.Select(tasks => new TaskViewModel(tasks)).ToList();
}
public IActionResult UpdateToDoList(ToDoListModel toDoListModel)
{
var toDoList = _toDoListService.UpdateToDoList(toDoListModel);
if (toDoList)
{
return(Ok(new { message = "ToDoList updated" }));
}
return(BadRequest(new { message = "Couldnt update list" }));
}
private RawResponseModel <ToDoListModel> SaveRow(ToDoListModel model)
{
if (model == null)
{
return(new RawResponseModel <ToDoListModel>(null, "model can't be null!", false));
}
var results = _logic.Save(model);
return(results);
}
public IActionResult CreateToDoList(ToDoListModel toDoListModel, int userId)
{
var result = _toDoListService.CreateToDoList(toDoListModel, userId);
if (result)
{
return(Ok(new { message = "ToDoList created" }));
}
return(BadRequest(new { message = "Couldnt create list" }));
}
public IActionResult Remove([FromBody] ToDoListModel model = null)
{
if (model == null)
{
return(this.Ok(new DeleteResponseModel("Can't Delete items due to missing some information or invalid data", false)));
}
var results = _logic.Delete(model);
return(this.Ok(results));
}
private void SwitchListControls(bool forward)
{
var nextList = _toDoListService.PickNextToDoList(_currentToDoList, forward);
var nextListModel = new ToDoListModel(nextList);
_currentToDoList = nextListModel;
var toDoListControl = new ToDoListControl(nextListModel, _toDoListService, _toDoListDao, _toDoTaskDao);
flowLayoutPanel1.Controls.Clear();
flowLayoutPanel1.Controls.Add(toDoListControl);
}
public IActionResult GetById(int id, [FromQuery] ToDoListModel model = null)
{
model.Id = id;
if (model == null)
{
model = new ToDoListModel();
}
var results = _logic.GetById(model);
return(this.Ok(results));
}
public IActionResult Index(string ItemName)
{
var CurrentToDo = new ToDoListModel
{
TaskName = ItemName
};
_context.Add(CurrentToDo);
_context.SaveChanges();
return(View(_context.ToDo.ToList()));
}
public async Task <IActionResult> All()
{
var userId = await this.usersService.GetUserIdAsync(this.User);
var todos = await this.toDoService.GetAllToDosAsyncForUser <ToDosViewModel>(userId);
var todosView = new ToDoListModel()
{
AllToDos = todos
};
return(this.View(todosView));
}
public IEnumerable <ToDoListModel> Get(ToDoListModel model)
{
var predicate = PredicateBuilder.New <ToDo>(true);
var rows = _repository.Find(predicate);
var results = rows.Select(x => new ToDoListModel()
{
Id = x.Id,
TaskName = x.TaskName,
CreatedAt = x.CreatedAt
});
return(results);
}
public ToDoListControl(ToDoListModel toDoListModel, IToDoListService toDoListService, IToDoListDao toDoListDao, IToDoTaskDao toDoTaskDao)
{
InitializeComponent();
_toDoListService = toDoListService;
_toDoListModel = toDoListModel;
_toDoListDao = toDoListDao;
_toDoTaskDao = toDoTaskDao;
buttonNewTask.Image = Properties.Resources.TaskAdd.ResizeTo(Constants.Sizes.DefaultAddImageSize);
SetListControl(_toDoListModel);
}
public void Delete(ToDoListModel model)
{
using (var db = new ToDoListDbContext())
{
var entry = db.Entry(model);
if (entry.State == EntityState.Detached)
{
db.ToDoTasks.Attach(model);
}
db.ToDoTasks.Remove(model);
db.SaveChanges();
}
}
public IActionResult Save(ToDoListModel model)
{
if (ModelState.IsValid)
{
Program.ToDoLanes = new List <List <ToDoItem> >()
{
model.NewItems,
model.BusyItems,
model.DoneItems
};
}
return(ViewIndex(model, false));
}
public void Retrun_WhenGiveValidParameters()
{ //Arrange
var mockedToDoListTaskRepository = new Mock <IEFGenericRepository <ToDoListTask> >();
var mockedUserRepository = new Mock <IEFGenericRepository <ApplicationUser> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var userId = Guid.NewGuid();
var tasks = new List <ToDoListTask>()
{
new ToDoListTask()
{
Task = "task 1", ExpirationDate = DateTime.Now.Date
},
new ToDoListTask()
{
Task = "task 2", ExpirationDate = DateTime.Now.Date
},
new ToDoListTask()
{
Task = "task 3", ExpirationDate = DateTime.Now.Date
}
};
var list = new ToDoListModel()
{
Tasks = tasks
};
var lists = new List <ToDoListModel>();
lists.Add(list);
var user = new ApplicationUser()
{
Id = userId.ToString(),
ToDoLists = lists
};
mockedUserRepository.Setup(r => r.GetById(userId)).Returns(user);
var taskService = new ToDoListTaskService(mockedToDoListTaskRepository.Object, mockedUserRepository.Object, mockedUnitOfWork.Object);
//Act
var actualResult = taskService.GetAllByUserId(userId);
//Assert
Assert.AreEqual(tasks, actualResult);
}
