/// <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());
}
