async void DoneEdit(object ender, EventArgs e)
{
string tobool = status_picker.SelectedItem.ToString();
bool val = Boolean.Parse(tobool);
SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation);
conn.Query <Reminders>("select * from Reminders where id=?", tempid);
Reminders reminders = new Reminders()
{
id = tempid,
Title = name_entry.Text,
Description = description_entry.Text,
Priority = priority_picker.SelectedItem.ToString(),
Date = datePicker.Date + timePicker.Time,
isActivated = val
};
conn.Update(reminders);
conn.Close();
await DisplayAlert("Success", "Pet reminder saved", "Ok");
await Navigation.PopToRootAsync();
}
private async void AddReminderExecute(object o)
{
LoaderManager.Instance.ShowLoader();
await Task.Run(() =>
{
Reminder reminder;
int hourNow = DateTime.Now.Hour;
var today = DateTime.Today.Date;
if (hourNow != 23)
{
reminder = new Reminder(today, hourNow + 1, DateTime.Now.Minute, "",
StationManager.CurrentUser);
}
else
{
reminder = new Reminder(today.AddDays(1), 00, DateTime.Now.Minute, "",
StationManager.CurrentUser);
}
Reminders.Add(reminder);
SelectedReminder = reminder;
DBManager.AddReminder(reminder);
RunReminderExecute(reminder.Guid);
return(true);
});
LoaderManager.Instance.HideLoader();
OnPropertyChanged();
Logger.Log("Created new reminder");
}
public void DeleteReminder(Reminders reminder)
{
realm.Write(() =>
{
realm.Remove(reminder);
});
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
try
{
Reminders reminder = new Reminders();
reminder.note = listMed.Text;
reminder.dateStart = DateTime.Parse(dateStart_box.Text);
reminder.dateFinish = DateTime.Parse(dateFinish_box.Text);
reminder.time = DateTime.Parse(time_box.Text);
reminder.UserId = MainClass.ID;
using (DBToHealth db = new DBToHealth())
{
db.Reminders.Add(reminder);
db.SaveChanges();
}
MessageBox.Show("Напоминание сохранено!");
MainClass.MW.frame.NavigationService.Navigate(new Uri("Pages/Therapy.xaml", UriKind.Relative));
}
catch (Exception ex) { MessageBox.Show(ex.Message); }
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
return(obj is InvoicePaymentRequest other &&
((Uid == null && other.Uid == null) || (Uid?.Equals(other.Uid) == true)) &&
((RequestMethod == null && other.RequestMethod == null) || (RequestMethod?.Equals(other.RequestMethod) == true)) &&
((RequestType == null && other.RequestType == null) || (RequestType?.Equals(other.RequestType) == true)) &&
((DueDate == null && other.DueDate == null) || (DueDate?.Equals(other.DueDate) == true)) &&
((FixedAmountRequestedMoney == null && other.FixedAmountRequestedMoney == null) || (FixedAmountRequestedMoney?.Equals(other.FixedAmountRequestedMoney) == true)) &&
((PercentageRequested == null && other.PercentageRequested == null) || (PercentageRequested?.Equals(other.PercentageRequested) == true)) &&
((TippingEnabled == null && other.TippingEnabled == null) || (TippingEnabled?.Equals(other.TippingEnabled) == true)) &&
((AutomaticPaymentSource == null && other.AutomaticPaymentSource == null) || (AutomaticPaymentSource?.Equals(other.AutomaticPaymentSource) == true)) &&
((CardId == null && other.CardId == null) || (CardId?.Equals(other.CardId) == true)) &&
((Reminders == null && other.Reminders == null) || (Reminders?.Equals(other.Reminders) == true)) &&
((ComputedAmountMoney == null && other.ComputedAmountMoney == null) || (ComputedAmountMoney?.Equals(other.ComputedAmountMoney) == true)) &&
((TotalCompletedAmountMoney == null && other.TotalCompletedAmountMoney == null) || (TotalCompletedAmountMoney?.Equals(other.TotalCompletedAmountMoney) == true)) &&
((RoundingAdjustmentIncludedMoney == null && other.RoundingAdjustmentIncludedMoney == null) || (RoundingAdjustmentIncludedMoney?.Equals(other.RoundingAdjustmentIncludedMoney) == true)));
}
public async Task <ActionResult <object> > UpdateAssetsAsync(
Guid subscriptionId,
int buildId,
string sourceSha,
List <Asset> assets)
{
(InProgressPullRequest pr, bool canUpdate) = await SynchronizeInProgressPullRequestAsync();
var updateParameter = new UpdateAssetsParameters
{
SubscriptionId = subscriptionId,
BuildId = buildId,
SourceSha = sourceSha,
Assets = assets
};
if (pr != null && !canUpdate)
{
await StateManager.AddOrUpdateStateAsync(
PullRequestUpdate,
new List <UpdateAssetsParameters> {
updateParameter
},
(n, old) =>
{
old.Add(updateParameter);
return(old);
});
await Reminders.TryRegisterReminderAsync(
PullRequestUpdate,
Array.Empty <byte>(),
TimeSpan.FromMinutes(5),
TimeSpan.FromMinutes(5));
return(ActionResult.Create <object>(
null,
$"Current Pull request '{pr.Url}' cannot be updated, update queued."));
}
if (pr != null)
{
await UpdatePullRequestAsync(pr, new List <UpdateAssetsParameters> {
updateParameter
});
return(ActionResult.Create <object>(null, $"Pull Request '{pr.Url}' updated."));
}
string prUrl = await CreatePullRequestAsync(new List <UpdateAssetsParameters> {
updateParameter
});
if (prUrl == null)
{
return(ActionResult.Create <object>(null, "Updates require no changes, no pull request created."));
}
return(ActionResult.Create <object>(null, $"Pull request '{prUrl}' created."));
}
/// <summary>
/// Synchronizes an in progress pull request.
/// This will update current state if the pull request has been manually closed or merged.
/// This will evaluate merge policies on an in progress pull request and merge the pull request if policies allow.
/// </summary>
/// <returns>
/// A <see cref="ValueTuple{InProgressPullRequest, bool}" /> containing:
/// The current open pull request if one exists, and
/// <see langword="true" /> if the open pull request can be updated; <see langword="false" /> otherwise.
/// </returns>
public virtual async Task <(InProgressPullRequest pr, bool canUpdate)> SynchronizeInProgressPullRequestAsync()
{
ConditionalValue <InProgressPullRequest> maybePr =
await StateManager.TryGetStateAsync <InProgressPullRequest>(PullRequest);
if (maybePr.HasValue)
{
InProgressPullRequest pr = maybePr.Value;
if (string.IsNullOrEmpty(pr.Url))
{
// somehow a bad PR got in the collection, remove it
await StateManager.RemoveStateAsync(PullRequest);
return(null, false);
}
bool?result = await ActionRunner.ExecuteAction(() => SynchronizePullRequestAsync(pr.Url));
if (result == true)
{
return(pr, true);
}
if (result == false)
{
return(pr, false);
}
}
await Reminders.TryUnregisterReminderAsync(PullRequestCheck);
return(null, false);
}
public ReminderProxy[] GetItemReminders(ReferenceType refType, int refID, int?userID)
{
Reminders reminders = new Reminders(TSAuthentication.GetLoginUser());
reminders.LoadByItemAll(refType, refID, userID);
return(reminders.GetReminderProxies());
}
async void Done(object ender, EventArgs e)
{
Reminders reminders = new Reminders()
{
Title = reminder_entry.Text,
Description = description_entry.Text,
Priority = priority_picker.SelectedItem.ToString(),
Date = datePicker.Date + timePicker.Time,
isActivated = true
};
SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation);
conn.CreateTable <Reminders>();
int rows = conn.Insert(reminders);
conn.Close();
if (rows > 0)
{
await DisplayAlert("Success", "You have added a reminder", "Ok");
}
else
{
await DisplayAlert("Failure", "Your reminder was not added", "OK");
}
await Navigation.PopToRootAsync();
}
public ReminderProxy[] GetUserReminders(int userID)
{
Reminders reminders = new Reminders(TSAuthentication.GetLoginUser());
reminders.LoadByUser(userID);
return(reminders.GetReminderProxies());
}
protected internal override void Define()
{
On((HasBeenReminded x) => reminded);
On((SetReminder x) => Reminders.Register("test", TimeSpan.Zero, x.Period));
On((GetInstanceHashcode x) => RuntimeHelpers.GetHashCode(this));
On((Deactivate x) => Activation.DeactivateOnIdle());
}
public async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Reminders.Clear();
if (MongoRepo.LoggedUser != null)
{
var pills = await MongoRepo.GetAllRemindersAsync(MongoRepo.LoggedUser.Username);
foreach (var pill in pills)
{
Reminders.Add(pill);
}
}
else
{
await Application.Current.MainPage.DisplayAlert("Reminders", "You should login to see reminders!", "OK");
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
private static Notification CreateNotification(ESignEnvelopeInfo envelope)
{
var reminder = new Reminders();
if (envelope.SendReminders != false)
{
reminder = new Reminders
{
ReminderDelay = envelope.FirstReminderDay.ToString(),
ReminderFrequency = envelope.ReminderFrequency.ToString(),
ReminderEnabled = true.ToString()
};
}
return(new Notification
{
UseAccountDefaults = false.ToString(),
Reminders = reminder,
Expirations = new Expirations
{
ExpireAfter = envelope.ExpiredDays.ToString(),
ExpireWarn = envelope.WarnDays.ToString(),
ExpireEnabled = true.ToString()
}
});
}
public IHttpActionResult PutReminders(int id, Reminders reminders)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != reminders.Id)
{
return(BadRequest());
}
db.Entry(reminders).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RemindersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void DeleteTask(int taskID)
{
Task task = Tasks.GetTask(UserSession.LoginUser, taskID);
if (task.CreatorID != UserSession.CurrentUser.UserID && !UserSession.CurrentUser.IsSystemAdmin)
{
return;
}
TaskAssociations associations = new TaskAssociations(UserSession.LoginUser);
associations.DeleteByReminderIDOnly(taskID);
Tasks subtasks = new Tasks(UserSession.LoginUser);
subtasks.LoadIncompleteByParentID(taskID);
foreach (Task subtask in subtasks)
{
DeleteTask(subtask.TaskID);
}
if (task.ReminderID != null)
{
Data.Reminder reminder = Reminders.GetReminder(UserSession.LoginUser, (int)task.ReminderID);
reminder.Delete();
reminder.Collection.Save();
}
string description = String.Format("{0} deleted task {1} ", UserSession.CurrentUser.FirstLastName, task.Description);
ActionLogs.AddActionLog(UserSession.LoginUser, ActionLogType.Delete, ReferenceType.Tasks, taskID, description);
task.Delete();
task.Collection.Save();
}
private Reminder CreateReminder(LoginUser loginUser, int taskID, string taskName, DateTime reminderDate, bool isDismissed, int userID)
{
Reminders reminderHelper = new Reminders(loginUser);
Reminder reminder = reminderHelper.AddNewReminder();
reminder.DateCreated = DateTime.UtcNow;
reminder.Description = taskName;
DateTime reminderDueDate = DateTime.Now;
if (reminderDate != null)
{
reminderDueDate = (DateTime)reminderDate;
}
reminder.DueDate = reminderDueDate;
reminder.IsDismissed = isDismissed;
reminder.RefType = ReferenceType.Tasks;
reminder.RefID = taskID;
reminder.HasEmailSent = false;
reminder.UserID = userID;
reminder.CreatorID = loginUser.UserID;
reminder.OrganizationID = loginUser.OrganizationID;
reminderHelper.Save();
return(reminder);
}
// Token: 0x06001659 RID: 5721 RVA: 0x0007DEAC File Offset: 0x0007C0AC
protected override void OnObjectModified(IMapiEvent mapiEvent, IMailboxSession itemStore, IStoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "ToDoModernReminderProcessor.OnObjectModified");
if (item != null)
{
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "ToDoModernReminderProcessor.OnObjectModified - item exists");
IToDoItem toDoItem = (IToDoItem)item;
Reminders <ModernReminder> reminders = toDoItem.ModernReminders;
if (reminders != null)
{
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "ToDoModernReminderProcessor.OnObjectModified - Reminders exist -> schedule reminder");
int numRemindersScheduled = 0;
customDataToLog.Add(new KeyValuePair <string, object>("ToDoRemSchd.Latency", base.ExecuteAndMeasure(delegate
{
numRemindersScheduled = this.ReminderMessageManager.ScheduleReminder(itemStore, toDoItem, reminders);
}).ToString()));
customDataToLog.Add(new KeyValuePair <string, object>("ToDoRemSchd.Count", numRemindersScheduled));
return;
}
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "ToDoModernReminderProcessor.OnObjectModified - Modern reminders don't exist -> clearing the reminder");
customDataToLog.Add(new KeyValuePair <string, object>("ToDoRemClr.Latency", base.ExecuteAndMeasure(delegate
{
this.ReminderMessageManager.ClearReminder(itemStore, toDoItem);
}).ToString()));
}
}
public void TabSelectedChanged(int index)
{
if (TabIndex != index)
{
_searchtext = null;
RaisePropertyChanged("SearchText");
}
TabIndex = index;
if (!IsLoading)
{
if (AllReminders != null && AllReminders.Any())
{
if (index == 0) // show only active reminders
{
Reminders = new ObservableCollection <RemindersModel>(AllReminders.Where((arg) => !arg.Reminder.DoneAt.HasValue));
}
else // Show terminated reminders
{
Reminders = new ObservableCollection <RemindersModel>(AllReminders.Where((arg) => arg.Reminder.DoneAt.HasValue));
}
}
}
if (Reminders != null)
{
IsEmpty = !Reminders.Any();
}
else
{
IsEmpty = true;
}
}
async Task ExecuteLoadRemindersCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Reminders.Clear();
var parameters = new Dictionary <Constants.Parameter, object>();
parameters[Constants.Parameter.ReminderListId] = ReminderList.Id;
var reminders = await ReminderDataStore.GetModelsAsync(true, parameters);
reminders = reminders.OrderBy(r => r.Completed).ThenByDescending(r => r.DueDate);
foreach (var reminder in reminders)
{
Reminders.Add(reminder);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async Task ScheduleReminders()
{
if (Device.RuntimePlatform == Device.iOS)
{
DependencyService.Get <ICancelNotification>()?.CancelAll();
}
else
{
await Notifications.CancelAll();
}
foreach (var reminder in Reminders)
{
var time = (reminder.Time);
if (reminder.IsActive)
{
DateTime startDate = DateTime.Now.Date;
DateTime endDate = DateTime.Now.AddMonths(1);
startDate = startDate + time;
for (int i = 0; i < endDate.Date.Subtract(startDate.Date).Days; i++)
{
DateTime item = startDate.AddDays(i);
bool isMonday = reminder.Monday.IsEnabled && item.DayOfWeek == reminder.Monday.Day;
bool isTuesday = reminder.Tuesday.IsEnabled && item.DayOfWeek == reminder.Tuesday.Day;
bool isWednesday = reminder.Wednesday.IsEnabled && item.DayOfWeek == reminder.Wednesday.Day;
bool isThursday = reminder.Thursday.IsEnabled && item.DayOfWeek == reminder.Thursday.Day;
bool isFriday = reminder.Friday.IsEnabled && item.DayOfWeek == reminder.Friday.Day;
bool isSaturday = reminder.Saturday.IsEnabled && item.DayOfWeek == reminder.Saturday.Day;
bool isSunday = reminder.Sunday.IsEnabled && item.DayOfWeek == reminder.Sunday.Day;
if (isMonday || isTuesday || isWednesday || isThursday || isFriday || isSaturday || isSunday)
{
if (item.CompareTo(DateTime.Now) > 0)
{
var notification = new Notification()
{
Id = GetUniqueID(item, Reminders.IndexOf(reminder)), Title = AppResources.NotificationHeader, Message = AppResources.NotificationContent, Date = item, Sound = "notification", Vibrate = false
};
if (Device.RuntimePlatform == Device.iOS)
{
notification.Sound = "notification.caf";
}
else
{
notification.When = TimeSpan.FromTicks(item.Subtract(DateTime.Now).Ticks);
}
await Notifications.Send(notification);
}
}
}
}
}
}
protected async override void ViewIsDisappearing(object sender, EventArgs e)
{
await ScheduleReminders();
Settings.ReminderStorage = JsonConvert.SerializeObject(Reminders.ToList());
base.ViewIsDisappearing(sender, e);
}
private void CompleteC(object obj)
{
int id = int.Parse(obj.ToString());
this.reminderService.SetCompleted(id);
Reminders.Remove(Reminders.Where(x => x.Id == id).FirstOrDefault());
NotifyRemindersChanged();
}
public RemindersPage(AppUser user, Reminders reminders)
{
InitializeComponent();
User = user;
Reminder = reminders;
this.BindingContext = new RemindersViewModel(User, Reminder);
SendButton.IsEnabled = false;
IsNew = false;
}
public async Task Handle(CreateTopic cmd)
{
query = cmd.Query;
foreach (var entry in cmd.Schedule)
{
await Reminders.Register(entry.Key.Path.Id, TimeSpan.Zero, entry.Value);
}
}
public void AddStandardReminder()
{
double hoursBeforeRaid = 0.5;
string message = $"The raid starts in {hoursBeforeRaid * 60} minutes.";
RaidReminder reminder = new RaidReminder(RaidReminder.ReminderType.User, message, hoursBeforeRaid, 0);
StandardReminderId = Guid.NewGuid();
Reminders.Add(StandardReminderId, reminder);
}
public void TimerEvent(object _)
{
//Don't allow multiple to run at the same time and generate possible race conditions
if (TimerWait)
{
return;
}
TimerWait = true;
//TODO: Check that bot is actually logged in before running
try
{
foreach (var reminder in Reminders.ToList())
{
if (reminder.TimeStamp + reminder.Length < DateTime.UtcNow)
{
if (!LocalManagementService.LastConfig.IsAcceptable(reminder.GuildId))
{
return;
}
var channel = Client.GetGuild(reminder.GuildId)?.GetTextChannel(reminder.ChannelId);
var user = Client.GetUser(reminder.UserId);
if (user == null)
{
RemoveReminder(reminder);
continue;
}
if (channel == null)
{
//DM User if available.
var dmChannel = user.GetOrCreateDMChannelAsync().Result;
if (dmChannel != null)
{
//TODO: Pretty up the message
dmChannel.SendMessageAsync(reminder.ReminderMessage).ConfigureAwait(false);
}
RemoveReminder(reminder);
continue;
}
channel.SendMessageAsync($"{user.Mention}", false, new EmbedBuilder()
{
Description = $"{reminder.ReminderMessage}".FixLength(1024),
Color = Color.Green
}.Build()).ConfigureAwait(false);
RemoveReminder(reminder);
}
}
}
finally
{
TimerWait = false;
}
}
public TaskExtra GetExtra(Wunderlist.TodoTask task)
{
return(new TaskExtra(
Lists[task.ListId],
Subtasks.TryGet(task.Id),
Reminders.TryGet(task.Id),
Notes.TryGet(task.Id),
SubtaskPositions.TryGet(task.Id)));
}
public ReminderProxy GetReminder(int reminderID)
{
Reminder reminder = Reminders.GetReminder(TSAuthentication.GetLoginUser(), (int)reminderID);
if (reminder.OrganizationID != TSAuthentication.OrganizationID)
{
return(null);
}
return(reminder.GetProxy());
}
public async void When_created()
{
await TopicCreated();
IsTrue(() => Reminders.Count() == schedule.Count,
"Should schedule recurrent search reminder per each api");
AssertReminderScheduled(facebook);
AssertReminderScheduled(twitter);
}
public static string GetReminder(RestCommand command, int reminderID)
{
Reminder reminder = Reminders.GetReminder(command.LoginUser, reminderID);
if (reminder.OrganizationID != command.Organization.OrganizationID)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
return(reminder.GetXml("Reminder", true));
}
