public bool RemoveItem(CollectionItem item)
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
repository.Remove(((TemplateItem)item.ItemContent).TaskTemplate);
return(true);
}
protected override void RunAction()
{
if (closedTasksGroup != null)
{
DateTime today = DateTime.Today;
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
{
foreach (Task task in closedTasksGroup.AllTasks.ToList())
{
if ((today - task.Closed).TotalDays > 60)
{
task.State = TaskState.Archived;
closedTasksGroup.Dispatcher.Invoke(() => closedTasksGroup.RemoveTask(task));
repository.Update(task);
StatsHelper.Update(StatsData.TaskArchived);
NotificationHelper.Notify(NotificationType.TaskArchived, task.Name);
Log.Debug($"Background action archived {task.Name} task", this);
}
}
}
}
}
public TemplatesAction()
: base(3600)
{
DateTime lastRun = DateTime.Today, today = DateTime.Today;
using (IRepository <Settings, long> repository = PersistentFactory.GetContext().GetRepository <Settings, long>())
{
Settings settings = SettingsFactory.GetSettings(repository);
lastRun = settings.LastRun.GetDate();
}
if (lastRun < today)
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
{
while (lastRun < today)
{
foreach (Template template in repository.GetAll())
{
if (template.SatisfiesCondition(lastRun))
{
Task newTask = template.CreateTask(lastRun);
TaskCreated?.Invoke(newTask);
repository.Update(template);
Log.Info($"Task {newTask.Name} was created from template for day {lastRun.ToShortDateString()}", this);
}
}
lastRun = lastRun.AddDays(1);
}
}
}
}
private void RefreshStats(object sender, SelectionChangedEventArgs e)
{
using (IRepository <StatsManager, long> repository = PersistentFactory.GetContext().GetRepository <StatsManager, long>())
{
StatsManager manager = repository.GetAll().FirstOrDefault();
if (manager != null)
{
StatsData result = new StatsData();
foreach (StatsData data in manager.GetData(((Period)cbPeriod.SelectedItem).Start, DateTime.Today))
{
result += data;
}
tbCreated.Text = result.TasksCreated.ToString();
tbFromTemplate.Text = $"{result.TasksCreatedFromTemplate} ({(result.TasksCreated > 0 ? Math.Round((double)result.TasksCreatedFromTemplate / result.TasksCreated, 2) * 100 : 0)}%)";
tbClosed.Text = $"{result.TasksClosed} ({(result.TasksCreated > 0 ? Math.Round((double)result.TasksClosed / result.TasksCreated, 2) * 100 : 0)}%)";
tbArchived.Text = $"{result.TasksArchived} ({(result.TasksCreated > 0 ? Math.Round((double)result.TasksArchived / result.TasksCreated, 2) * 100 : 0)}%)";
tbRemoved.Text = $"{result.TasksRemoved} ({(result.TasksCreated > 0 ? Math.Round((double)result.TasksRemoved / result.TasksCreated, 2) * 100 : 0)}%)";
tbVeryHigh.Text = $"{result.TasksVeryHighPriority} ({(result.TasksClosed > 0 ? Math.Round((double)result.TasksVeryHighPriority / result.TasksClosed, 2) * 100 : 0)}%)";
tbHigh.Text = $"{result.TasksHighPriority} ({(result.TasksClosed > 0 ? Math.Round((double)result.TasksHighPriority / result.TasksClosed, 2) * 100 : 0)}%)";
tbNormal.Text = $"{result.TasksNormalPriority} ({(result.TasksClosed > 0 ? Math.Round((double)result.TasksNormalPriority / result.TasksClosed, 2) * 100 : 0)}%)";
tbLow.Text = $"{result.TasksLowPriority} ({(result.TasksClosed > 0 ? Math.Round((double)result.TasksLowPriority / result.TasksClosed, 2) * 100 : 0)}%)";
tbVeryLow.Text = $"{result.TasksVeryLowPriority} ({(result.TasksClosed > 0 ? Math.Round((double)result.TasksVeryLowPriority / result.TasksClosed, 2) * 100 : 0)}%)";
}
}
}
public static void Notify(NotificationType type, params string[] parameters)
{
Notification notification = NotificationManager.Instance.Notify(type, parameters);
using (IRepository <Notification, long> repository = PersistentFactory.GetContext().GetRepository <Notification, long>())
repository.Add(notification);
Log.Debug($"Notification {type} was created.", null);
}
protected override void RunAction()
{
using (IRepository <Settings, long> repository = PersistentFactory.GetContext().GetRepository <Settings, long>())
{
Settings settings = SettingsFactory.GetSettings(repository);
settings.LastRun = DateTime.Now;
repository.Update(settings);
}
Log.Debug("Last run in user settings was updated", this);
}
public void UpdateItem(CollectionItem item, Window owner)
{
EditTemplateWindow window = new EditTemplateWindow(owner, ((TemplateItem)item.ItemContent).TaskTemplate);
if (window.ShowDialog() ?? false)
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
repository.Update(window.EditedTemplate);
((TemplateItem)item.ItemContent).Update();
}
}
public CollectionItem AddItem(Window owner)
{
EditTemplateWindow window = new EditTemplateWindow(owner);
if (window.ShowDialog() ?? false)
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
repository.Add(window.EditedTemplate);
return(new CollectionItem(new TemplateItem(window.EditedTemplate)));
}
return(null);
}
public NotificationsWindow(Window owner)
{
Owner = owner;
InitializeComponent();
NotificationManager.Instance.Targets.Add(this);
Closing += (sender, e) => NotificationManager.Instance.Targets.Remove(this);
using (IRepository <Notification, long> repository = PersistentFactory.GetContext().GetRepository <Notification, long>())
foreach (Notification notification in repository.GetAll().OrderByDescending(x => x.Created).Take(VISIBLE_NOTIFICATIONS_NUMBER).Reverse())
{
AddNotification(notification);
}
}
private void Command_PostponeTask(object sender, ExecutedRoutedEventArgs e)
{
if (groupOpen.SelectedTask != null)
{
Task selectedTask = groupOpen.SelectedTask;
selectedTask.State = TaskState.Postponed;
selectedTask.Updated = DateTime.Now;
groupOpen.RemoveTask(selectedTask);
groupPostponed.AddTask(selectedTask);
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Update(selectedTask);
NotificationHelper.Notify(NotificationType.TaskDeferred, selectedTask.Name);
}
}
protected override void RunAction()
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
{
foreach (Template template in repository.GetAll())
{
if (template.SatisfiesCondition())
{
Task newTask = template.CreateTask();
TaskCreated?.Invoke(newTask);
repository.Update(template);
Log.Info($"Task {newTask.Name} was created from template", this);
}
}
}
}
private void Command_NewTask(object sender, ExecutedRoutedEventArgs e)
{
EditTaskWindow window = new EditTaskWindow(this);
if (window.ShowDialog() ?? false)
{
groupOpen.AddTask(window.EditedTask);
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Add(window.EditedTask);
StatsHelper.Update(StatsData.TaskCreated);
NotificationHelper.Notify(NotificationType.TaskCreated, window.EditedTask.Name);
ActionsCollection.Instance.Add(new TaskDeadlineAction(window.EditedTask));
}
}
private PersistentFactory CreateTestFactory(bool cleanOldDataStore = true)
{
var dataStorePath = Path.Combine(TestContext.TestRunDirectory, "persistent40liteDatastore");
if (cleanOldDataStore)
{
var dirinfo = new DirectoryInfo(dataStorePath);
if (dirinfo.Exists) dirinfo.Delete(true);
}
var logger = new TestLogger();
var storage = new PlainFilePersistentStorage(logger, dataStorePath);
var serializer = new JsonPersistentSerializer(logger);
var factory = new PersistentFactory(storage, serializer, logger);
return factory;
}
public static void Update(UpdateStatsData update)
{
using (IRepository <StatsManager, long> repository = PersistentFactory.GetContext().GetRepository <StatsManager, long>())
{
StatsManager manager = repository.GetAll().FirstOrDefault();
if (manager == null)
{
manager = new StatsManager();
repository.Add(manager);
Log.Debug("Stats manager created", null);
}
manager.Update(update);
repository.Update(manager);
}
}
private void Command_RemoveTask(object sender, ExecutedRoutedEventArgs e)
{
TasksGroupControl selectedGroup = groups.FirstOrDefault(x => x.SelectedTask != null);
if (selectedGroup != null)
{
Task selectedTask = selectedGroup.SelectedTask;
selectedTask.State = TaskState.Removed;
selectedGroup.RemoveTask(selectedTask);
ActionsCollection.Instance.Remove(ActionsCollection.Instance.Actions.OfType <TaskDeadlineAction>().FirstOrDefault(x => x.Task == selectedTask));
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Update(selectedTask);
StatsHelper.Update(StatsData.TaskRemoved);
NotificationHelper.Notify(NotificationType.TaskRemoved, selectedTask.Name);
}
}
private void Command_EditTask(object sender, ExecutedRoutedEventArgs e)
{
deselect = false;
TasksGroupControl selectedGroup = groups.FirstOrDefault(x => x.SelectedTask != null);
if (selectedGroup != null && (selectedGroup.SelectedTask.State == TaskState.Open || selectedGroup.SelectedTask.State == TaskState.Postponed))
{
EditTaskWindow window = new EditTaskWindow(this, selectedGroup.SelectedTask);
if (window.ShowDialog() ?? false)
{
selectedGroup.UpdateTask(window.EditedTask);
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Update(window.EditedTask);
NotificationHelper.Notify(NotificationType.TaskUpdated, window.EditedTask.Name);
}
}
}
private void ActivityClick(BaseTask task, Image image)
{
if (task.IsActive)
{
task.CloseActivity();
image.Source = new BitmapImage(new Uri("/Resources/rec.png", UriKind.Relative));
NotificationHelper.Notify(NotificationType.TaskActivityStopped, task.Name);
}
else
{
task.StartActivity();
image.Source = new BitmapImage(new Uri("/Resources/recActive.png", UriKind.Relative));
NotificationHelper.Notify(NotificationType.TaskActivityStarted, task.Name);
}
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Update(Task);
}
public static void AppStart()
{
CultureInfo culture = new CultureInfo(9);
culture.DateTimeFormat.ShortDatePattern = "dd/MM/yyyy";
culture.DateTimeFormat.LongTimePattern = "HH:mm:ss";
CultureInfo.CurrentCulture = CultureInfo.CurrentUICulture = culture;
try
{
Log.Configure((LogLevel)Enum.Parse(typeof(LogLevel), Settings.Default.LogLevel), Settings.Default.LogDirectory, Settings.Default.LogFile);
}
catch
{
MessageBox.Show("Grizzlist application cannot start. There is a problem with configuration.", "Grizzlist startup error", MessageBoxButton.OK, MessageBoxImage.Error);
Application.Current.Shutdown();
}
Log.Info("Grizzlist started", null);
PersistentFactory.ConfigureContext(Settings.Default.AppDataFolder);
}
private void SearchClick(object sender, RoutedEventArgs e)
{
if (pnlCondition.Children.Count == 1 && pnlCondition.Children[0] is ValidatableControl && ((ValidatableControl)pnlCondition.Children[0]).IsValid() && pnlCondition.Children[0] is IConditionControl)
{
ICondition condition = ((IConditionControl)pnlCondition.Children[0]).GetCondition();
pnlTasks.Children.Clear();
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
{
foreach (Task task in repository.GetAll().Where(x => x.State != TaskState.Removed))
{
if (condition.Satisfies(task))
{
SearchItemControl control = new SearchItemControl(this, task);
control.OnSelect += t => Deselect();
pnlTasks.Children.Add(control);
}
}
tbResult.Text = $"{pnlTasks.Children.Count} tasks was found";
}
}
}
public MainWindow()
{
InitializeComponent();
NotificationManager.Instance.Targets.Add(this);
Closing += (sender, e) => NotificationManager.Instance.Targets.Remove(this);
groupOpen = new TasksGroupControl("Open tasks");
groupPostponed = new TasksGroupControl("Postponed tasks");
groupClosed = new TasksGroupControl("Closed tasks");
groups.Add(groupOpen);
groups.Add(groupPostponed);
groups.Add(groupClosed);
foreach (TasksGroupControl group in groups)
{
pnlGroups.Children.Add(group);
group.OnTaskSelect += OnTaskSelect;
group.OnTaskSelected += OnTaskSelected;
}
groupOpen.BackgroundSelector = new OpenTaskBackgroundSelector();
groupPostponed.BackgroundSelector = new OpenTaskBackgroundSelector();
groupClosed.BackgroundSelector = new TaskBackgroundSelector();
groupOpen.DateSelector = new DeadlineSelector();
groupPostponed.DateSelector = new DeadlineSelector();
groupClosed.DateSelector = new ClosedSelector();
groupOpen.ActivityVisibilitySelector = new SimpleBoolSelector(true);
groupPostponed.ActivityVisibilitySelector = new SimpleBoolSelector(false);
groupClosed.ActivityVisibilitySelector = new SimpleBoolSelector(false);
groupOpen.GroupIconsSelector = new DeadlineIconsSelector();
groupPostponed.GroupIconsSelector = new DeadlineIconsSelector();
groupOpen.TaskDoubleClick += t => Command_EditTask(null, null);
groupPostponed.TaskDoubleClick += t => Command_EditTask(null, null);
groupClosed.TaskDoubleClick += t => Command_ShowTask(null, null);
groupOpen.AddOrderSelector(x => x.Task.Deadline, false).AddOrderSelector(x => x.Task.Priority, true);
groupPostponed.AddOrderSelector(x => x.Task.Deadline, false).AddOrderSelector(x => x.Task.Priority, true);
groupClosed.AddOrderSelector(x => x.Task.Closed, true);
groupOpen.OnTaskControlCreated += t => ActionsCollection.Instance.Add(new TaskControlAction(t));
groupPostponed.OnTaskControlCreated += t => ActionsCollection.Instance.Add(new TaskControlAction(t));
groupOpen.OnTaskControlRemove += t => ActionsCollection.Instance.Remove(ActionsCollection.Instance.Actions.OfType <TaskControlAction>().FirstOrDefault(x => x.TaskControl == t));
groupPostponed.OnTaskControlRemove += t => ActionsCollection.Instance.Remove(ActionsCollection.Instance.Actions.OfType <TaskControlAction>().FirstOrDefault(x => x.TaskControl == t));
groupOpen.Collapse(false);
ActionsCollection.Instance.Add(new DeadlineIconsAction(groupOpen));
ActionsCollection.Instance.Add(new DeadlineIconsAction(groupPostponed));
ActionsCollection.Instance.Add(new TaskArchivingAction(groupClosed));
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
{
foreach (Task task in repository.GetAll())
{
switch (task.State)
{
case TaskState.Open:
groupOpen.AddTask(task);
ActionsCollection.Instance.Add(new TaskDeadlineAction(task));
break;
case TaskState.Postponed:
groupPostponed.AddTask(task);
ActionsCollection.Instance.Add(new TaskDeadlineAction(task));
break;
case TaskState.Closed:
groupClosed.AddTask(task);
break;
}
}
}
TemplatesAction templatesAction = new TemplatesAction();
templatesAction.TaskCreated += task =>
{
if (task != null)
{
groupOpen.Dispatcher.Invoke(() => groupOpen.AddTask(task));
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Add(task);
StatsHelper.Update(StatsData.TaskCreated);
StatsHelper.Update(StatsData.TaskCreatedFromTemplate);
NotificationHelper.Notify(NotificationType.TaskCreatedFromTemplate, task.Name);
ActionsCollection.Instance.Add(new TaskDeadlineAction(task));
}
};
ActionsCollection.Instance.Add(templatesAction);
ActionsCollection.Instance.Add(new LastRunAction());
backgroundThread.Start();
RefreshMenu();
Log.Debug($"{groups.Sum(x => x.Count)} tasks loaded", this);
Log.Info("Main window opened", this);
}
private void App_OnStartup(object sender, StartupEventArgs e)
{
try
{
Current.Dispatcher.UnhandledException +=
(o, args) =>
{
ErrorManager.ShowError("Something unexpected happened in the launcher, please report this error.", args.Exception, true);
args.Handled = true;
};
uniqueLaunchGateway = new WurmAssistantLauncherGateway(doNotAutoEnter: true);
uniqueLaunchGateway.Enter(1000);
LauncherPipeCom = new PipeCom(uniqueLaunchGateway.UniqueId, "Default");
LauncherPipeCom.LoginAsEndpointAlpha();
LauncherTaskbarIcon = (TaskbarIcon)FindResource("LauncherTaskbarIcon");
AppContext.BuildContext();
Logger = new SimpleLogger();
Logger.SetLogSaveDir(PathEx.CombineWithCodeBase("LauncherLogs"));
Logger.SetConsoleHandlingMode(SimpleLogger.ConsoleHandlingOption.SendConsoleToLoggerOutputDIAG);
SpellbookLogger.Logged += (o, args) =>
{
switch (args.Severity)
{
case LogSeverity.Debug:
Logger.LogDebug(args.Message, args.Source, args.Exception);
break;
case LogSeverity.Info:
Logger.LogInfo(args.Message, args.Source, args.Exception);
break;
case LogSeverity.Error:
Logger.LogError(args.Message, args.Source, args.Exception);
break;
}
};
var logger = new PersistentLogger();
var storage = new PlainFilePersistentStorage(logger, AppContext.LauncherSettingsDir);
var serializer = new JsonPersistentSerializer(logger);
PersistentFactory = new PersistentFactory(storage, serializer, logger);
var initialSetup = new InitialSetupManager();
initialSetup.Execute();
Settings = PersistentFactory.Create<LauncherSettings>("LauncherSettings");
StartupUri = new Uri(@"Views\MainWindow.xaml", UriKind.Relative);
}
catch (GatewayClosedException)
{
// try activate existing instance of launcher
using (var pipecom = new PipeCom(uniqueLaunchGateway.UniqueId, "Default"))
{
pipecom.LoginAsAlphaClient();
pipecom.TrySend("ShowWindow", null);
}
Shutdown();
}
catch (Exception exception)
{
MessageBox.Show("Unexpected error while starting the Launcher, please report this bug! Error: " +
exception.Message);
Logger.LogError("error on app init", this, exception);
Shutdown();
}
}
public void Update()
{
btnActivity.Visibility = ActivityVisibilitySelector?.Select() ?? false ? Visibility.Visible : Visibility.Collapsed;
btnActivity.Source = new BitmapImage(new Uri(Task.IsActive ? "/Resources/recActive.png" : "/Resources/rec.png", UriKind.Relative));
pnlPriority.Fill = new SolidColorBrush(TaskPriorityColors.GetColor(Task.Priority));
tbName.Text = Task.Name;
UpdateDate();
tbDescription.Text = Task.Description;
if (Task.SubTasks.Count == 0)
{
rowSubtasks.Height = new GridLength(0);
}
else
{
rowSubtasks.Height = new GridLength(1, GridUnitType.Star);
}
gridSubtasks.RowDefinitions.Clear();
gridSubtasks.Children.Clear();
foreach (SubTask subtask in Task.SubTasks)
{
gridSubtasks.RowDefinitions.Add(new RowDefinition());
Image imgCompleted = new Image()
{
Source = new BitmapImage(new Uri("/Resources/completed_24_green.png", UriKind.Relative)), Margin = new Thickness(2, 2, 2, string.IsNullOrEmpty(subtask.Description) ? 10 : 2), Opacity = subtask.Completed ? 1 : 0.3
};
TextBlock tbSubtaskName = new TextBlock()
{
Margin = new Thickness(4, 2, 0, string.IsNullOrEmpty(subtask.Description) ? 10 : 2), FontWeight = FontWeights.Bold, Text = subtask.Name, Opacity = subtask.Completed ? 0.3 : 1
};
gridSubtasks.Children.Add(imgCompleted);
gridSubtasks.Children.Add(tbSubtaskName);
Grid.SetColumn(imgCompleted, 0);
Grid.SetColumn(tbSubtaskName, 1);
Grid.SetRow(imgCompleted, gridSubtasks.RowDefinitions.Count - 1);
Grid.SetRow(tbSubtaskName, gridSubtasks.RowDefinitions.Count - 1);
imgCompleted.MouseLeftButtonDown += (sender, e) => {
if (!subtask.Completed)
{
subtask.Close();
Update();
using (IRepository <Task, long> repository = PersistentFactory.GetContext().GetRepository <Task, long>())
repository.Update(Task);
}
};
if (!subtask.Completed && (ActivityVisibilitySelector?.Select() ?? false))
{
Image imgActivity = new Image()
{
Source = new BitmapImage(new Uri(subtask.IsActive ? "/Resources/recActive.png" : "/Resources/rec.png", UriKind.Relative)), Margin = new Thickness(2, 2, 2, string.IsNullOrEmpty(subtask.Description) ? 10 : 2)
};
gridSubtasks.Children.Add(imgActivity);
Grid.SetColumn(imgActivity, 2);
Grid.SetRow(imgActivity, gridSubtasks.RowDefinitions.Count - 1);
imgActivity.MouseLeftButtonDown += (sender, e) => ActivityClick(subtask, imgActivity);
}
if (!string.IsNullOrEmpty(subtask.Description))
{
gridSubtasks.RowDefinitions.Add(new RowDefinition());
TextBlock tbSubtaskDescription = new TextBlock()
{
Margin = new Thickness(4, 0, 0, 10), TextWrapping = TextWrapping.Wrap, Text = subtask.Description, Opacity = subtask.Completed ? 0.2 : 1
};
gridSubtasks.Children.Add(tbSubtaskDescription);
Grid.SetColumn(tbSubtaskDescription, 1);
Grid.SetRow(tbSubtaskDescription, gridSubtasks.RowDefinitions.Count - 1);
Grid.SetColumnSpan(tbSubtaskDescription, 2);
}
}
if (string.IsNullOrEmpty(Task.Note) && Task.Attachments.Count == 0 && Task.Drawings.Count == 0)
{
rowAttachments.Height = new GridLength(0);
}
else
{
rowAttachments.Height = new GridLength(1, GridUnitType.Star);
}
imgNote.Visibility = string.IsNullOrEmpty(Task.Note) ? Visibility.Collapsed : Visibility.Visible;
imgDrawing.Visibility = Task.Drawings.Count == 0 ? Visibility.Collapsed : Visibility.Visible;
imgFile.Visibility = Task.Attachments.Count == 0 ? Visibility.Collapsed : Visibility.Visible;
if (string.IsNullOrEmpty(Task.Note))
{
HideNote();
}
tbNote.Text = Task.Note;
if (Task.Tags.Count == 0)
{
rowTags.Height = new GridLength(0);
}
else
{
rowTags.Height = new GridLength(1, GridUnitType.Star);
}
pnlTags.Children.Clear();
foreach (Tag tag in Task.Tags)
{
pnlTags.Children.Add(new Border()
{
Margin = new Thickness(6), Padding = new Thickness(4, 2, 4, 2), CornerRadius = new CornerRadius(4), Background = new SolidColorBrush(Color.FromRgb(255, 244, 204)), BorderThickness = new Thickness(1), BorderBrush = new SolidColorBrush(Color.FromRgb(255, 216, 0)), Child = new TextBlock()
{
Text = tag.Value
}
});
}
UpdateBackground();
}
public IEnumerable <CollectionItem> LoadItems()
{
using (IRepository <Template, long> repository = PersistentFactory.GetContext().GetRepository <Template, long>())
return(repository.GetAll().Select(x => new CollectionItem(new TemplateItem(x))));
}
