public Output Process(Message msg, IMessageContext model)
{
switch (msg)
{
case CreateTodoCommand cmd:
var existingListIds = new HashSet <string>((model as CreateTodoContext).ListIds);
if (existingListIds.Contains(cmd.ListId) is false)
{
return(new Output(new Failure($"Invalid parent list provided!")));
}
var e = new TaskAdded {
Subject = cmd.Subject
};
var events = new Event[] {
e,
new ListExpanded {
ListId = cmd.ListId, TaskId = e.Id
}
};
return(new Output(new Success(), events));
default:
throw new NotImplementedException($"Message processing not implemented for '{msg}'!");
}
}
private void InsertTask(OfflineTask newTask)
{
_loggingService.WriteLine("Inserting task into database.");
_database.Insert(newTask);
TaskAdded?.Invoke(this, new OfflineTaskAddedEventArgs(newTask));
}
private void TaskValidateButton_Click(object sender, EventArgs e)
{
if (ValidateInput())
{
var ID = Guid.Empty;
if (String.IsNullOrEmpty(TaskIDTextBox.Text))
{
ID = Guid.NewGuid();
}
else
{
ID = Guid.Parse(TaskIDTextBox.Text);
}
var newTask = new Models.Task
{
ID = ID,
Description = TaskDescriptionTextBox.Text,
DueDate = DueDateDateTimePicker.Value,
StartDate = StartDateDateTimePicker.Value,
TaskPriority = (TaskPriority)Enum.Parse(typeof(TaskPriority), TaskPriorityComboBox.Text),
TaskState = (TaskState)Enum.Parse(typeof(TaskState), TaskStateComboBox.Text),
Title = TaskTitleTextBox.Text,
Comments = TaskCommentTextBox.Text,
User = UserComboBox.Text
};
context.Tasks.AddOrUpdate(newTask);
TaskAdded.Invoke(this, null);
context.SaveChanges();
}
else
{
MessageBox.Show("Please verify your inputs!");
}
}
public Task AddAsync(string url, IEnumerable <string> newTags)
{
_loggingService.WriteLine($"Adding task for URL '{url}' with {newTags.Count()} tags: {string.Join(",", newTags)}");
Uri.TryCreate(url, UriKind.Absolute, out var uri);
var newTask = new OfflineTask()
{
ItemId = _lastItemId,
Action = OfflineTaskAction.AddItem,
Url = url,
Tags = newTags.ToList()
};
_database.Insert(newTask);
// Fetch task ID from database
newTask.Id = _database.FindWithQuery <OfflineTask>("select Id from OfflineTask where ItemId=? and Action=?", newTask.ItemId, newTask.Action).Id;
_loggingService.WriteLine($"Inserting new placeholder item for task {newTask.Id} into the database.");
_database.Insert(new Item()
{
Id = _lastItemId + 1,
Title = uri.Host,
Url = url,
Hostname = uri.Host,
Content = m_PLACEHOLDER_PREFIX + newTask.Id
});
int placeholderItemId = _database.FindWithQuery <Item>("select Id from Item where Content=?", m_PLACEHOLDER_PREFIX + newTask.Id).Id;
TaskAdded?.Invoke(this, new OfflineTaskAddedEventArgs(newTask, placeholderItemId));
return(ExecuteAsync(newTask));
}
public void When(TaskAdded e)
{
StepRecordId(e.TaskId);
var item = new TaskItem(e.Text, e.TaskId, e.StoryId);
_items.Add(e.TaskId, item);
var story = _stories[e.StoryId];
story.AsItGoes.Add(e.TaskId);
}
public void addTask(Task item)
{
items.Add(item.UniqueName, item);
if (TaskAdded != null)
{
TaskAdded.Invoke(item);
}
}
/// <summary>
/// Cleans up event handlers when finished using this object
/// </summary>
public virtual void Dispose()
{
foreach (Delegate d in TaskAdded.GetInvocationList())
{
TaskAdded -= (EventHandler <TaskConqueror.TaskAddedEventArgs>)d;
}
foreach (Delegate d in TaskUpdated.GetInvocationList())
{
TaskUpdated -= (EventHandler <TaskConqueror.TaskUpdatedEventArgs>)d;
}
foreach (Delegate d in TaskDeleted.GetInvocationList())
{
TaskDeleted -= (EventHandler <TaskConqueror.TaskDeletedEventArgs>)d;
}
}
private async System.Threading.Tasks.Task DoSync()
{
try
{
// Load config
Config config = Config.LoadConfiguration();
if (string.IsNullOrEmpty(config.ModsDirectory) || string.IsNullOrEmpty(config.ResourcePackDirectory) || string.IsNullOrEmpty(config.ConfigFilesDirectory))
{
Task.Errors.Add("Configuration file not setup");
SyncComplete?.Invoke(this, new EventArgs());
return;
}
HashSet <string> clientSideWhiteListMods = new HashSet <string>();
if (File.Exists("mods_white_list.txt"))
{
foreach (string line in File.ReadAllLines("mods_white_list.txt"))
{
clientSideWhiteListMods.Add(line);
}
}
HashSet <string> clientSideWhiteListResourcePacks = new HashSet <string>();
if (File.Exists("resourcepacks_white_list.txt"))
{
foreach (string line in File.ReadAllLines("resourcepacks_white_list.txt"))
{
clientSideWhiteListResourcePacks.Add(line);
}
}
List <Task> tasks = new List <Task>();
// Load database stuff
List <MCSyncFile> syncFiles = await MCSyncFile.GetMCSyncFiles();
// Drive off of files
List <string> handledFiles = new List <string>();
// Mod Files
IEnumerable <MCSyncFile> modSyncFiles = syncFiles.Where(f => f.FileType == MCSyncFile.FileTypes.mods && IsDownloadTypeValid(config.Mode, f.DownloadType));
foreach (string file in Directory.EnumerateFiles(config.ModsDirectory, "*", SearchOption.AllDirectories))
{
string strippedFile = StripDirectory(file, MCSyncFile.FileTypes.mods);
byte[] fileHash = CalculateHash(file);
MCSyncFile syncFile = modSyncFiles.FirstOrDefault(f => f.Filename == strippedFile);
if (syncFile == null)
{
if (!clientSideWhiteListMods.Contains(strippedFile))
{
// Extrinsic, delete
Task deleteTask = new Task($"Delete mod file {strippedFile}", () =>
{
File.Delete(file);
return(true);
});
tasks.Add(deleteTask);
TaskAdded?.Invoke(this, deleteTask);
}
}
else if (!syncFile.Checksum.SequenceEqual(fileHash))
{
Task updateTask = new Task($"Update mod file {strippedFile}", () => DownloadFile(syncFile.FileType, config.ModsDirectory, strippedFile, syncFile.DownloadType));
tasks.Add(updateTask);
TaskAdded?.Invoke(this, updateTask);
}
handledFiles.Add(strippedFile);
}
// Resource Pack Files
IEnumerable <MCSyncFile> resourcePackSyncFiles = syncFiles.Where(f => f.FileType == MCSyncFile.FileTypes.resourcepacks && IsDownloadTypeValid(config.Mode, f.DownloadType));
foreach (string file in Directory.EnumerateFiles(config.ResourcePackDirectory, "*", SearchOption.AllDirectories))
{
string strippedFile = StripDirectory(file, MCSyncFile.FileTypes.resourcepacks);
byte[] fileHash = CalculateHash(file);
MCSyncFile syncFile = resourcePackSyncFiles.FirstOrDefault(f => f.Filename == strippedFile);
if (syncFile == null)
{
if (!clientSideWhiteListResourcePacks.Contains(strippedFile))
{
// Extrinsic, delete
Task deleteTask = new Task($"Delete resource pack file {strippedFile}", () =>
{
File.Delete(file);
return(true);
});
tasks.Add(deleteTask);
TaskAdded?.Invoke(this, deleteTask);
}
}
else if (!syncFile.Checksum.SequenceEqual(fileHash))
{
Task updateTask = new Task($"Update resource pack file {strippedFile}", () => DownloadFile(syncFile.FileType, config.ResourcePackDirectory, strippedFile, syncFile.DownloadType));
tasks.Add(updateTask);
TaskAdded?.Invoke(this, updateTask);
}
handledFiles.Add(strippedFile);
}
// Config
IEnumerable <MCSyncFile> configSyncFiles = syncFiles.Where(f => f.FileType == MCSyncFile.FileTypes.config && IsDownloadTypeValid(config.Mode, f.DownloadType));
foreach (MCSyncFile configFile in configSyncFiles)
{
if (File.Exists(config.ConfigFilesDirectory + "\\" + configFile.Filename))
{
byte[] fileHash = CalculateHash(config.ConfigFilesDirectory + "\\" + configFile.Filename);
if (!fileHash.SequenceEqual(configFile.Checksum))
{
Task updateTask = new Task($"Update config file {configFile.Filename}", () => DownloadFile(configFile.FileType, config.ConfigFilesDirectory, configFile.Filename, configFile.DownloadType));
tasks.Add(updateTask);
TaskAdded?.Invoke(this, updateTask);
}
handledFiles.Add(configFile.Filename);
}
}
// Missing Files
IEnumerable <MCSyncFile> missingFiles = syncFiles.Where(f => IsDownloadTypeValid(config.Mode, f.DownloadType) && !handledFiles.Contains(f.Filename));
foreach (MCSyncFile missingFile in missingFiles)
{
if (missingFile.FileType == MCSyncFile.FileTypes.resourcepacks)
{
Task.Informations.Add($"The resource pack {missingFile.Filename} has been added. Make sure to select it under the 'Available Resource Packs' column in the 'Options...'->'Resource Packs...' menu in Minecraft before attempting to join the server!");
}
string directory = "";
switch (missingFile.FileType)
{
case MCSyncFile.FileTypes.mods:
directory = config.ModsDirectory;
break;
case MCSyncFile.FileTypes.resourcepacks:
directory = config.ResourcePackDirectory;
break;
case MCSyncFile.FileTypes.config:
directory = config.ConfigFilesDirectory;
break;
}
Task downloadTask = new Task($"Download {missingFile.FileType.ToString()} file {missingFile.Filename}", () => DownloadFile(missingFile.FileType, directory, missingFile.Filename, missingFile.DownloadType));
tasks.Add(downloadTask);
TaskAdded?.Invoke(this, downloadTask);
}
// Perform Tasks
foreach (Task task in tasks)
{
task.Execute();
}
}
catch (Exception ex)
{
Task.Errors.Add($"An unexpected error occurred during Sync: {ex.Message}");
}
SyncComplete?.Invoke(this, new EventArgs());
}
public void OnTaskAdded()
{
TaskAdded.Invoke(this, EventArgs.Empty);
}
public void Add(string filePath)
{
_collection.Enqueue(filePath);
TaskAdded.Set();
}
public void Consume(TaskAdded e)
{
AddRecord(e.TaskId, e.Text);
}
/// <summary>
/// Raises the <see cref="E:TaskAdded" /> event.
/// </summary>
/// <param name="e">The <see cref="ParkitectNexus.Data.Tasks.QueueableTaskEventArgs" /> instance containing the event data.</param>
protected virtual void OnTaskAdded(QueueableTaskEventArgs e)
{
TaskAdded?.Invoke(this, e);
}
