public async Task <IActionResult> SaveChangesReminderAsync(ReminderViewModel reminderViewModel) { var note = await _context.Reminders.FindAsync(reminderViewModel.Id); note.Header = reminderViewModel.Header; note.Text = reminderViewModel.Text; note.DateLastChanged = DateTime.Now; note.ReminderDate = new DateTime(reminderViewModel.ReminderDate.Ticks); note.StatusNote = reminderViewModel.StatusNote; try { _context.Entry(note).State = EntityState.Modified; } catch (Exception e) { Debug.WriteLine(e.Message); } try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ReminderExists(reminderViewModel.Id)) { return(RedirectToAction("Index", "Index")); } throw; } return(RedirectToAction("Index", "Index")); }
public ActionResult Edit() { var reminder = new ReminderViewModel(); _reminderLogic.GetById(reminder); return(View(reminder)); }
public async Task <IActionResult> Post(long noteId, ReminderViewModel reminder) { try { if (ModelState.IsValid) { var note = await repository.Get(noteId); if (note != null) { var reminderEntity = mapper.Map <ReminderViewModel, Reminder>(reminder); note.Reminders.Add(reminderEntity); await repository.Update(note); reminder = mapper.Map <Reminder, ReminderViewModel>(reminderEntity); return(Created($"/api/Notes/{noteId}/Reminders/{reminder.Id}", reminder)); } else { return(NotFound($"Note {noteId} not Found")); } } else { return(BadRequest(ModelState)); } } catch (Exception ex) { logger.LogCritical(ex, $"Failed to insert reminder for note {noteId}"); return(BadRequest($"Failed to insert reminder for note {noteId}")); } }
private OperationResult <ReminderViewModel> MapToVM( ValidationResult <Domain.Reminders.Reminder> validationResult) { return(new OperationResult <ReminderViewModel> { Data = ReminderViewModel.MapToVM(validationResult.Data), Errors = validationResult.GetErrors(Severity.Error) }); }
public IActionResult AddOrEditReminder(ReminderViewModel rvm) { if (ModelState.IsValid) { _expirationReminderService.SaveReminder(User.GetUserId(), Mapper.Map <Reminder>(rvm)); _expirationReminderService.SetCategoriesToReminder(User.GetUserId(), rvm.Id, rvm.SelectedCategories); return(RedirectToAction(nameof(ListReminders))); } return(View(rvm)); }
public IActionResult AddOrEditReminder(int?id) { Reminder reminder = id.HasValue ? _expirationReminderService.GetReminder(User.GetUserId(), id.Value) : _expirationReminderService.GetReminderDefault(User.GetUserId()); ReminderViewModel viewModel = Mapper.Map <ReminderViewModel>(reminder); List <ReminderCategory> categories = _expirationReminderService.GetReminderCategories(User.GetUserId()); viewModel.SetAvailableCategories(Mapper.Map <List <ReminderCategory>, List <ReminderCategoryViewModel> >(categories)); return(View(viewModel)); }
public IActionResult DeleteReminder(ReminderViewModel rvm) { if (ModelState.IsValid) { _expirationReminderService.DeleteReminder(User.GetUserId(), Mapper.Map <Reminder>(rvm)); return(RedirectToAction(nameof(ListReminders))); } return(View(rvm)); }
public async Task <IActionResult> Create() { var viewModel = new ReminderViewModel { Date = DateTime.Now.ToString("dd.MM.yyyy"), Time = DateTime.Now.AddHours(+1).ToString("HH:mm"), ReminderTypes = await _unitOfWork.ReminderTypes.GetReminderTypes() }; return(View("ReminderForm", viewModel)); }
[HttpPost] //działa public async Task <JsonResult> CreateReminder([FromBody] CreateReminderRequestViewModel request) { var owner = await _userService.GetUserByIdAsync(request.ownerId); var date = DateTime.Parse(request.date); // ISO time var reminder = await _reminderService.CreateReminderAsync(request.title, request.description, date, owner); var result = new ReminderViewModel(reminder); return(Json(result)); }
public CardReminder(Reminder reminder) { _vm = new ReminderViewModel(reminder); BindingContext = _vm; InitializeComponent(); TapGestureRecognizer tap = new TapGestureRecognizer(); tap.Tapped += (object sender, EventArgs e) => { DeleteReminder(); }; ButtonDeleteReminder.GestureRecognizers.Add(tap); }
public ActionResult Create([FromBody] ReminderViewModel reminder) { try { var result = this._reminderAppService.Create(this._mapper.Map <ReminderDomain>(reminder)); return(StatusCode(201, new ResponseViewModel { Data = this._mapper.Map <ReminderViewModel>(result) })); } catch (Exception ex) { return(StatusCode(500, new ResponseViewModel { ErrorMessage = ex.Message })); } }
public ActionResult Reminder(long[] studentids) { var children = db.fees.Where(x => x.status == FeePaymentStatus.UNPAID.ToString() && x.duedate < DateTime.Now && studentids.Contains(x.studentid)) .GroupBy(x => x.user); if (!children.Any()) { return(SendJsonErrorResponse("Cannot send reminder if fee is not overdue")); } var viewmodel = new ReminderViewModel(); foreach (var entry in children) { if (viewmodel.parents == null) { viewmodel.parents = entry.Key.students_guardians.Select(x => new SelectListItem() { Value = x.user1.id.ToString(), Text = x.user1.ToName(true) }); } var alert = new LateFeeAlert(); alert.studentname = entry.Key.ToName(false); alert.studentid = entry.Key.id; alert.overdueFees = entry.Select(x => x).ToModel(auth.perms); viewmodel.alerts.Add(alert); } // set next due date one week from largest prev date var prevDate = viewmodel.alerts.SelectMany(x => x.overdueFees).OrderByDescending(y => y.duedate).First().duedate; viewmodel.nextduedate = (prevDate.HasValue? prevDate.Value: DateTime.Now).AddDays(7).ToString(Constants.DATEFORMAT_DATEPICKER); // init tempaltes viewmodel.templates = db.fees_templates.OrderBy(x => x.title).Select(x => new SelectListItem() { Value = x.id.ToString(), Text = x.title }); var view = this.RenderViewToString("Reminder", viewmodel); return(Json(view.ToJsonOKData(), JsonRequestBehavior.AllowGet)); }
/// <summary> /// Constructor for the variables declared /// </summary> public Reminder() { InitializeComponent(); DataContext = new ReminderViewModel(); DataContext = new UserViewModel(); if (datacontext.DatabaseExists()) { NoteDatagrid.ItemsSource = datacontext.NoteTables; // Connecting to the SQLExpress Server } _days = new List <string>() { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" }; _list = new List <Note>(); }
private void ShowReminder(ReminderViewModel model, Action onClose) { log.Info($"Displayed '{model.Title}' reminder."); notificationManager.Show(model, expirationTime: TimeSpan.FromMinutes(15), onClose: () => { if (onClose != null) { onClose.Invoke(); } else { log.Info($"User dismissed '{model.Title}' reminder."); } }); }
// GET public async Task <IActionResult> EditReminder(string idRem) { var note = await _context.Reminders.FindAsync(new Guid(idRem)); var model = new ReminderViewModel() { Id = note.Id, Header = note.Header, Text = note.Text, DateCreated = note.DateCreated, DateLastChanged = note.DateLastChanged, ReminderDate = note.ReminderDate, StatusNote = note.StatusNote, IdUser = note.IdUser }; return(View(model)); }
public async Task <IActionResult> Put(long noteId, long id, ReminderViewModel reminder) { try { if (ModelState.IsValid) { var note = await repository.Get(noteId); if (note != null) { var reminderEntity = note.Reminders.FirstOrDefault(r => r.Id == id); if (reminderEntity != null) { reminder.Id = id; mapper.Map(reminder, reminderEntity); return(Ok(await repository.Update(note))); } else { return(NotFound($"Reminder {id} not Found in Note {noteId}")); } } else { return(NotFound($"Note {noteId} not Found")); } } else { return(BadRequest(ModelState)); } } catch (Exception ex) { logger.LogCritical(ex, $"Failed to insert reminder for note {noteId}"); return(BadRequest($"Failed to insert reminder for note {noteId}")); } }
public IActionResult Edit(Guid id, ReminderViewModel reminder) { var token = GetTokenFromSesssion(); if (string.IsNullOrEmpty(token)) { return(RedirectToAction("Login")); } var client = _clientFactory.CreateClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); var httpContent = new StringContent(JsonConvert.SerializeObject(reminder, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }), Encoding.UTF8, "application/json"); HttpResponseMessage response; if (id != null && id != Guid.Empty) { response = client .PutAsync($"https://localhost:44356/api/reminders/{id}", httpContent) .ConfigureAwait(false).GetAwaiter().GetResult(); } else { response = client .PostAsync($"https://localhost:44356/api/reminders", httpContent) .ConfigureAwait(false).GetAwaiter().GetResult(); } if (response.IsSuccessStatusCode) { return(RedirectToAction("Index")); } else { return(RedirectToAction("Error")); } }
protected override async void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e) { _vm = (ReminderViewModel)DataContext; _vm.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_vm_PropertyChanged); if (this.NavigationContext.QueryString.ContainsKey("id")) { string guidIdString = this.NavigationContext.QueryString["id"]; Guid id = Guid.Parse(guidIdString); int?index = null; if (this.NavigationContext.QueryString.ContainsKey("index")) { string indexString = this.NavigationContext.QueryString["index"]; index = Int32.Parse(indexString); } DateTime?time = null; if (this.NavigationContext.QueryString.ContainsKey("time")) { string timeString = this.NavigationContext.QueryString["time"]; time = DateTime.Parse(timeString); } string spoor = this.NavigationContext.QueryString["spoor"]; await _vm.Initialize(id, index, time, spoor); } else { await _vm.Initialize(null, null, null, null); } base.OnNavigatedTo(e); }
public async Task <IActionResult> Save(ReminderViewModel viewModel) { if (!ModelState.IsValid) { return(View("ReminderForm", viewModel)); } var userId = _userManager.GetUserId(HttpContext.User); var eventDate = viewModel.GetDateTime(); if (viewModel.Id == 0) { var reminder = _mapper.Map <ReminderViewModel, Reminder>(viewModel); reminder.UserId = userId; reminder.EventDate = eventDate; reminder.AddNotification(eventDate, isDefault: true); _unitOfWork.Reminders.AddReminder(reminder); } else { var reminderInDb = await _unitOfWork.Reminders.GetReminder(viewModel.Id, userId); _mapper.Map <ReminderViewModel, Reminder>(viewModel, reminderInDb); reminderInDb.EventDate = eventDate; var defaultNotification = reminderInDb.Notifications .Where(n => n.IsDefault == true && !n.IsSent) .Single(); defaultNotification.NotificationDateTime = eventDate; } await _unitOfWork.CompleteAsync(); return(RedirectToAction("Index", "Reminders")); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> public MainViewModel(ITimerService timerService, TrayIconViewModel trayIconViewModel, ReminderViewModel reminderViewModel) { TimerService = timerService; TrayIconViewModel = trayIconViewModel; ReminderViewModel = reminderViewModel; }
private async void CheckForReminder(object sender, EventArgs e) { if (_settings == null || _patron == null) { return; } if (_core.TryGetUiManager(out IUiManager ui)) { if (ui.CurrentPage.GetType().Assembly == this.GetType().Assembly) { return; } } var mealDetails = GetNextMealReminder(_settings, _patron); var mealToRemind = mealDetails?.CompMeal; var meal = mealDetails?.Meal; #if DEBUG (sender as DispatcherTimer).Stop(); #endif if (mealDetails == null) { #if DEBUG mealToRemind = _settings.Meals.Find(m => { return(m.Code == "LUN"); }); meal = _patron.Meals.Find(m => { return(m.Code == "LUN"); }); #else return; #endif } if (mealToRemind == null || meal == null) { return; } try { var vm = new MenuViewModel(_core, _mrn, computrition, _settings, MealNotRequiredCategoryName); await vm.SetSelectedMealAsync(meal); await vm.UnlockAsync(); var reminder = new ReminderViewModel(_core, vm, mealToRemind, this, meal); if (_core.TryGetUiManager(out IUiManager ui2)) { if (_previousReminder != null) { ui2.Refrain(_previousReminder); ui2.HidePopup(_previousReminder); } _previousReminder = reminder; if (mealToRemind.MessageType == "notification") { ui2.Notify(reminder); } else { await ui2.ShowPopup <object>(reminder); } } else { _core.Logger.Error(this, "ui manager not loaded"); } } catch (Exception ex) { _core.Logger.Error(this, ex.Message); } }
public ActionResult Create() { var reminderViewModel = new ReminderViewModel(); return(View(reminderViewModel)); }
private void OnSelectedMenuItem() { if (SelectedMenuItem == MenuResources.CallRegistry) { if (CallRegistryViewModel == null) CallRegistryViewModel = new CallRegistryViewModel(this.Messenger, this.UserLogin) { ParentViewModel = this }; DetailSectionViewModel = CallRegistryViewModel; return; } if (SelectedMenuItem == MenuResources.Reminders) { if (ReminderViewModel == null) ReminderViewModel = new ReminderViewModel(this.Messenger, this.UserLogin) { ParentViewModel = this }; DetailSectionViewModel = ReminderViewModel; } }
public ActionResult Create(ReminderViewModel reminderViewModel) { _reminderLogic.CreateReminder(reminderViewModel); return(RedirectToAction("Index")); }
public ReminderResponse(ReminderViewModel setReminder) : this(true, ClientMessageConstant.Success, setReminder) { }
public ActionResult Edit(ReminderViewModel reminder) { _reminderLogic.UpdateReminder(reminder); return(RedirectToAction("Index")); }
private ReminderResponse(bool success, string message, ReminderViewModel setReminder) : base(success, message) { SetReminder = setReminder; }
public MainPage() { InitializeComponent(); BindingContext = new ReminderViewModel(); }