using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.IO;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

}

​

public sealed class NoticeOfViolationLettersFactory : IWorkflowFactory<NoticeOfViolationLettersWorkflow>

{

}

​

public interface IWorkflowFactory

{

}

​

​

public sealed class NoticeOfViolationLettersProcess : Process

{

    public string Name => "Notice of Violation Letters";

​

    public string Description =>

        "Generates various letters to constituents who are in violation of something.";

​

    /// <summary>

    ///     Creates a new instance of the <see cref="NoticeOfViolationLettersProcess"/> class.

    /// </summary>

    public NoticeOfViolationLettersProcess(IStage generateLettersStage,

                                           IStage generateBatchPdfStage,

                                           IStage uploadPdfForPrintingStage,

                                           IStage archiveLettersStage)

    {

        // TODO: Check parameters for null

​

        // Note: this.Stages is type List<IStage>

        stages.Add(generateLettersStage);

        stages.Add(generateBatchPdfStage);

        stages.Add(uploadPdfForPrintingStage);

        stages.Add(archiveLettersStage);

    }

}

​

#region Example Plugin

​

sealed class GenerateLettersStage : IStage

{

    readonly List<ITask> tasks = new List<ITask>();

​

    public ReadOnlyCollection<ITask> Stages => tasks.AsReadOnly();

​

    GenerateLettersStage(ITask queryBridgeData)

    {

        if (queryBridgeData == null)

            throw new ArgumentNullException(nameof(queryBridgeData));

​

        tasks.Add(queryBridgeData);

    }

}

​

sealed class QueryBridgeData : ITask

{

    public void Execute()

    {

        // TODO: Perform necessary task work

    }

}

​

sealed class GeneratePDFs : ITask

{

    public void Execute()

    {

        // TODO: Perform necessary task work

    }

}

​

sealed class ArchivePDFs : ITask

{

    readonly ITaskContext taskContext;

​

    public ArchivePDFs(ITaskContext taskContext)

    {

        // taskContext is automatically injected at run-time

        if (taskContext == null)

            throw new ArgumentNullException(nameof(taskContext));

​

        this.taskContext = taskContext;

    }

​

    public void Execute()

    {

        // TODO: Perform necessary task work

        var pdfs = Directory.GetFiles(taskContext.CurrentWorkspace, "*.pdf");

        var pdfsArtifact = new FileCollectionArtifact(pdfs);

        taskContext.PublishArtifact(pdfsArtifact);

    }

}

​

#endregion Example Plugin

​

​

​

#region Plugin Code

​

​

public abstract class Process

{

    protected readonly List<IStage> stages = new List<IStage>();

    public ReadOnlyCollection<IStage> Stages => stages.AsReadOnly();

}

​

public interface IProcess

{

    string Name { get; }

    string Description { get; }

}

​

public interface IStage

{

    ReadOnlyCollection<ITask> Stages { get; }

}

​

public interface ITask

{

    void Execute();

}

​

public interface IConditionalTask : ITask

{

    bool TaskShouldExecute(ITaskContext taskContext);

}

​

public interface IArtifact

{

    byte[] FileData { get; }

    string FileName { get; }

    /// <summary>Gets the directory of the artifact, relative to the workspace's root directory.</summary>

    string RelativeDirectory { get; }

}

​

public sealed class FileArtifact : IArtifact

{

    public FileArtifact(string fileName, string relativeDirectory, string workspaceRootDir)

    {

        if (fileName == null)

            throw new ArgumentNullException(nameof(fileName));

        if (String.IsNullOrWhiteSpace(fileName))

            throw new ArgumentException(nameof(fileName));

        if (String.IsNullOrWhiteSpace(relativeDirectory))

        {

            // Avoid NullReferenceExceptions from being thrown

            relativeDirectory = String.Empty;

        }

        else

        {

            // Standardize the path separator chars

            relativeDirectory = relativeDirectory.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);

            // Remove any leading separator chars to make sure the path is relative

            if (relativeDirectory.StartsWith(Path.DirectorySeparatorChar.ToString()))

                relativeDirectory = relativeDirectory.Substring(1, relativeDirectory.Length - 1);

        }

        FileName = fileName;

        RelativeDirectory = relativeDirectory;

        WorkspaceRootDir = String.IsNullOrWhiteSpace(workspaceRootDir)

                         ? Directory.GetCurrentDirectory()

                         : workspaceRootDir;

    }

    byte[] fileData;

    public byte[] FileData => fileData == null

                ? (fileData = File.ReadAllBytes(AbsolutePathToFile))

                : fileData;

    public string FileName { get; private set; }

    public string RelativeDirectory { get; private set; }

    public string AbsolutePathToFile => Path.Combine(WorkspaceRootDir, RelativeDirectory, FileName);

    public string WorkspaceRootDir { get; private set; }

}

​

public interface ITaskContext

{

    void PublishArtifact(IArtifact artifact);

    /// <summary>Gets the full path to the current workspace directory.</summary>

    string CurrentWorkspace { get; }

}

​

public interface IStageContext

{

    Type StageType { get; }

    string StageName { get; }

    string StageDescription { get; }

}

​

#endregion Plugin Code