public IActionResult AddReminder(int noteID, ReminderRequest reminder)
{
try
{
bool success = false, data;
string message;
var idClaim = HttpContext.User.Claims.FirstOrDefault(id => id.Type.Equals("id", StringComparison.InvariantCultureIgnoreCase));
int userId = Convert.ToInt32(idClaim.Value);
data = _userNoteBusiness.AddReminder(userId, noteID, reminder);
if (data)
{
success = true;
message = "Reminder Set Successfully";
return(Ok(new { success, message }));
}
else
{
message = "Try Again!";
return(Ok(new { success, message }));
}
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
public async Task <ReminderRegistration> RegisterAsync(ReminderRequest request)
{
var res = await(await clientFactory()).PostAsync($"api/users/{userId}/reminders",
new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json"));
if (res.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ReminderRegistration>(await res.Content.ReadAsStringAsync()));
}
throw new CalendarServiceException($"Could not register reminder: {res.StatusCode}.");
}
public async Task <IActionResult> RegisterReminder(string userId, [FromBody] ReminderRequest request)
{
if (null == request ||
request.Minutes == 0 ||
string.IsNullOrEmpty(request.NotificationUri) ||
string.IsNullOrEmpty(request.ClientState))
{
return(BadRequest());
}
var reminderRegistration = await reminderService.RegisterAsync(userId, request);
return(Ok(reminderRegistration));
}
public async Task <IActionResult> Post(ReminderRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var reminderId = await reminderService.CreateMotReminder(model);
return(CreatedAtAction("get", reminderId, new
{
ReminderId = System.Guid.NewGuid().ToString()
}));
}
/// <summary>
/// It Add a Reminder to the Notes.
/// </summary>
/// <param name="NoteId">Note Id</param>
/// <param name="reminder">Reminder Data</param>
/// <param name="userId">User Id</param>
/// <returns>If Successfull it return NoteResponse Model or else Null</returns>
public async Task <NoteResponseModel> UpdateRemoveReminder(int NoteId, ReminderRequest reminder, int userId)
{
try
{
if (NoteId <= 0 || reminder == null || userId <= 0)
{
return(null);
}
else
{
return(await _notesRepository.UpdateRemoveReminder(NoteId, reminder, userId));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <int> CreateMotReminder(ReminderRequest model)
{
var expiryDate = DateTime.Parse(model.MotExpiryDate);
var dueDate = expiryDate.AddYears(1).AddDays(-30);
var tableRow = new TableModels.Reminder {
Email = model.Email,
Manufacturer = model.Manufacturer,
Model = model.Model,
MotExpiryDate = expiryDate,
Registration = model.Registration,
ReminderDueDate = dueDate
};
dataContext.Reminders.Add(tableRow);
await dataContext.SaveChangesAsync();
return(tableRow.Id);
}
public bool AddReminder(int userID, int noteID, ReminderRequest reminder)
{
try
{
var userData = _context.UserNotes.FirstOrDefault(user => user.UserId == userID && user.NotesId == noteID);
if (userData != null)
{
userData.Reminder = reminder.Reminder;
_context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> UpdateRemoveReminder(int NoteId, ReminderRequest reminder)
{
try
{
var user = HttpContext.User;
bool status = false;
string message;
if (user.HasClaim(c => c.Type == _tokenType))
{
if (user.Claims.FirstOrDefault(c => c.Type == _tokenType).Value == _login &&
user.Claims.FirstOrDefault(c => c.Type == _userType).Value == _regularUser)
{
int UserId = Convert.ToInt32(user.Claims.FirstOrDefault(c => c.Type == _userId).Value);
if (reminder.Reminder != null)
{
TimeZoneInfo time = TimeZoneInfo.Local;
reminder.Reminder = TimeZoneInfo.ConvertTimeFromUtc(reminder.Reminder.Value, time);
}
NoteResponseModel data = await _notesBusiness.UpdateRemoveReminder(NoteId, reminder, UserId);
if (data != null)
{
status = true;
message = "Reminder Has Been Successfully Updated to the note";
return(Ok(new { status, message, data }));
}
message = "Unable to update the reminder to the note";
return(Ok(new { status, message }));
}
}
message = "Invalid Token";
return(BadRequest(new { status, message }));
}
catch (Exception e)
{
return(BadRequest(new { e.Message }));
}
}
HookRegistry[] EnableReminder(ReminderRequest request);
public async Task <ResponseWrapper <PaginatedResponse <ReminderResponse> > > RemindersAsync(ReminderRequest model, string userId)
{
var paginatedResult = await _reminderService.ReminderListAsync(model, userId);
if (paginatedResult?.Items?.Any() != true)
{
return(NoItems <ReminderResponse>());
}
var result = (from reminder in paginatedResult.Items
select new ReminderResponse
{
CheckBank = reminder.CheckBank,
CheckNumber = reminder.CheckNumber,
Date = reminder.Date.ToUnixTimestamp(),
Price = (long)reminder.Price,
Subject = reminder.Description,
Pictures = reminder.Pictures?.Select(x => Path.Combine(_baseUrl, $"img/{x.File}")).ToList()
}).ToList();
return(Success(result, paginatedResult));
}
public Task <int> CreateMotReminder(ReminderRequest model)
{
dataStore.Add(model);
return(Task.FromResult(dataStore.Count()));
}
public bool AddReminder(int userID, int noteID, ReminderRequest reminder)
{
bool responseData = _userNoteRepository.AddReminder(userID, noteID, reminder);
return(responseData);
}
public async Task <IActionResult> RemindersAsync([FromForm] ReminderRequest model)
{
var response = await _appService.RemindersAsync(model, this.AuthorizeStatus.User.UserId);
return(new JsonResult(response, _settings));
}
