public async Task <ReminderDto> CreateAsync(IGuild guild, IMessage message, IUser user, DateTime when, String what)
{
var reminder = new ReminderDto(guild.Id, message.Channel.Id, message.Id, user.Id, when, what);
await this.UpdateAsync(reminder);
return(reminder);
}
public ReminderDto Create(ReminderDto dto)
{
Reminder reminder = ConvertToEntity(dto);
appContext.Reminder.Add(reminder);
Save();
return(ConverToDto(reminder));
}
private ReminderViewModel Map(ReminderDto dto)
{
return(new ReminderViewModel
{
Id = dto.Id,
Name = dto.Name,
RemindOn = dto.RemindOn,
ScheduleType = dto.ScheduleType
});
}
private Reminder ConvertToEntity(ReminderDto dto)
{
return(new Reminder
{
Id = dto.Id,
Message = dto.Message,
RemindTo = dto.RemindTo,
TaskId = dto.TaskId,
//Task = dto.TaskDto
});
}
public void Update(ReminderDto dto)
{
var remindItem = appContext.Reminder.Where(w => w.Id == dto.Id).FirstOrDefault();
if (remindItem != null)
{
remindItem.Message = dto.Message;
remindItem.RemindTo = dto.RemindTo;
Save();
}
}
private (Boolean isLate, TimeSpan howLate) CheckIfLate(ReminderDto reminder)
{
var currentTime = DateTime.UtcNow;
var expectedTime = reminder.RemindAt;
var diff = currentTime.Subtract(expectedTime);
// Only display the late message if we're > 1 minute late.
return(diff.TotalMinutes >= 1
? (true, diff)
: (false, TimeSpan.Zero));
}
public JsonResult SaveReminder(ReminderDto reminderItem)
{
if (reminderItem.Id > 0)
{
reminderRepository.Update(reminderItem);
}
else
{
reminderItem = reminderRepository.Create(reminderItem);
}
return(Json(reminderItem));
}
public void AddReminder(Reminder reminder)
{
var table = _tableConfiguration.GetTableReference();
var reminderDto = new ReminderDto
{
Time = reminder.Time,
Text = reminder.Text
};
var insertOperation = TableOperation.Insert(reminderDto);
table.ExecuteAsync(insertOperation).Wait();
reminder.Id = reminderDto.RowKey;
}
public IActionResult ReminderModal(int id, int taskid)
{
ReminderDto reminderDto;
if (id > 0)
{
reminderDto = reminderRepository.Read(id);
}
else
{
reminderDto = new ReminderDto {
TaskId = taskid, RemindTo = DateTime.Now
}
};
return(PartialView("_ReminderModal", reminderDto));
}
public IActionResult Create(ReminderDto reminderDto)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var reminder = new Reminder
{
Title = reminderDto.Title,
Description = reminderDto.Description,
Date = DateTime.Now,
Status = reminderDto.Status,
GroupId = reminderDto.GroupId,
UserId = userId
};
_context.Add(reminder);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public void UpdateReminder(Guid id, ReminderDto reminder)
{
var reminderDb = FindByCondition(x => x.Id.Equals(id)).FirstOrDefault();
if (reminderDb == null)
{
throw new NotFoundException();
}
reminderDb.Name = reminder.Name;
reminderDb.Price = reminder.Price;
reminderDb.Notes = reminder.Notes;
reminderDb.ReminderTerm = ToReminderTerm(reminder.ReminderTerm);
reminderDb.ReminderValue = reminder.ReminderValue;
reminderDb.ExpiryDate = reminder.ExpiryDate;
Update(reminderDb);
}
public async Task <ActionResult <ReminderDto> > PostReminder(ReminderDto reminder)
{
try
{
_repositories.Reminder.CreateReminder(reminder);
await _repositories.SaveAsync();
return(CreatedAtAction("GetReminder", new { id = reminder.Id }, reminder));
}
catch (NotFoundException)
{
return(NotFound());
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult <ReminderDto> Add(Reminder reminder)
{
var ServiceResult = _reminderListService.Add(reminder);
if (ServiceResult.ResponseCode != ResponseCode.Success)
{
return(BadRequest(ServiceResult.Error));
}
var result = new ReminderDto
{
Id = ServiceResult.Result.Id,
Description = ServiceResult.Result.Description,
Message = ServiceResult.Result.Message,
DateDue = ServiceResult.Result.DateDue,
UserId = ServiceResult.Result.UserId
};
return(Ok(result));
}
public IActionResult Create([FromBody] ReminderDto reminderDto)
{
var userId = GetUserId();
var reminder = _mapper.Map <Reminder>(reminderDto);
var user = _userService.GetById(userId);
reminder.User = user;
try
{
reminder = _reminderService.Create(reminder);
var createdReminderDto = _mapper.Map <ReminderDto>(reminder);
return(Ok(createdReminderDto));
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> PutReminder(Guid id, ReminderDto reminder)
{
if (id != reminder.Id)
{
return(BadRequest());
}
try
{
_repositories.Reminder.UpdateReminder(id, reminder);
await _repositories.SaveAsync();
}
catch (NotFoundException)
{
return(NotFound());
}
catch (Exception ex)
{
throw ex;
}
return(NoContent());
}
public void CreateReminder(ReminderDto reminder)
{
var reminderDb = _mapper.Map <Reminder>(reminder);
Create(reminderDb);
}
private IUser GetCurrentUser(ReminderDto reminder)
{
var guild = this._client.GetGuild(reminder.GuildId);
return(guild.CurrentUser);
}
public void Delete(ReminderDto dto)
{
appContext.Reminder.Remove(ConvertToEntity(dto));
Save();
}
private Task <IMessageChannel> GetChannelAsync(ReminderDto reminder)
{
var guild = this._client.GetGuild(reminder.GuildId);
return(Task.FromResult <IMessageChannel>(guild.GetTextChannel(reminder.ChannelId)));
}
public async Task UpdateAsync(ReminderDto reminder)
{
var reminderKey = $"reminders:{reminder.GuildId}:{reminder.ChannelId}:{reminder.MessageId}";
await this._db.AddAsync(reminderKey, reminder);
}
