public async Task <IActionResult> Create(TodoItemViewModel todoItem, List <int> tagId)
{
if (ModelState.IsValid)
{
try
{
int todoItemId = await _todoItemdataService.Create(_mapper.Map <TodoItemVO>(todoItem));
await _itemTagService.Create(todoItemId, tagId);
return(RedirectToAction(nameof(Index)));
}
catch (ArgumentException ex)
{
ViewData["Categories"] = _mapper.Map <IEnumerable <CategoryViewModel> >(await _categorydataService.GetAll());
ViewData["Tags"] = _mapper.Map <IEnumerable <TagViewModel> >(await _tagdataService.GetAll());
ModelState.AddModelError("Name", ex.Message);
return(View(todoItem));
}
}
else
{
ViewData["Categories"] = _mapper.Map <IEnumerable <CategoryViewModel> >(await _categorydataService.GetAll());
ViewData["Tags"] = _mapper.Map <IEnumerable <TagViewModel> >(await _tagdataService.GetAll());
return(View(todoItem));
}
}
public int UpdateTodoItem(TodoItemViewModel item)
{
try
{
var itemEntity = new TodoItem
{
Id = item.Id,
Title = item.Title,
Description = item.Description,
Lat = item.Latitude,
Long = item.Longitude
//Location = new Point(item.Latitude, item.Latitude) { SRID = 4326 }
};
// add validation
_context.Entry(itemEntity).State = EntityState.Modified;
_context.SaveChanges();
return(1);
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> AddItem(TodoItemViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var currentUser = await _userManager.GetUserAsync(User);
if (currentUser == null)
{
return(Challenge());
}
var newItem = new TodoItem()
{
Id = model.Id,
Title = model.Title,
DueAt = model.DueAt,
Category = await _categoryService.GetByIdAsync(model.CategoryId)
};
var successful = await _todoItemService.AddItemAsync(newItem, currentUser);
if (!successful)
{
return(BadRequest("Could not add item."));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
ApplicationUser user = await _userManager.GetUserAsync(User);
TodoItem todoItem = await _context.TodoItem
.Include(a => a.ApplicationUser)
.SingleOrDefaultAsync(m => m.ToDoItemId == id && m.ApplicationUser == user);
if (todoItem == null)
{
return(NotFound());
}
TodoItemViewModel todoItemViewModel = new TodoItemViewModel
{
ToDoItemId = todoItem.ToDoItemId,
Title = todoItem.Title,
Description = todoItem.Description,
IsComplete = todoItem.IsComplete
};
return(View(todoItemViewModel));
}
public static void Delete(string id)
{
DeleteProfilePictureAsync(id);
DatabaseService.GetInstance().Delete(id);
TodoItemViewModel.GetInstance().RemoveTodoItem();
App.UpdateFileAndTile();
}
private void GridView_ItemClick_1(object sender, ItemClickEventArgs e)
{
var item = e.ClickedItem as TodoItem;
var vm = new TodoItemViewModel(item.Project, item);
this.Frame.Navigate(typeof(TodoItemView), vm);
}
public async Task Update(TodoItemViewModel model)
{
var todo = await UnitOfWork.TodoRepository.GetById(model.Id);
UnitOfWork.TodoRepository.Update(Mapper.Map(model, todo));
UnitOfWork.SaveChanges();
}
public IHttpActionResult DeleteTodoItem(int id)
{
TodoItem todoItem = db.TodoItems.Find(id);
if (todoItem == null)
{
return(StatusCode(HttpStatusCode.NotFound));
}
if (!String.Equals(db.Entry(todoItem.TodoList).Entity.UserId, User.Identity.GetUserId(), StringComparison.OrdinalIgnoreCase))
{
// Trying to delete a record that does not belong to the user
return(StatusCode(HttpStatusCode.Unauthorized));
}
TodoItemViewModel todoItemDto = new TodoItemViewModel(todoItem);
db.TodoItems.Remove(todoItem);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(HttpStatusCode.InternalServerError));
}
return(Content(HttpStatusCode.OK, todoItemDto));
}
public IHttpActionResult PostTodoItem(TodoItemViewModel todoItemDto)
{
if (!ModelState.IsValid)
{
return(Message(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)));
}
TodoList todoList = db.TodoLists.Find(todoItemDto.TodoListId);
if (todoList == null)
{
return(StatusCode(HttpStatusCode.NotFound));
}
if (!String.Equals(todoList.UserId, User.Identity.GetUserId(), StringComparison.OrdinalIgnoreCase))
{
// Trying to add a record that does not belong to the user
return(StatusCode(HttpStatusCode.Unauthorized));
}
TodoItem todoItem = todoItemDto.ToEntity();
// Need to detach to avoid loop reference exception during JSON serialization
db.Entry(todoList).State = EntityState.Detached;
db.TodoItems.Add(todoItem);
db.SaveChanges();
todoItemDto.TodoItemId = todoItem.TodoItemId;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, todoItemDto);
response.Headers.Location = new Uri(Url.Link("TodoItem", new { id = todoItemDto.TodoItemId }));
return(Message(response));
}
public async Task <IActionResult> IndexById(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction(actionName: nameof(Index), controllerName: "Home"));
}
var todo = await _todoItemRepository.GetAsync(id.Value);
if (todo == null)
{
return(Content("Todo items not found"));
}
var viewModel = new TodoItemViewModel()
{
Id = todo.ID,
Name = todo.Name,
IsComplete = todo.IsComplete,
ModifyTime = todo.ModifyTime,
StepCount = todo.Steps.Count
};
List <TodoItemViewModel> list = new List <TodoItemViewModel>();
list.Add(viewModel);
return(View("Index", list));
}
// GET: TodoItems/Edit/5
public async Task <ActionResult> Edit(int id)
{
var allStatuses = await _context.ToDoStatus
.Select(d => new SelectListItem()
{
Text = d.Title, Value = d.Id.ToString()
})
.ToListAsync();
var item = await _context.ToDoItem.FirstOrDefaultAsync(i => i.Id == id);
var loggedInUser = await GetCurrentUserAsync();
if (item.ApplicationUserId != loggedInUser.Id)
{
return(NotFound());
}
var viewModel = new TodoItemViewModel()
{
Id = item.Id,
Title = item.Title,
TodoStatusId = item.ToDoStatusId,
ToDoStatusOptions = allStatuses
};
return(View(viewModel));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Description,DeadLineDate,CreationDate,Priority,Status,CategoryID")] TodoItemViewModel todoItem)
{
if (id != todoItem.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var todoItemVo = mapper.Map <TodoItemVo>(todoItem);
await provider.Edit(todoItemVo);
}
catch (DbUpdateConcurrencyException)
{
if (!provider.Exists(todoItem.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryID"] = new SelectList(categoryProvider.GetEnum(), "ID", "Name", todoItem.CategoryID);
return(View(todoItem));
}
public void Put([FromBody] TodoItemViewModel todoItem)
{
if (!User.Identity.IsAuthenticated)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Доступ разрешен только для авторизованным пользователям"));
}
if (todoItem == null)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Возникла ошибка при обработке запроса"));
}
var item = _todoItemService.GetTodoItemById(todoItem.Id);
if (item == null)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Не удалось найти указанный элемент"));
}
if (User.Identity.GetUserId() != _todoListService.GetTodoListById(item.TodoListEntityId).ApplicationUserEntityId)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "Доступ к ресурсу запрещен"));
}
item.Name = todoItem.Name;
item.DueDate = todoItem.DueDate;
item.ChangedFromCompletedToIncompleted = (item.IsCompleted ^ todoItem.IsCompleted) &&
!item.IsCompleted;
item.IsCompleted = todoItem.IsCompleted;
item.Note = todoItem.Note;
if (todoItem.InsertToPosition > -1)
{
item.IncertToPlace = todoItem.InsertToPosition;
}
_todoItemService.UpdateTodoItem(item);
}
public async Task <IActionResult> MarkDone(Guid id)
{
if (id == Guid.Empty)
{
return(RedirectToAction("Index"));
}
var currentUser = await _userManager.GetUserAsync(User);
if (currentUser == null)
{
return(RedirectToAction("Index"));
}
TodoItemViewModel[] currentTodoItems = await _todoItemService.GetIncompleteItemsAsync(currentUser);
TodoItemViewModel item = currentTodoItems.SingleOrDefault(i => i.Id == id);
var successful = await _todoItemService.MarkDoneAsync(item, currentUser);
if (!successful)
{
return(BadRequest("Could not mark item as done."));
}
return(RedirectToAction("Index"));
}
private void GridView_ItemClick_2(object sender, ItemClickEventArgs e)
{
var item = e.ClickedItem as TodoItem;
var vm = new TodoItemViewModel(null, item, ViewModel.Stars, "Stars");
this.Frame.Navigate(typeof(TodoItemView), vm);
}
public async Task <IActionResult> Create(TodoItemViewModel todoItem)
{
if (ModelState.IsValid)
{
ApplicationUser user = await _userManager.GetUserAsync(User);
DateTime dtNow = DateTime.UtcNow;
_context.Add(new TodoItem
{
ApplicationUser = user,
Title = todoItem.Title,
Description = todoItem.Description,
CreatedDateTime = dtNow,
UpdatedDateTime = dtNow
});
try
{
await _context.SaveChangesAsync();
Message = "Success, a new item has been created";
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
//log
Message = "Error, something went wrong.";
}
}
return(View(todoItem));
}
private void ListView_ItemClick_1(object sender, ItemClickEventArgs e)
{
var item = e.ClickedItem as TodoItem;
var vm = new TodoItemViewModel(DataService.Inbox, item);
this.Frame.Navigate(typeof(TodoItemView), vm);
}
public ActionResult Edit(TodoItemViewModel tvm)
{
TodoClient tc = new TodoClient();
tc.Edit(tvm.todoItem);
return(RedirectToAction("Index"));
}
private void ProcessItemClick <TModel>(ItemClickEventArgs e) where TModel : ItemCollectionBase
{
var item = e.ClickedItem as TModel;
var vm = new TodoItemViewModel(item, item.Items.FirstOrDefault());
this.Frame.Navigate(typeof(TodoItemView), vm);
}
public TodoItemViewModel Post(TodoItemViewModel todoItem)
{
todoItem.Id = !_TodoItems.Any() ? 1 : _TodoItems.Max(ti => ti.Id) + 1;
_TodoItems.Add(todoItem);
return(todoItem);
}
public async Task <IActionResult> Create([Bind("Id,Created,Task,Detail,IsComplete,IsWorkingOn,StartWorking,Finished")] TodoItemViewModel todoItemVM)
{
TodoItem todoItem;
todoItemVM.Created = TimeZoneInfo
.ConvertTime(DateTime.UtcNow, TZConvert.GetTimeZoneInfo("New Zealand Standard Time"));;
todoItem = new TodoItem
{
Id = todoItemVM.Id,
Created = todoItemVM.Created,
Task = todoItemVM.Task,
Detail = todoItemVM.Detail,
IsComplete = false,
IsWorkingOn = false,
};
if (ModelState.IsValid)
{
_context.Add(todoItem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(todoItem));
}
public IActionResult CreateItem(string id, [FromBody] TodoItemViewModel model)
{
if (ModelState.IsValid)
{
User user = UserHelper.GetUserById(User.Identity.Name);
//You must be logged in as the user specified in the URL
if (id != user?.Id)
{
return(BadRequest("Invalid Permissions"));
}
if (model.Task == null || model.Task.Trim() == "")
{
return(BadRequest());
}
Todo item = new Todo()
{
Owner = user.Id,
Completed = false,
Task = model.Task
};
db.Todos.Add(item);
return(Ok(item));
}
else
{
return(BadRequest());
}
}
protected virtual async Task <IActionResult> DoUpdate(string slug, TodoItemViewModel viewModel)
{
var user = await this.GetLocalUser(UserService);
var todoItem = await TodoItemService.TodoItemRepository
.FindOneBy(t => t.User.Id == user.Id && t.Slug == slug);
if (todoItem == null)
{
return(NotFound());
}
await Validate(viewModel, user.Id, slug);
if (!ModelState.IsValid)
{
return(ValidationProblem());
}
await TodoItemService.Update(todoItem, viewModel.ToDto());
var responseBody = new
{
Message = StatusMessageLocalizer["TodoItemUpdated"].Value,
Data = todoItem.ToDto()
};
return(Ok(responseBody));
}
public TodoItemPage(TodoItem todoItem, TodoListViewModel lvm)
{
InitializeComponent();
this.TodoItemViewModel = new TodoItemViewModel
{
Navigation = this.Navigation,
TodoListViewModel = lvm
};
// addition
if (todoItem == null)
{
this.TodoItemViewModel.IsAdding = true;
}
// editing
else
{
this.TodoItemViewModel.TodoItem = todoItem.ShallowCopy();
this.TodoItemViewModel.Id = todoItem.Id;
this.TodoItemViewModel.Name = todoItem.Name;
this.TodoItemViewModel.Description = todoItem.Description;
this.TodoItemViewModel.Date = todoItem.Date;
this.TodoItemViewModel.Time = todoItem.Time;
}
this.BindingContext = this.TodoItemViewModel;
}
public IActionResult PutTodoItem(string id, TodoItemViewModel TodoItem)
{
try
{
string userId = HttpContext.User.Claims.First(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
UserViewModel user = _mapper.Map <UserViewModel>(_usertRepository.GetById(userId));
var returnTodoItem = user.TodoItems.FirstOrDefault(c => c.id == id);
if (returnTodoItem == null)
{
return(NotFound());
}
var index = user.TodoItems.IndexOf(returnTodoItem);
if (index != -1)
{
user.TodoItems[index] = _mapper.Map <TodoItemViewModel>(TodoItem);
}
_usertRepository.Update(user.id, _mapper.Map <UserEntity>(user));
return(CreatedAtAction(nameof(GetTodoItemById), new { TodoItem.id }, TodoItem));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
ApplicationView.GetForCurrentView().SetPreferredMinSize(new Size(500, 600));
if (e.Parameter.GetType() == typeof(ViewModels.TodoItemViewModel))
{
this.ViewModel = (ViewModels.TodoItemViewModel)(e.Parameter);
}
}
public ActionResult Edit(int id)
{
TodoClient tc = new TodoClient();
TodoItemViewModel tvm = new TodoItemViewModel();
tvm.todoItem = tc.find(id);
return(View("Edit", tvm));
}
public IActionResult Index(TodoItemViewModel model)
{
if (ModelState.IsValid)
{
_todoItemService.Add(_mapper.Map <TodoItem>(model));
}
return(RedirectToAction("Index"));
}
public static void Update(string title, string detail, DateTime date, double size, ImageSource img)
{
DatabaseService.GetInstance().Update(TodoItemViewModel.GetInstance().selectedItem.id, title, detail, size, date);
SaveBitmapToFileAsync((WriteableBitmap)img, TodoItemViewModel.GetInstance().selectedItem.id);
TodoItemViewModel.GetInstance().UpdateTodoItem(title, detail, date, size, img);
App.UpdateFileAndTile();
}
public void Handle(Core.Boundaries.AddTodoItem.Response response)
{
CreatedItem = new TodoItemViewModel()
{
Id = response.Id
};
}
public HttpResponseMessage PostTodoItem(TodoItemViewModel item)
{
var modelStateErrors = ModelState.Values.ToList();
List<string> errors = new List<string>();
foreach (var s in modelStateErrors)
foreach (var e in s.Errors)
if (e.ErrorMessage != null && e.ErrorMessage.Trim() != "")
errors.Add(e.ErrorMessage);
if (errors.Count == 0)
{
try
{
string userId = Request.GetOwinContext().Authentication.User.Identity.GetUserId();
var currentUser = UserManager.FindById(userId);
currentUser.todoItems.Add(new todoItem()
{
completed = false,
task = item.task
});
UserManager.Update(currentUser);
return Request.CreateResponse(HttpStatusCode.Accepted);
}
catch
{
return Request.CreateResponse(HttpStatusCode.InternalServerError);
}
}
else
{
return Request.CreateResponse<List<string>>(HttpStatusCode.BadRequest, errors);
}
var user = db.Users.Where(u => u.firstName == "Test").FirstOrDefault();
}
public async Task NavigateToDetailsView(TodoItemViewModel todo, INavigation navigation)
{
await todo.LoadImagesAsync(); // reload images as they download asynchronously
var detailsView = new TodoItemDetailsView();
detailsView.BindingContext = todo;
await navigation.PushAsync(detailsView);
}
