/// <summary> /// Adds activities to the local storage from the specified Task for the next 61 days, last day inclusive, today inclusive. /// Activities after firstDay will be deleted, even if they are marked as completed. /// </summary> /// <param name="task">The PlantTask to create the activities for.</param> /// <param name="firstDay">The first (possible) day to add an activity for.</param> public static async Task AddActivitiesFromTaskAsync(PlantTask task, DateTime firstDay) { //First, we need to delete all activities that are after 'firstDay'. (This can run on seperate thread - will be waited later on.) Task deleteTask = Task.Run(async() => { await asyncDb.Table <PlantActivityItem>() .Where(act => act.PlantTaskFk == task.Id && act.Time >= firstDay) .DeleteAsync(); }); //Now add for the next 61 days. List <PlantActivityItem> resultList = new List <PlantActivityItem>(); for (DateTime day = firstDay; day <= DateTime.Today.AddDays(60); day = day.AddDays(1)) { if (task.IsRepeating) { //Check the task's each recurring option. //If any of the options indicate that the task should be performed this day, it gets added to the list. //Single Days. if ((day.DayOfWeek == DayOfWeek.Monday && task.OnMonday) || (day.DayOfWeek == DayOfWeek.Tuesday && task.OnTuesday) || (day.DayOfWeek == DayOfWeek.Wednesday && task.OnWednesday) || (day.DayOfWeek == DayOfWeek.Thursday && task.OnThursday) || (day.DayOfWeek == DayOfWeek.Friday && task.OnFriday) || (day.DayOfWeek == DayOfWeek.Saturday && task.OnSaturday) || (day.DayOfWeek == DayOfWeek.Sunday && task.OnSunday) || //If it should occur every X days and {[number of days passed since the first occurrence] mod X} = 0. (task.EveryXDays > 0 && day >= task.FirstOccurrenceDate.Date && (day - task.FirstOccurrenceDate.Date).Days % task.EveryXDays == 0) || //If it should occur every X month and this the Xth month's same day as it was for the first occurence. (task.EveryXMonths > 0 && //If this day is after the first occurrence... day >= task.FirstOccurrenceDate.Date && //If it should occur in this month... ((day.Year - task.FirstOccurrenceDate.Date.Year) * 12 + day.Month - task.FirstOccurrenceDate.Date.Month) % task.EveryXMonths == 0 && //If the day is the same or this is the last day of the month and the day is more than the number of days in this month... (day.Day == task.FirstOccurrenceDate.Date.Day || (IsLastDayOfMonth(day) && DateTime.DaysInMonth(day.Year, day.Month) < task.FirstOccurrenceDate.Day)))) { AddActivityItemForDay(resultList, task.Id, day); } } else { if (day.Date == task.FirstOccurrenceDate.Date) { AddActivityItemForDay(resultList, task.Id, day); } } } await deleteTask; await asyncDb.InsertAllAsync(resultList); await RecreateDailyReminders(); }
/// <summary> /// Removes a PlantTask and its future PlantActivityItems and all PlantConnections. /// </summary> /// <param name="task"></param> /// <returns></returns> public static async Task RemoveTaskAsync(PlantTask task) { await asyncDb.DeleteAsync(task); await RemoveActivitiesOfTaskAsync(task); await RemovePlantTaskPlantConnectionsForPlantTaskAsync(task); }
public static async Task ModifyPlantTaskAsync(PlantTask task, List <Plant> plantsToPerformTaskOn) { var oldConnections = await PlantActivityService.GetPlantTaskPlantConnectionsAsync(task); //Remove old connections. var plantIdsToRemove = oldConnections .Select(oldConn => oldConn.PlantFk) .Except(plantsToPerformTaskOn.Select(p => p.Id)); var connectionsToRemove = (await asyncDb .Table <PlantTaskPlantConnection>() .Where(conn => conn.PlantTaskFk == task.Id) //Only this task .ToListAsync()) .Where(conn => plantIdsToRemove.Any(id => id == conn.PlantFk)); //Only the plants to remove await Task.WhenAll(connectionsToRemove .Select(conn => asyncDb.DeleteAsync(conn))); //Add new connections. var connectionsToAdd = plantsToPerformTaskOn .Select(p => p.Id) .Except(oldConnections.Select(oldConn => oldConn.PlantFk)) .Select(id => new PlantTaskPlantConnection() { PlantFk = id, PlantTaskFk = task.Id }); await asyncDb.InsertAllAsync(connectionsToAdd); //Update the task and recreate the activities. await asyncDb.UpdateAsync(task); await AddActivitiesFromTaskAsync(task, DateTime.Today); }
public TaskDetailsPage(PlantTask plantTask) { InitializeComponent(); vm = new TaskDetailsViewModel(plantTask); this.BindingContext = vm; }
public static async Task <PlantTask> GetTaskOfActivityAsync(PlantActivityItem activity) { PlantTask plantTask = await asyncDb .Table <PlantTask>() .FirstAsync(task => task.Id == activity.PlantTaskFk); return(plantTask); }
/// <summary> /// Removes all activities for the specified task from the local storage. /// </summary> /// <param name="task">The PlantTask which's activities should be removed.</param> public static async Task RemoveActivitiesOfTaskAsync(PlantTask task) { await asyncDb.Table <PlantActivityItem>() .Where(act => act.PlantTaskFk == task.Id && act.Time >= DateTime.Now.Date) .DeleteAsync(); await RecreateDailyReminders(); }
public NewTaskPage(bool isEditingMode, PlantTask taskToEdit = null) { InitializeComponent(); this.DatePicker.MinimumDate = DateTime.Now.Date; this.TimePicker.Time = TimeSpan.FromHours(8); this.BindingContext = new NewTaskViewModel(this, isEditingMode, taskToEdit); vm = this.BindingContext as NewTaskViewModel; }
public static PlantActivityItem GetNextIncompleteActivityOfTask(PlantTask plantTask) { var activitiesOfTask = Db.Table <PlantActivityItem>() .ToList() .Where(pai => pai.PlantTaskFk == plantTask.Id && pai.Time.Date >= DateTime.Today && !pai.IsCompleted) .FirstOrDefault(); return(activitiesOfTask); }
/// <summary> /// Returns a List with all the Plants this PlantTask should be performed on. /// </summary> /// <param name="plantTask">The PlantTask to perform</param> /// <returns>The List of Plants</returns> public static List <Plant> GetPlantsOfTask(PlantTask plantTask) { var plantConnections = Db.Table <PlantTaskPlantConnection>() .Where(ptpc => ptpc.PlantTaskFk == plantTask.Id) .ToList(); var plants = Db.Table <Plant>() .ToList(); return(plants .Where(p => plantConnections .Select(pc => pc.PlantFk) .Contains(p.Id)) .ToList()); }
public static async Task UpdateTask(PlantTask plantTask) { await asyncDb.UpdateAsync(plantTask); var activityItems = await asyncDb.Table <PlantActivityItem>() .Where(act => act.PlantTaskFk == plantTask.Id) .ToListAsync(); var activityForToday = activityItems .FirstOrDefault(act => act.Time.Date == DateTime.Today); //If today's activity is marked completed, we will remove it. Otherwise not. var firstDateToRemove = (activityForToday?.IsCompleted ?? false) ? DateTime.Today.AddDays(1) : DateTime.Today; await AddActivitiesFromTaskAsync(plantTask, firstDateToRemove); }
/// <summary> /// Adds the PlantTask to the local storage, asynchronously. Then, creates the associated PlantActivityItems. /// </summary> /// <param name="task">The PlantTask to add.</param> /// <param name="plantsToPerformTaskOn">The list of Plants this task should be performed on.</param> /// <returns>A Task object that, when finished, creates the resources mentioned above.</returns> public static async Task AddPlantTaskAsync(PlantTask task, List <Plant> plantsToPerformTaskOn) { //Inserting the new PlantTask into DB. await asyncDb.InsertAsync(task); //This will populate the id field. //Creating the PlantTask - Plant connections. var connectionList = new List <PlantTaskPlantConnection>(); foreach (var plant in plantsToPerformTaskOn) { var plantTaskPlantConnection = new PlantTaskPlantConnection { PlantFk = plant.Id, PlantTaskFk = task.Id }; connectionList.Add(plantTaskPlantConnection); } await PlantActivityService.AddPlantTaskPlantConnectionsAsync(connectionList); //Adding activities for the task + recreating the daily reminders. await AddActivitiesFromTaskAsync(task, DateTime.Today); }
/// <summary> /// Removes the Plant association items for the PlantTask. /// </summary> /// <param name="task">The PlantTask to remove Plant connections for.</param> /// <returns></returns> public static async Task RemovePlantTaskPlantConnectionsForPlantTaskAsync(PlantTask task) { await asyncDb.Table <PlantTaskPlantConnection>() .Where(conn => conn.PlantTaskFk == task.Id) .DeleteAsync(); }
public static async Task <List <PlantTaskPlantConnection> > GetPlantTaskPlantConnectionsAsync(PlantTask task) { var dconnections = await asyncDb.Table <PlantTaskPlantConnection>() .ToListAsync(); var connections = await asyncDb.Table <PlantTaskPlantConnection>() .Where(conn => conn.PlantTaskFk == task.Id) .ToListAsync(); return(connections); }
public static List <string> CreateRecurrenceTextArray(this PlantTask plantTask) { var result = new List <string>(); if (plantTask.IsRepeating) { if (plantTask.OnMonday) { result.Add("Every Monday"); } if (plantTask.OnTuesday) { result.Add("Every Tuesday"); } if (plantTask.OnWednesday) { result.Add("Every Wednesday"); } if (plantTask.OnThursday) { result.Add("Every Thursday"); } if (plantTask.OnFriday) { result.Add("Every Friday"); } if (plantTask.OnSaturday) { result.Add("Every Saturday"); } if (plantTask.OnSunday) { result.Add("Every Sunday"); } if (plantTask.EveryXDays > 0) { if (plantTask.EveryXDays == 1) { result.Add("Everyday"); } else { result.Add($"Every {plantTask.EveryXDays} days"); } } if (plantTask.EveryXMonths > 0) { if (plantTask.EveryXMonths == 1) { result.Add("Every month"); } else { result.Add($"Every {plantTask.EveryXMonths} months"); } } } else { result.Add("No recurrence"); } return(result); }
internal void AddPlantTask(short x, short y, short z) { AddPhysicsTask(new PlantTask(this, x, y, z), PlantTask.GetRandomDelay()); }