public ReminderForm(Reminder reminder,string musicPath)
{
InitializeComponent();
_reminder = reminder;
_musicPath = musicPath;
InitInfo();
}
private void Button_Click_2(object sender, RoutedEventArgs e)
{
i++;
bool isReminderExist;
Reminder reminder = ScheduledActionService.Find("Reminder" + i) as Reminder;
if (reminder == null)
{
isReminderExist = false;
reminder = new Reminder("Reminder" + i);
}
else
{
isReminderExist = true;
}
reminder.BeginTime = DateTime.Now.AddMinutes(1);
reminder.ExpirationTime = DateTime.Now.AddMinutes(2);
reminder.Content = "提醒" + i;
reminder.NavigationUri = new Uri("/Page1.xaml", UriKind.Relative);
reminder.RecurrenceType = RecurrenceInterval.Daily;
if (!isReminderExist)
ScheduledActionService.Add(reminder);
else
ScheduledActionService.Replace(reminder);
var reminders = ScheduledActionService.GetActions<Reminder>();
lls2.ItemsSource = reminders.ToList();
}
private void Add_Click(object sender, EventArgs e)
{
if(tbxTitle.Text=="")
{
MessageBox.Show("Vui lòng nhập tiêu đề.");
return;
}
GhiChu u = new GhiChu();
u.Title = tbxTitle.Text;
u.Content = tbxContent.Text;
string date = String.Format("{0:d}", datePicker.Value) + " " + String.Format("{0:t}", timePicker.Value);
u.Time = DateTime.ParseExact(date, "M/d/yyyy h:m tt", CultureInfo.InvariantCulture, DateTimeStyles.None);
if (u.Time <= DateTime.Now)
{
MessageBox.Show("Hạn chót phải sau thời điểm hiện tại.");
return;
}
u.Complete = false;
DatabaseHelper help = new DatabaseHelper();
help.Insert(u);
if (u.Title.Length > 35)
{
u.Title = u.Title.Substring(0, 35) + "...";
}
Reminder reminder = new Reminder(u.Id.ToString());
reminder.Title = u.Title;
reminder.Content = u.Content;
reminder.BeginTime = u.Time;
reminder.NavigationUri = new Uri("/DetailPage.xaml?id=" + u.Id, UriKind.Relative);
ScheduledActionService.Add(reminder);
NavigationService.GoBack();
}
public void setReminder(DateTime time, int reminderIndex)
{
string reminderName = "reminder" + reminderIndex;
Reminder reminder = ScheduledActionService.Find(reminderName) as Reminder;
if (reminder != null)
{
try
{
ScheduledActionService.Remove(reminderName);
}
catch (Exception)
{
}
}
reminder = new Reminder(reminderName);
reminder.Content = "Your reminder for RSS is Triggered. Please Tap the HERE to play your Feed";
//alarm.Sound = new Uri(@"http://dl.dropbox.com/u/5758134/sara.mp3");
reminder.BeginTime = time;
reminder.ExpirationTime = DateTime.MaxValue;
reminder.RecurrenceType = RecurrenceInterval.Daily;
string queryString = "?tab=" + Const.PLAY_AUDIO;
reminder.NavigationUri = new Uri("/MainPage.xaml" + queryString, UriKind.Relative);
ScheduledActionService.Add(reminder);
}
public ActionResult Create()
{
ViewBag.PossibleTasks = this.taskProcessor.GetTasksList(userRepository.GetByName(User.Identity.Name).Id);
var reminder = new Reminder();
reminder.ReminderDate = DateTime.Now;
return this.View(reminder);
}
public ImminentReminderModel(Vehicle vehicle, Reminder reminder, bool isOverdue)
{
IsOverdue = isOverdue;
_vehicle = vehicle;
_reminder = reminder;
_summary = new ReminderSummaryModel(reminder,isOverdue);
}
private void btnTestDeserialize_Click(object sender, EventArgs e)
{
var account = new Account();
using (var fs = new FileStream(string.Format(FolderPath, typeof(Account)).Replace("ToDo.", ""), FileMode.Open, FileAccess.Read))
{
FileIO.LoadFromFile(fs, ref account);
fs.Close();
}
var project = new Project();
using (var fs = new FileStream(string.Format(FolderPath, typeof(Project)).Replace("ToDo.", ""), FileMode.Open, FileAccess.Read))
{
FileIO.LoadFromFile(fs, ref project);
fs.Close();
}
var task = new Task();
using (var fs = new FileStream(string.Format(FolderPath, typeof(Task)).Replace("ToDo.", ""), FileMode.Open, FileAccess.Read))
{
FileIO.LoadFromFile(fs, ref task);
fs.Close();
}
var reminder = new Reminder();
using (var fs = new FileStream(string.Format(FolderPath, typeof(Reminder)).Replace("ToDo.", ""), FileMode.Open, FileAccess.Read))
{
FileIO.LoadFromFile(fs, ref reminder);
fs.Close();
}
var location = new Location();
using (var fs = new FileStream(string.Format(FolderPath, typeof(Location)).Replace("ToDo.", ""), FileMode.Open, FileAccess.Read))
{
FileIO.LoadFromFile(fs, ref location);
fs.Close();
}
}
private static int CompareReminders(Reminder x, Reminder y)
{
if (x == null && y == null)
{
return 0;
}
else if (x != null && y == null)
{
return -1; // I want non-null values first
}
else if (x == null && y != null)
{
return 1; // I want non-null values first
}
else
{
int result = CompareDueDate(x, y);
if (result == 0)
{
result = CompareDueDistance(x, y);
if (result == 0)
{
result = x.ReminderId.CompareTo(y.ReminderId);
}
}
return result;
}
}
public void PostShouldCreateEmailReminder()
{
FetchReminderType fetchReminderType = Task.New<FetchReminderType>();
fetchReminderType.In.ReminderTypeName = "email";
fetchReminderType.Execute();
var reminder = new Reminder {
ReminderType = fetchReminderType.Out.ReminderType,
Contact = "*****@*****.**",
Message = "hello peoples",
RemindOn = DateTime.Now,
Verified = false,
Address = "1234 address ave",
CreatedAt = DateTime.Now
};
var response = browser.Post(url, with => {
with.HttpRequest();
with.FormValue("contact", reminder.Contact);
with.FormValue("message", reminder.Message);
with.FormValue("remindOn", reminder.RemindOn.ToString());
with.FormValue("verified", reminder.Verified.ToString());
with.FormValue("address", reminder.Address);
with.FormValue("createdAt", reminder.CreatedAt.ToString());
});
Assert.AreEqual(Nancy.HttpStatusCode.Created, response.StatusCode);
Assert.That(response.Context.JsonBody<Reminder>(), Is.EqualTo(reminder));
}
public Task<Reminder> AddReminderAsync(string message, string when, IRequestContext context)
{
var reminder = new Reminder(message, when);
_reminders.Add(reminder);
context.Clear();
return Task.FromResult(reminder);
}
private void Save_Click(object sender, RoutedEventArgs e)
{
DateTime todoDate = dpicker.Value.Value;
DateTime todoTime = tpicker.Value.Value;
DateTime deadline = new DateTime(todoDate.Year, todoDate.Month, todoDate.Day, todoTime.Hour, todoTime.Minute, todoTime.Second);
try
{
ScheduledActionService.Remove(App.TodoViewModel.findTodoById(todoid).Title);
}
catch
{
}
App.TodoViewModel.findTodoById(todoid).Title = tbtitle.Text;
App.TodoViewModel.findTodoById(todoid).Content = tbcontent.Text;
App.TodoViewModel.findTodoById(todoid).Deadline = deadline;
App.TodoViewModel.findTodoById(todoid).Category = lpicker.SelectedItem.ToString();
try
{
Reminder rem = new Reminder(App.TodoViewModel.findTodoById(todoid).Title);
rem.BeginTime = deadline;
ScheduledActionService.Add(rem);
}
catch
{
}
NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}
public void CriarRemindersAgua(double peso)
{
if (RemindersAguaConfigurados())
return;
Configuracoes configuracoes = new Configuracoes();
DateTime dateTime = MetodosTempo.StringToDateTime(configuracoes.GetHorarioInicioAgua());
string nome = "agua";
int horaMax = MetodosTempo.Hora(configuracoes.GetHorarioFimAgua());
int minutoMax = MetodosTempo.Minuto(configuracoes.GetHorarioFimAgua());
int qtdeIntervalos = MetodosTempo.QtdeIntervalos(configuracoes.GetHorarioInicioAgua(), configuracoes.GetHorarioFimAgua(), configuracoes.GetIntervaloAgua());
qtdeIntervalos++;
for (int i = 0; (dateTime.Hour < horaMax) || ((dateTime.Hour == horaMax) && (dateTime.Minute <= minutoMax)); i++)
{
Reminder reminder = new Reminder(nome + i.ToString());
reminder.Title = "Beber " + Math.Ceiling(Calculo.calculoConsumoAgua(peso) / qtdeIntervalos) + "ml de água";
reminder.Content = MetodosTempo.DateTimeToString(dateTime);
if (DateTime.Compare(DateTime.Now, dateTime) > 0)
reminder.BeginTime = dateTime.AddDays(1);
else
reminder.BeginTime = dateTime;
reminder.ExpirationTime = dateTime.AddYears(10);
reminder.RecurrenceType = RecurrenceInterval.Daily;
dateTime = dateTime.AddHours(MetodosTempo.Hora(configuracoes.GetIntervaloAgua()));
dateTime = dateTime.AddMinutes(MetodosTempo.Minuto(configuracoes.GetIntervaloAgua()));
reminder.NavigationUri = new Uri("/View/Perfil.xaml", UriKind.Relative);
ScheduledActionService.Add(reminder);
}
}
public void CreateReminder(PackageViewModel package)
{
Reminder deliveryReminder = new Reminder(package.TrackingNumber);
deliveryReminder.BeginTime = System.DateTime.Now.AddSeconds(30);
deliveryReminder.ExpirationTime = System.DateTime.Now.AddSeconds(610);
deliveryReminder.Content = "\"" + package.Name + "\" will be arriving today!";
ScheduledActionService.Add(deliveryReminder);
Debug.WriteLine("Reminded added for package (" + package.TrackingNumber + ")");
}
public void CreateButton_Click(object sender, System.Windows.RoutedEventArgs e)
{
for (int i = 0; i < 5; i++)
{
string reminderName = "My reminder " + i;
Reminder reminder = new Reminder(reminderName);
// NOTE: setting the Title property is supported for reminders
reminder.Title = "My reminders .... " + i;
reminder.Content = "My reminders .... My reminders ...." + i;
//NOTE: the value of BeginTime must be after the current time
//set the BeginTime time property in order to specify when the reminder should be shown
reminder.BeginTime = DateTime.Now.AddSeconds(5.0D + i);
// NOTE: ExpirationTime must be after BeginTime
// the value of the ExpirationTime property specifies when the schedule of the reminder expires
// very useful for recurring reminders, ex:
// show reminder every day at 5PM but stop after 10 days from now
reminder.ExpirationTime = reminder.BeginTime.AddSeconds(5.0 + i);
reminder.RecurrenceType = RecurrenceInterval.Daily;
// you can set a navigation uri that is passed to the application when it is launched from the reminder
//reminder.NavigationUri = navigationUri;
reminder.NavigationUri = new Uri("/View/FirstPage.xaml", UriKind.Relative);
ScheduledAction sa = ScheduledActionService.Find(reminderName);
if (sa == null)
{
try
{
ScheduledActionService.Add(reminder);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Can not create the reminder: " + ex.Message);
}
}
else
{
System.Diagnostics.Debug.WriteLine("A reminder is set already.");
System.Windows.MessageBox.Show("A reminder is set already.");
}
}
IEnumerable<Reminder> reminders = ScheduledActionService.GetActions<Reminder>();
if (reminders != null)
{
foreach (Reminder re in reminders)
{
System.Diagnostics.Debug.WriteLine("The name of the reminder: " + re.Name);
System.Diagnostics.Debug.WriteLine("The reminder is scheduled: " + re.IsScheduled);
System.Diagnostics.Debug.WriteLine("The tile of the reminder: " + re.Title);
}
System.Windows.MessageBox.Show("Reminders are scheduled!");
}
}
public static void AddReminder(Reminder reminder)
{
try
{
ScheduledActionService.Add(reminder);
}
catch (System.Exception)
{
}
}
protected void Button1_Click(object sender, EventArgs e)
{
try
{
int mid = 1, msgid = 1;
//System.Windows.Forms.MessageBox.Show("Before alert " + Request.Params.Get("alert"));
if (Request.Params.Get("alert") != null)
{
//System.Windows.Forms.MessageBox.Show("In alert ");
Mails m;
Messages mg;
Clock c;
bool MailEnabled = (Request.Params.Get("mail") != null);
bool MessageEnabled = Request.Params.Get("message") != null;
if (MailEnabled || MessageEnabled)
{
c = InitializeClock();
c.Save();
if (MailEnabled)
{
Label1.Text += " Mail ";
m = new Mails(-1, TextBox1.Text, TextBox2.Text, TextBox3.Text, c.getId());
m.save();
mid = m.getId();
}
if (MessageEnabled)
{
Label1.Text += " Message";
mg = new Messages(-1, TextBox4.Text, TextBox6.Text, c.getId());
mg.save();
msgid = mg.getId();
}
}
}
// System.Windows.Forms.MessageBox.Show("Before saving");
Label1.Text += " Remainder";
Reminder r = new Reminder(u.getUserName(), Calendar1.SelectedDate.ToString("dd/MMM/yyyy"), DropDownList10.SelectedItem.Text, TextBox7.Text, mid, msgid);
// System.Windows.Forms.MessageBox.Show("After saving");
Label1.Text = r.getQuery();
if (r.save())
{
/*Response.Write("<script language='javascript'>"+
"alert('Reminder added successfully..');"+
"window.open('./RemindersList.aspx');"+
"alert('new Page');"+
"</script>");*/
Response.Redirect("RemindersList.aspx");
}
else
Response.Write("<script language='javascript'>alert('An error occured in saving your reminder , try again after few seconds');</script>");
}
catch (Exception ee) { Response.Write(ee.Message); }
}
public static Reminder getById(int Id)
{
string query = "SELECT * FROM Remainder WHERE Id=" + Id;
OleDbDataReader odr = DataBase.getData(query);
if(odr.Read())
{
Reminder r = new Reminder(odr[1].ToString(), odr[2].ToString(), odr[3].ToString(), odr[4].ToString(), int.Parse(odr[5].ToString()), int.Parse(odr[6].ToString()));
r.Id = Id;
return r;
}
return null;
}
/// <summary>
/// Creates a new Reminder instance and adds to current medicine's Reminders list
/// </summary>
/// <param name="beginTime">Begin time for Reminder</param>
/// <param name="endTime">End time for Reminder</param>
/// <param name="interval">Frequency of Reminder</param>
public void AddReminderToList(DateTime beginTime, DateTime endTime, RecurrenceInterval interval)
{
String name = System.Guid.NewGuid().ToString();
Reminder reminder = new Reminder(name);
reminder.Title = "Its time to take medicine";
reminder.BeginTime = beginTime;
reminder.ExpirationTime = endTime;
reminder.RecurrenceType = interval;
medicine.Reminders.Add(reminder);
//NotifyPropertyChanged("Reminders");
}
public ActionResult Create(Reminder reminder)
{
if (ModelState.IsValid)
{
reminder.UserId = userRepository.GetByName(User.Identity.Name).Id;
this.reminderRepository.Add(reminder);
return this.RedirectToAction("MyReminders");
}
ViewBag.PossibleTasks = this.taskProcessor.GetAllTasks();
ViewBag.PossibleEmployees = this.userRepository.GetAll();
return this.View(reminder);
}
private void AddReminder()
{
Reminder reminder = new Reminder(App.CurrentItem.textboxTaskContent.Text);
reminder.Title = App.CurrentItem.textboxTaskContent.Text;
reminder.Content = App.CurrentItem.Notes;
reminder.BeginTime = App.CurrentItem.date;
reminder.ExpirationTime = App.CurrentItem.date;
reminder.RecurrenceType = RecurrenceInterval.None;
reminder.NavigationUri = new Uri("/Mainpage.xaml",UriKind.Relative);
// Register the reminder with the system.
ScheduledActionService.Add(reminder);
}
public override bool IsApplicable(Reminder reminder, IWpfTextView view)
{
var now = DateTime.Now;
//using (var db = new SessionsContext())
//{
// var current = db.Sessions.Where(s => !s.Complete && s.Start > reminder.CreatedOn);
// if (current.Any())
// return true;
// var sessions = db.Sessions
// .Where(s => s.Complete && s.End.Value > reminder.CreatedOn);
// return sessions.Any();
//}
return true;
}
public static void addScheduleReminder(string name, string title, string content, DateTime beginTime, DateTime expirationTime)
{
Reminder reminder = new Reminder(name);
reminder.Title = title;
reminder.Content = content;
reminder.BeginTime = beginTime;
reminder.ExpirationTime = expirationTime;
reminder.RecurrenceType = RecurrenceInterval.Daily;
//reminder.NavigationUri = navigationUri;
//reminder.
// Register the reminder with the system.
ScheduledActionService.Add(reminder);
}
private void AddReminder_Click(object sender, EventArgs e)
{
string reminderName = string.Format("Reminder {0}", Guid.NewGuid());
Reminder reminder = new Reminder(reminderName);
reminder.BeginTime = DateTime.Now.AddMinutes(1);
reminder.RecurrenceType = RecurrenceInterval.Daily;
reminder.Content = "This is a WP7 in Action Reminder";
reminder.Title = "Reminders in action";
reminder.NavigationUri = new Uri(
"/MainPage.xaml?reminder=" + reminderName, UriKind.Relative);
ScheduledActionService.Add(reminder);
DisplayScheduledNotifications();
}
public DiaryEntry()
{
date = DateTime.Now;
time = TimeOfDay.None;
timeSelected = DateTime.Now;
text = "";
underline = false;
asterisk = false;
circle = false;
reminder = null;
abs = true;
mus = false;
tag = false;
not = false;
}
public static void SetupReminders()
{
try
{
DeleteReminder(App.Instance.StaticServiceData.NotificationList);
foreach (var item in App.Instance.StaticServiceData.NotificationList)
{
string reminderName = item.Name;
var beginTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
item.Time.Hour, item.Time.Minute, item.Time.Second);
var reminder = ScheduledActionService.Find(reminderName);
reminder = new Reminder(reminderName)
{
// // NOTE: setting the Title property is supported for reminders
// // in contrast to alarms where setting the Title property is not supported
Title = string.Format("{0} {1}\n{2}", AppResources.ReminderForUser, item.ModifiedUser.UserName, item.Name),
Content = item.Description ?? "",
// //double.TryParse(this.txtSeconds.Text, out seconds);
// //NOTE: the value of BeginTime must be after the current time
// //set the BeginTime time property in order to specify when the reminder should be shown
BeginTime = beginTime,
//BeginTime = DateTime.Now.AddMinutes(1),
// // NOTE: ExpirationTime must be after BeginTime
// // the value of the ExpirationTime property specifies when the schedule of the reminder expires
// // very useful for recurring reminders, ex:
// // show reminder every day at 5PM but stop after 10 days from now
ExpirationTime = beginTime.AddDays(1).AddDays(7),
RecurrenceType = RecurrenceInterval.Daily
};
// NOTE: another difference from alerts
// you can set a navigation uri that is passed to the application when it is launched from the reminder
//reminder.NavigationUri = navigationUri;
ScheduledActionService.Add(reminder);
}
}
catch (Exception)
{
throw;
}
}
public DiaryEntry(DateTime date, TimeOfDay time, DateTime selected, String text, bool underline, bool asterisk, bool circle, Reminder reminder, bool abs, bool mus, bool not, bool tag)
{
Date = date;
this.time = time;
this.timeSelected = selected;
Text = text;
Underline = underline;
Asterisk = asterisk;
Circle = circle;
this.reminder = reminder;
reminder.Entry = this;
Abs = abs;
Mus = mus;
Not = not;
Tag = tag;
}
public static string FormatDueOnText(Reminder reminder)
{
var msg = reminder.DueDate == null
? string.Empty
: String.Format("on {0:d}", reminder.DueDate);
msg += reminder.DueDate == null || reminder.DueDistance == null
? string.Empty
: " or ";
msg += reminder.DueDistance == null
? string.Empty
: String.Format("at {0}", UserDisplayPreferencesHelper.FormatDistanceWithAbbreviation(reminder.DueDistance.Value));
msg += ".";
return msg;
}
private void StartButton_Click(object sender, RoutedEventArgs e)
{
System.Diagnostics.Debug.WriteLine("Starting at " + DateTime.Now.Ticks);
startTime = DateTime.Now;
Reminder reminder = new Reminder(Guid.NewGuid().ToString());
reminder.BeginTime = startTime.AddMinutes(TimeSlider.Value);
reminder.RecurrenceType = RecurrenceInterval.None;
reminder.Content = "Time's up for task " + TaskNameBox.Text;
ScheduledActionService.Add(reminder);
MessageBox.Show("Start task " + TaskNameBox.Text);
TaskNameBox.Text = "";
}
public void Schedule()
{
foreach (var action in ScheduledActionService.GetActions<Reminder>())
ScheduledActionService.Remove(action.Name);
foreach (var lembrete in _lembretes.Where(lem => lem.Inicio > DateTime.Now))
{
var periodicTask = ScheduledActionService.Find(lembrete.LembreteName) as Reminder;
try
{
if (periodicTask != null)
ScheduledActionService.Remove(lembrete.LembreteName);
periodicTask = new Reminder(lembrete.LembreteName)
{
Title = "Meu Ponto",
Content = lembrete.Mensagem,
BeginTime = lembrete.Inicio,
ExpirationTime = lembrete.Fim,
RecurrenceType = RecurrenceInterval.None
};
ScheduledActionService.Add(periodicTask);
}
catch (InvalidOperationException exception)
{
if (exception.Message.Contains("BNS Error: The action is disabled"))
{
MessageBox.Show("Background agents for this application have been disabled by the user.");
}
if (exception.Message.Contains("BNS Error: The maximum number of ScheduledActions of this type have already been added."))
{
// No user action required. The system prompts the user when the hard limit of periodic tasks has been reached.
}
}
catch (SchedulerServiceException ex)
{
// No user action required.
MessageBox.Show(ex.Message);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public static JsonReminderViewModel ToJsonReminderViewModel(Reminder reminder, VehicleModel vehicle)
{
return new JsonReminderViewModel
{
VehicleName = vehicle.Name,
ReminderId = reminder.ReminderId,
VehicleId = vehicle.VehicleId,
Title = reminder.Title,
Remarks = reminder.Remarks,
DueDate = reminder.DueDate.HasValue
? String.Format("{0:d MMM yyyy}", reminder.DueDate)
: null,
DueDistance = reminder.DueDistance,
IsOverdue = reminder.IsOverdue ?? false,
IsFulfilled = reminder.IsFulfilled,
};
}
public async Task <IActionResult> Post([FromBody] Reminder reminder)
{
if (reminder == null)
{
ModelState.AddModelError("", "Model doesn't exist");
}
try
{
await db.Reminders.AddAsync(reminder);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
await db.SaveChangesAsync();
return(CreatedAtAction("ReminderPost", reminder));
}
private void CreateEvent()
{
var start = new DateTime(StartDate.Year, StartDate.Month, StartDate.Day, StartTime.Hour, StartTime.Minute, 0, DateTimeKind.Local);
if (_reminder != null)
{
if (_reminder.BeginTime != start)
{
ScheduledActionService.Remove(_item.ReminderName);
}
else
{
return;
}
}
else
{
_item.ReminderName = FindFreeTask();
}
if (string.IsNullOrEmpty(_item.ReminderName))
{
MessageBox.Show("More than 100 reminders established. Adding a new abolished.");
}
else if (start > DateTime.Now)
{
var r = new Reminder(_item.ReminderName)
{
Content = _description,
BeginTime = start,
Title = NameEvent
};
ScheduledActionService.Add(r);
}
else
{
MessageBox.Show("Wrong start time");
}
App.Current.ListItems.Save();
}
public async Task RemoveReminder(CommandContext ctx, string reminderId)
{
if (ctx.Member.GetRole().IsCHOrHigher())
{
await ctx.TriggerTypingAsync();
// Cancels:
if (!ReminderSystem.IsReminder(reminderId))
{
await ctx.Channel.SendMessageAsync(
ChatObjects.GetErrMessage(@"That is not a valid Reminder ID..."));
return;
}
Reminder reminderToRemove = ReminderSystem.GetReminderFromId(reminderId);
// DEB!
DiscordEmbedBuilder deb = new DiscordEmbedBuilder();
DateTimeOffset dto = DateTimeOffset.FromUnixTimeMilliseconds(reminderToRemove.Time); // The reminder's DTO.
TimeSpan remainingTime = dto.Subtract(DateTimeOffset.UtcNow); // The remaining time left for the reminder.
string originalAuthorMention = String.Format("<@{0}>", reminderToRemove.User);
deb.WithTitle(@"Notification Removed");
deb.AddField(@"User", originalAuthorMention);
deb.AddField(@"Time", dto.ToString());
deb.AddField(@"Remaining time",
String.Format("{0}day {1}hr {2}min {3}sec", remainingTime.Days, remainingTime.Hours, remainingTime.Minutes, remainingTime.Seconds));
deb.AddField(@"Message", reminderToRemove.Text);
deb.AddField(@"Notification Identifier", reminderId);
deb.WithColor(DiscordColor.LightGray);
deb.WithThumbnailUrl(ChatObjects.URL_REMINDER_DELETED);
ReminderSystem.RemoveReminder(reminderToRemove);
ReminderSystem.Save();
await ctx.Channel.SendMessageAsync(originalAuthorMention, false, deb);
}
}
public async Task RemoveReminderAsync(int id)
{
User localUser = DatabaseHandler.GetFromDb(Context.User);
Reminder localReminder = DatabaseHandler.GetFromDb(new Reminder()
{
Id = id
}, localUser);
switch (DatabaseHandler.RemoveFromDb(localReminder))
{
case DatabaseHandler.Result.Successful:
await ReplyAsync(Message.Info.SuccessfullyRemoved(new Reminder()));
break;
default:
await ReplyAsync(Message.Error.Generic);
break;
}
}
private async Task <bool> TryAnnounceReminderAsync(Reminder reminder)
{
try
{
var channel = GetChannel(reminder.ChannelId);
if (channel == null)
{
// could not find channel - deleted?
return(true);
}
await channel.SendMessageAsync($"<@{reminder.UserId}> Remember! {reminder.Message}");
}
catch
{
return(false);
}
return(true);
}
public ActionResult ReminderPreview(ReminderJSON reminder)
{
var template = db.fees_templates.SingleOrDefault(x => x.id == reminder.templateid);
if (template == null)
{
return(SendJsonErrorResponse("Template not found"));
}
var viewmodel = new Reminder();
viewmodel.Initialise(reminder);
var liquid = new LiquidTemplate(template.body);
liquid.AddParameters("reminder", viewmodel);
var view = liquid.Render();
return(Json(view.ToJsonOKData()));
}
private string GetFormattedOccuranceType(Reminder reminder)
{
OccuranceType occurance = reminder.FindOccuranceType();
if (occurance == OccuranceType.BEFORE_MONTH)
{
return(" will get");
}
else if (occurance == OccuranceType.BEFORE_WEEK)
{
return(" will get");
}
else if (occurance == OccuranceType.LAST_DAY)
{
return("has");
}
else
{
return(string.Empty);
}
}
public void StartReminder(Reminder r)
{
var time = r.When - DateTime.UtcNow;
if (time.TotalMilliseconds > int.MaxValue)
{
return;
}
if (time.TotalMilliseconds < 0)
{
time = TimeSpan.FromSeconds(5);
}
var remT = new Timer(ReminderTimerAction, r, (int)time.TotalMilliseconds, Timeout.Infinite);
if (!Reminders.TryAdd(r.Id, remT))
{
remT.Change(Timeout.Infinite, Timeout.Infinite);
}
}
public async Task CheckReminder(Reminder reminder)
{
if (client == null)
{
return;
}
// Set the item as completed and update it in the table
reminder.Complete = true;
try {
await reminderTable.UpdateAsync(reminder); // update the new item in the local database
await SyncAsync(); // send changes to the mobile service
if (reminder.Complete)
{
adapter.Remove(reminder);
}
} catch (Exception e) {
CreateAndShowDialog(e, "Error");
}
}
/// <summary>
/// Serialization
/// </summary>
private void SerializeMethod(object parameter)
{
Reminder login = new Reminder();
//creating a BF object to serialize our object
BinaryFormatter bf = new BinaryFormatter();
FileStream fsout = new FileStream("credentials.binary", FileMode.Create, FileAccess.Write, FileShare.None);
try
{
using (fsout)
{
bf.Serialize(fsout, login);
MessageBox.Show("Serialization successful!");
}
}
catch
{
MessageBox.Show("An error has occured.");
}
}
public static string CheckTime(SocketGuild guild)
{
string message = "";
Reminder reminder = GetFirstReminder();
if (reminder != null)
{
DateTime currentTime = DateTime.UtcNow;
DateTime savedTime = Convert.ToDateTime(reminder.TimeToTrigger);
if (savedTime <= currentTime)
{
DeleteFirstReminder();
SocketGuildUser user = guild.Users.FirstOrDefault(u => u.Username == reminder.User);
message = $"{user.Mention} you are being reminded about the message: {reminder.Message}";
}
}
return(message);
}
public void Dalete(CallbackQuery _message, DataBaseContext baseContext)
{
TempDate tempDate = baseContext._TempDate.Where(p => p.user.ID == _message.From.Id).FirstOrDefault();
Reminder reminder = baseContext._Reminders.Where(p => p.user.ID == _message.From.Id).FirstOrDefault(p => p.Work == true);
foreach (EventTime eventTime in baseContext._EventTimes.Include("reminder"))
{
if (eventTime.reminder != null)
{
if (eventTime.reminder.ID == reminder.ID)
{
if (eventTime.dateTime.Date == tempDate.date.Date)
{
baseContext._EventTimes.Remove(eventTime);
}
}
}
}
baseContext._Reminders.Remove(reminder);
baseContext.SaveChanges();
}
public async Task AddReminderShouldReturnReminder()
{
Reminder reminder = new Reminder {
NewsId = 102, Schedule = DateTime.Now.AddDays(1)
};
Reminder addedReminder = new Reminder {
ReminderId = 2, NewsId = 102, Schedule = DateTime.Now.AddDays(1)
};
Reminder _reminder = null;
var mockRepo = new Mock <IReminderRepository>();
mockRepo.Setup(repo => repo.GetReminderByNewsId(reminder.NewsId)).Returns(Task.FromResult(_reminder));
mockRepo.Setup(repo => repo.AddReminder(reminder)).Returns(Task.FromResult(addedReminder));
var service = new ReminderService(mockRepo.Object);
var actual = await service.AddReminder(reminder);
Assert.NotNull(actual);
Assert.IsAssignableFrom <Reminder>(actual);
Assert.Equal(2, actual.ReminderId);
}
public async Task CreateReminderAsync(ulong userId, ulong guildId, string message, TimeSpan duration)
{
var reminder = new Reminder
{
UserId = userId,
GuildId = guildId,
Message = message,
TimeInvoked = DateTime.Now,
Duration = duration
};
_hiromiContext.Add(reminder);
await _hiromiContext.SaveChangesAsync();
var timer = new Timer(async _ => await HandleReminderCallbackAsync(reminder),
null,
reminder.Duration,
Timeout.InfiniteTimeSpan);
_reminders.TryAdd(reminder.Id, timer);
}
public static List <string> GetShopItems(SysBattleShopVo shopVo)
{
List <string> list = null;
if (shopVo == null)
{
Reminder.ReminderStr("根据ID未获取到商店信息SHopID===>" + shopVo);
}
else if (shopVo.items == null)
{
Reminder.ReminderStr("商店数据为空");
}
else
{
list = new List <string>(shopVo.items.Split(new char[]
{
','
}));
}
return((list == null) ? new List <string>() : list);
}
/// <summary>
/// Attempts to find the reminder whose activation date matches the passed date in this object's commandString
/// </summary>
/// <returns>the found reminder, which may be null if an reminder wasn't found</returns>
private Reminder GetReminderForClosestMatchToPassedDate()
{
List <Reminder> reminders = StoredProcedures.QueryAllUnexpiredReminders();
// get the date from the command text
var now = DateTime.Now;
// putting in the datetime to start at midnight of this day so that times don't get shifted around. I know it's marked as only used for tests, but it's what I had to do
DateTime commandDateTime = DateTimeParser.ParseDateTimeFromText(this.CommandString, new DateTime(now.Year, now.Month, now.Day, 0, 0, 0));
Reminder foundReminder = null;
// if there's only one reminder, that's the one we're getting
if (reminders.Count == 1)
{
foundReminder = reminders[0];
}
else
{
// find the first reminder whose hour and minute matches the command date time
foundReminder = reminders.Find(reminder => reminder.ActivateDateAndTime.Hour == commandDateTime.Hour && reminder.ActivateDateAndTime.Minute == commandDateTime.Minute);
}
return(foundReminder);
}
/// <summary>
/// Permanentely deletes a single reminder from the database
/// </summary>
/// <param name="rem">The reminder you wish to remove</param>
public static void PermanentelyDeleteReminder(Reminder rem)
{
using (RemindMeDbEntities db = new RemindMeDbEntities())
{
db.Reminder.Attach(rem);
db.Reminder.Remove(rem);
//Remove attached foreign properties
DLLocalDatabase.AVRProperty.DeleteAvrFilesFoldersById(rem.Id);
DLLocalDatabase.AVRProperty.DeleteAvrProperties(rem.Id);
DLLocalDatabase.HttpRequest.DeleteHttpRequestByReminderId(rem.Id);
if (rem.HttpId != null)
{
DLLocalDatabase.HttpRequestConditions.DeleteConditionsForHttpRequest((long)rem.HttpId);
}
SaveAndCloseDataBase(db);
}
}
private async Task <Reminder> NewReminderAsync()
{
Reminder createdReminder = await this.CreateReminderAsync();
// if the reminder is null, then don't do anything
if (createdReminder != null)
{
// insert the reminder into the database
StoredProcedures.CreateReminder(createdReminder.Title, createdReminder.ActivateDateAndTime, createdReminder.Description);
// schedule a toast notification for the reminder
AlarmAndReminderHelper.ScheduleReminder(StoredProcedures.QueryLatestReminder());
string mainPart = $"Alright, reminder set for ";
string datePart = createdReminder.ActivateDateAndTime.ToString("MMM d");
string timePart = createdReminder.ActivateDateAndTime.ToString("h:mm tt");
string rawSSML = new SSMLBuilder().Add(mainPart).SayAs(datePart, SSMLBuilder.SayAsTypes.DATE).Add(" at ").SayAs(timePart, SSMLBuilder.SayAsTypes.TIME).BuildWithoutWrapperElement();
string prosodySSML = new SSMLBuilder().Prosody(rawSSML, pitch: "+5%", contour: "(10%,+5%) (50%,-5%) (80%,-5%)").Build();
TextToSpeechEngine.SpeakInflectedText(this.MediaElement, prosodySSML);
}
return(createdReminder);
}
public async Task AddOrUpdateReminderShouldSuccess()
{
string userId = "Sam";
int newsId = 101;
Reminder reminder = new Reminder {
Schedule = DateTime.Now.AddDays(2)
};
News mockNews = new News {
NewsId = 101, Title = "chandrayaan2-spacecraft"
};
var mockRepo = new Mock <INewsRepository>();
mockRepo.Setup(repo => repo.GetNewsById(userId, newsId)).Returns(Task.FromResult(mockNews));
mockRepo.Setup(repo => repo.AddOrUpdateReminder(userId, newsId, reminder)).Returns(Task.FromResult(true));
var service = new NewsService.Services.NewsService(mockRepo.Object);
var actual = await service.AddOrUpdateReminder(userId, newsId, reminder);
Assert.True(actual);
}
public void DeleteAssociation(int reminderID, int refID, ReferenceType refType)
{
try
{
LoginUser loginUser = TSAuthentication.GetLoginUser();
TaskAssociations associations = new TaskAssociations(loginUser);
associations.DeleteAssociation(reminderID, refID, refType);
string description = String.Format("{0} deleted task association to {1} ", TSAuthentication.GetUser(loginUser).FirstLastName, Enum.GetName(typeof(ReferenceType), refType));
TaskLogs.AddTaskLog(loginUser, reminderID, description);
Reminder task = Reminders.GetReminder(loginUser, reminderID);
if (task.UserID != null && loginUser.UserID != task.UserID)
{
SendModifiedNotification(loginUser.UserID, task.ReminderID);
}
}
catch (Exception ex)
{
DataUtils.LogException(UserSession.LoginUser, ex);
}
}
public ActionResult ReminderPage(Reminder reminder)
{
if (ModelState.IsValid)
{
WebMail.Send(reminder.Email
, "HPTuningInc - Reminder Service Due",
"Hi, This Is Just A Reminder To Let You Know That You Are Due For Service" + "<br />" + "<a href=\"http://localhost:40592/Appointment/Create\">Click Here To Make A Appointment</a>"
, null
, null
, null
, true
, null
, null
, null
, null
, null
, reminder.Email);
return(RedirectToAction("SendConfirm"));
}
return(View());
}
[Route("/api/news/{newsId}/reminder")]//api/news/userId/newsId/reminder
public async Task <IActionResult> Post(int newsId, [FromBody] Reminder reminder)
{
try
{
var userId = User.Claims.Where(x => x.Type == "userId").FirstOrDefault().Value;
return(Created("", await _newsService.AddOrUpdateReminder(userId, newsId, reminder)));
}
catch (NoNewsFoundException nnf)
{
return(NotFound(nnf.Message));
}
catch (NewsAlreadyExistsException nnf)
{
return(Conflict(nnf.Message));
}
catch (System.Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public Reminder CreateReminder(Reminder reminder)
{
try
{
var result = reminderRepository.CreateReminder(reminder);
if (result == null)
{
throw new ReminderNotCreatedException("This reminder already exists");
}
return(result);
}
catch (ReminderNotCreatedException)
{
throw;
}
catch (Exception)
{
throw;
}
}
public bool UpdateReminder(int reminderId, Reminder reminder)
{
try
{
var result = reminderRepository.UpdateReminder(reminderId, reminder);
if (!result)
{
throw new ReminderNotFoundException("This reminder id not found");
}
return(result);
}
catch (ReminderNotFoundException)
{
throw;
}
catch (Exception)
{
throw;
}
}
public string GetEmailSubject(Reminder reminder)
{
OccuranceType occurance = reminder.FindOccuranceType();
if (occurance == OccuranceType.BEFORE_MONTH)
{
return(" in a month");
}
else if (occurance == OccuranceType.BEFORE_WEEK)
{
return(" in a week");
}
else if (occurance == OccuranceType.LAST_DAY)
{
return("today");
}
else
{
return(string.Empty);
}
}
public int AddReminder(Reminder reminder)
{
int result = 0;
try
{
string sql = "INSERT INTO t_tixing(Id,Time,Info)values(@Id,@Time,@Info)";
SQLiteParameter[] parameters = new SQLiteParameter[] {
new SQLiteParameter("@Id", reminder.ReminderId),
new SQLiteParameter("@Time", reminder.ReminderTime.ToString("yyyy-MM-dd HH:mm:ss")),
new SQLiteParameter("@Info", reminder.ReminderInfo)
};
SqlAction action = new SqlAction();
result = action.IntQuery(sql, parameters);
}
catch
{
}
return(result);
}
public Task <Reminder> AddNewPasswordReminderAsync(Reminder reminder)
{
return(Task.Factory.StartNew(() =>
{
if (ValidationService.Instance().Password(reminder.ReminderPassword))
{
if (PasswordsData.Instance().AddReminderPassword(reminder) > 0)
{
return reminder;
}
else
{
return null;
}
}
else
{
return null;
}
}));
}
public async Task <IActionResult> Post([FromBody] Reminder reminder)
{
try
{
var result = await _reminderService.CreateReminder(reminder.UserId, reminder.Email, reminder.NewsReminders[0]);
return(Created("", result));
}
catch (NoReminderFoundException nnf)
{
return(NotFound(nnf.Message));
}
catch (ReminderAlreadyExistsException nnf)
{
return(Conflict(nnf.Message));
}
catch (System.Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
/// <summary>
/// Delete reminder
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <int> DeleteReminder(string id)
{
try
{
Reminder reminder = await _context.Reminders.FindAsync(id);
if (reminder == null)
{
return(NOT_FOUND);
}
_context.Reminders.Remove(reminder);
await _context.SaveChangesAsync();
return(OK);
}
catch
{
return(SERVER_ERROR);
}
}
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)));
}
