public async Task <IActionResult> PutReminder(int id, [FromBody] ReminderDTO reminder)
{
//check for a bad request
if (id != reminder.Id)
{
return(BadRequest());
}
//check if the reminder exists
if (!ReminderExists(id))
{
return(NotFound());
}
var dbObject = _context.Reminders.First(x => x.Id == id);
//change the dto fields
dbObject.EventId = reminder.EventId;
dbObject.Date = reminder.EventDate;
dbObject.Message = reminder.Message;
dbObject.Modified = DateTime.Now;
dbObject.ModifiedById = 1; //Exchange for current user
_context.Entry(dbObject).State = EntityState.Modified;
try
{
//try to save the changes
await _context.SaveChangesAsync();
return(Ok());
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ReminderDTO> UpdateReminder(ReminderDTO reminder)
{
var reminderToUpdate = _mapper.Map <ReminderDTO, Reminder>(reminder);
await _repo.Update(reminderToUpdate);
return(reminder);
}
public async Task InsertAsync(ReminderDTO dto)
{
using (var sql = dbConnectionFactory())
{
await sql.ExecuteAsync($"{DapperHelper.INSERT(TABLE, DTOFIELDS)}", dto);
}
}
public IActionResult PutReminder(int id, ReminderDTO reminder)
{
User user = _userRepository.GetBy(User.Identity.Name);
Reminder oldReminder = _reminderRepository.GetById(id);
if (oldReminder == null)
{
return(NotFound());
}
foreach (var tag in reminder.Tags)
{
bool notExist = oldReminder.Tags.FirstOrDefault(t => t.TagName == tag.Name) == null;
if (notExist)
{
Tag createTag = _tagRepository.GetByName(tag.Name);
if (createTag == null)
{
createTag = new Tag(tag.Name, tag.Color, user);
ReminderTag reminderTag = new ReminderTag(oldReminder, createTag);
oldReminder.AddTag(reminderTag, createTag);
_tagRepository.Add(createTag);
}
else
{
ReminderTag reminderTag = new ReminderTag(oldReminder, createTag);
oldReminder.AddTag(reminderTag, createTag);
}
}
}
foreach (var checklist in reminder.CheckList)
{
ChecklistHeader oldHeader = oldReminder.Checklist.FirstOrDefault(c => c.Title == checklist.Title);
bool notExist = oldHeader == null;
if (notExist)
{
ChecklistHeader createChecklistHeader = new ChecklistHeader(checklist.Title, checklist.Volgorde, oldReminder, checklist.Finished, checklist.Checked);
foreach (var item in checklist.Items)
{
ChecklistItem createChecklistItem = new ChecklistItem(item.Title, createChecklistHeader, item.Volgorde, item.Finished, item.Checked);
}
}
else
{
oldHeader.Checked = checklist.Checked;
oldHeader.Finished = checklist.Finished;
oldHeader.Volgorde = checklist.Volgorde;
foreach (var item in checklist.Items)
{
ChecklistItem oldItem = oldHeader.Items.FirstOrDefault(c => c.Title == item.Title);
oldItem.Checked = item.Checked;
oldItem.Finished = item.Finished;
oldItem.Volgorde = item.Volgorde;
}
}
}
oldReminder.RecalculateProcessBar();
_reminderRepository.Update(oldReminder);
_reminderRepository.SaveChanges();
return(NoContent());
}
public async Task <ActionResult <IEnumerable <ReminderDTO> > > GetReminders()
{
//fetch all reminders
var list = await _context.Reminders.Where(x => !x.IsDeleted).Include(x => x.CreatedBy).ToListAsync();
var dtoList = new List <ReminderDTO>();
//select only the needed fields for transfer as described in dto
foreach (var reminder in list)
{
var dto = ReminderDTO.Selector().Compile()(reminder);
dtoList.Add(dto);
}
//return dto list
return(dtoList);
}
public async Task <ActionResult <ReminderDTO> > GetReminder(int id)
{
//fetch the reminder
var reminder = await _context.Reminders.FindAsync(id);
if (reminder == null)
{
return(NotFound());
}
//select only the needed fields for transfer as described in dto
var dto = ReminderDTO.Selector().Compile()(reminder);
//fetch user details
var user = await _context.Users.FindAsync(reminder.CreatedById);
dto.SendtFrom = user.FirstName + " " + user.SirName;
//return dto
return(dto);
}
public async Task <ActionResult <ReminderDTO> > PostReminder([FromBody] ReminderDTO dto)
{
//Exchange CreatedByID for current user
//create new reminder object
var reminder = new Reminder()
{
Created = DateTime.Now,
CreatedById = 1,
Date = dto.EventDate,
EventId = dto.EventId,
Message = dto.Message
};
//save reminder to the db
_context.Reminders.Add(reminder);
await _context.SaveChangesAsync();
//return the new object with the new id
return(CreatedAtAction("GetReminder", new { id = reminder.Id }, ReminderDTO.Selector().Compile()(reminder)));
}
public ActionResult <Reminder> PostReminder(ReminderDTO reminderDTO)
{
User user = _userRepository.GetBy(User.Identity.Name);
Reminder createReminder = new Reminder(reminderDTO.Title, reminderDTO.DatumReleased, user, reminderDTO.Link, reminderDTO.Description, reminderDTO.Watched);
foreach (var tag in reminderDTO.Tags)
{
Tag createTag = _tagRepository.GetByName(tag.Name);
if (createTag == null)
{
createTag = new Tag(tag.Name, tag.Color, user);
ReminderTag reminderTag = new ReminderTag(createReminder, createTag);
createReminder.AddTag(reminderTag, createTag);
_tagRepository.Add(createTag);
}
else
{
ReminderTag reminderTag = new ReminderTag(createReminder, createTag);
createReminder.AddTag(reminderTag, createTag);
}
}
foreach (var checklist in reminderDTO.CheckList)
{
ChecklistHeader createChecklistHeader = new ChecklistHeader(checklist.Title, checklist.Volgorde, createReminder, checklist.Finished, checklist.Checked);
foreach (var item in checklist.Items)
{
ChecklistItem createChecklistItem = new ChecklistItem(item.Title, createChecklistHeader, item.Volgorde, item.Finished, item.Checked);
createChecklistHeader.AddItem(createChecklistItem);
}
createReminder.AddToCheckList(createChecklistHeader);
}
createReminder.RecalculateProcessBar();
_reminderRepository.Add(createReminder);
_tagRepository.SaveChanges();
_reminderRepository.SaveChanges();
return(CreatedAtAction(nameof(GetReminder), new { id = createReminder.ReminderId }, createReminder));
}
public async Task <HttpResponseMessage> AddReminderAsync(ReminderDTO dto)
{
await remindersService.AddReminder(dto);
return(Request.CreateResponse(HttpStatusCode.OK, true));
}
public async Task SendMeetingReminder(DiscordClient client)
{
var discordGuild = client.Guilds.FirstOrDefault(g => g.Key == Constants.GuildId).Value;
if (discordGuild == null)
{
Console.Error.WriteLine("Could not find the specified guild");
return;
}
var now = DateTime.Now;
var events = await GetFoxtrotCalendarEvents(now);
foreach (var evt in events.Items)
{
var eventDateStart = evt.Start != null ? evt.Start.DateTime : null;
if (eventDateStart == null)
{
continue;
}
var eventDateEnd = evt.End != null ? evt.End.DateTime : null;
if (eventDateEnd == null)
{
continue;
}
var deltaTime = (eventDateStart - now).Value.TotalMinutes;
if (15 >= deltaTime && deltaTime > 0.0)
{
var isReminded =
await _reminderRepository.IsReminded(eventDateStart.Value, discordGuild.Id, evt.Summary);
if (isReminded.status == Status.Found || isReminded.reminded)
{
continue;
}
var reminder = new ReminderDTO
{
StartTime = eventDateStart.Value,
GuildId = discordGuild.Id,
Summary = evt.Summary,
Reminded = true
};
var channel = discordGuild.Channels.FirstOrDefault(c => c.Key == Constants.ReminderChannelId).Value;
if (channel == null)
{
Console.Error.WriteLine("Could not find the reminder channel");
continue;
}
var foxtrotRole =
discordGuild.Roles.Values.FirstOrDefault(r => r.Name.ToLower().Contains("foxtrot"));
await _reminderRepository.Create(reminder);
var messageText = $" **{evt.Summary}** is today from {eventDateStart:HH:mm} - {eventDateEnd:HH:mm}. Remember to start your [time tracking](https://clockify.me/tracker).";
var reminderEmbed = new DiscordEmbedBuilder
{
Title = evt.Summary,
Description = messageText,
Timestamp = DateTimeOffset.Now,
Color = DiscordColor.Aquamarine
};
var messageBuilder = new DiscordMessageBuilder
{
Content = foxtrotRole != null ? foxtrotRole.Mention : "@here",
Embed = reminderEmbed
};
var message = await channel.SendMessageAsync(messageBuilder);
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":gift:"));
}
}
}
public async Task <ActionResult <ReminderDTO> > UpdateReminder([FromBody] ReminderDTO reminder)
{
return(Ok(await _remindersService.UpdateReminder(reminder)));
}
protected override void OnStart(string[] args)
{
try
{
DBQuery.Queries.ReminderQuery rq = new DBQuery.Queries.ReminderQuery();
List <ReminderDTO> reminderDTOList = new List <ReminderDTO>();
reminderDTOList = rq.GetReminderData();
foreach (ReminderDTO reminderDto in reminderDTOList)
{
ReminderDTO reminderDTO = new ReminderDTO();
string eventId = reminderDto.EventId;
string participantId = reminderDto.ParticipantId;
string email = reminderDto.Email;
string eventName = reminderDto.Name;
string address = reminderDto.Address;
string city = reminderDto.City;
string state = reminderDto.State;
string zip = reminderDto.Zip;
string startDate = reminderDto.TimeStartShort;
string startTime = reminderDto.TimeStart12Hr;
string endDate = reminderDto.TimeStopShort;
string endTime = reminderDto.TimeStop12Hr;
string adminEmail = "*****@*****.**";
//List of participant email address along with admin email address
List <string> emailAddresses = new List <string>();
List <string> phoneNumbers = new List <string>();
emailAddresses.Add(adminEmail);
if (reminderDTO.EmailOn)
{
emailAddresses.Add(email);
}
if (reminderDTO.SMSOn)
{
phoneNumbers.Add(reminderDTO.Phone);
}
Business.ENotifications.EmailNotification emailNotification = new Business.ENotifications.EmailNotification();
Business.ENotifications.SMSNotification SMSNotification = new Business.ENotifications.SMSNotification();
string body = ($"This is a reminder: " + "<br />" + "<br />" +
$"You're scheduled to attend the event <b>{eventName}</b> on <b>{startDate}</b>" +
$" from <b>{startTime}</b>" +
$" to <b>{endTime}</b>. " + "<br />" + "<br />" +
$"The location is: " + " <br /> " + " <br /> " +
$"<b>{address}</b>, <b>{city}</b>, <b>{state}</b> <b>{zip}</b>");
string subject = "Event Reminder";
//emailNotification.SendEmail(email, body, subject);
foreach (string emailAddress in emailAddresses)
{
emailNotification.SendEmail(emailAddress, body, subject);
}
foreach (string phoneNumber in phoneNumbers)
{
SMSNotification.SendSMS(phoneNumber, body, subject);
}
/* Timestamps when the email notification was sent
* -updates the current participant record with the current datetime
* -the reminder query is set to pull where the EmailNotificationSentTime
* field is null (to prevent sending duplicate notifications) */
int participantKey = Int32.Parse(participantId);
var participants = rq.db.Participants.Find(participantKey);
participants.EmailNotificationSentTime = DateTime.Now;
rq.db.Participants.Attach(participants);
var entry = rq.db.Entry(participants);
entry.Property(e => e.EmailNotificationSentTime).IsModified = true;
rq.db.SaveChanges();
}
}
catch (Exception ex)
{
WriteToFile($"Message={ex.Message}\n InnerException={ex.InnerException} \n\n");
}
}
/* Method to get the participants that have elected to have reminder notifications sent to them
* -queries the database and gets the results as a list
* -passes the list into a DTO object and returns a DTO with the query results */
public List <ReminderDTO> GetReminderData()
{
/* LINQ syntax to query the database for participants with reminder notifications set for today
* -creates a list from the query results */
var reminderList = (from u in db.Users
join e in db.Events on u.Id equals e.CreatedBy.Id
join p in db.Participants on e.Id equals p.EventID.Id
where p.emailNotificationOn == true || p.SMSNotificationOn == true
where p.Reminder.Value.Year == DateTime.Now.Year
where p.Reminder.Value.Month == DateTime.Now.Month
where p.Reminder.Value.Day == DateTime.Now.Day
where p.EmailNotificationSentTime == null
select new
{
p.EventID,
p.Id,
p.SMSNotificationOn,
p.emailNotificationOn,
u.Email,
u.PhoneNumber,
e.Name,
e.Address,
e.City,
e.State,
e.Zip,
e.TimeStart,
e.TimeStop
}).ToList();
//Instantiates a List type based on the Reminder DTO object found in the DTO folder
List <ReminderDTO> reminderDTOList = new List <ReminderDTO>();
/* Iterates the query result list and sets the DTO field value to the query field value
* -then adds the complete record to the DTO object
* -finally returns the DTO object with the query data */
foreach (var u in reminderList)
{
//Instantiates a new Reminder DTO object found in the DTO folder
ReminderDTO reminderDTO = new ReminderDTO();
reminderDTO.EventId = u.EventID.ToString();
reminderDTO.ParticipantId = u.Id.ToString();
reminderDTO.Email = u.Email;
reminderDTO.Phone = u.PhoneNumber;
reminderDTO.Name = u.Name;
reminderDTO.Address = u.Address;
reminderDTO.City = u.City;
reminderDTO.State = u.State;
reminderDTO.Zip = u.Zip;
reminderDTO.SMSOn = u.SMSNotificationOn;
reminderDTO.EmailOn = u.emailNotificationOn;
reminderDTO.TimeStartShort = Convert.ToDateTime(u.TimeStart).ToShortDateString();
reminderDTO.TimeStart12Hr = Convert.ToDateTime(u.TimeStart).ToShortTimeString();
reminderDTO.TimeStopShort = Convert.ToDateTime(u.TimeStop).ToShortDateString();
reminderDTO.TimeStop12Hr = Convert.ToDateTime(u.TimeStop).ToShortTimeString();
reminderDTOList.Add(reminderDTO);
}
return(reminderDTOList);
}
