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();
}
