protected override void SetElement(VisualElement element)
{
TaskElement taskElement = element as TaskElement;
_taskElement = taskElement;
base.SetElement(element);
}
public void DescriptionIsCorrect()
{
var expected = Guid.NewGuid().ToString();
var sut = new TaskElement(arbitraryName, expected, arbitraryValue);
Assert.Equal(expected, sut.Description);
}
public AddWorkLog(TaskElement taskElement)
{
InitializeComponent();
try
{
user = MainController.Instance.User;
this.taskElement = taskElement;
task = taskDAO.Read(taskElement.taskID);
date.Text = DateTime.Now.Date.ToString();
if (!task.Completed)
{
taskList = (StackPanel)taskElement.Parent;
StackPanel lastStackPanel = (StackPanel)((StackPanel)taskElement.Parent).Children[taskList.Children.Count - 1];
completedTaskList = ((StackPanel)lastStackPanel.Children[lastStackPanel.Children.Count - 1]);
}
else
{
completedTaskList = (StackPanel)taskElement.Parent;
taskList = ((StackPanel)((StackPanel)completedTaskList.Parent).Parent);
}
if (task.Completed)
{
CompleteTask.Content = "Start Opgave";
CompleteTask.Background = new Utilities().GetColor("#FF2196F3");
}
}
catch (Exception exception)
{
utilities.GetNotifier().ShowError(utilities.HandleException(exception));
}
}
public ViewTask(TaskElement taskElement)
{
InitializeComponent();
try
{
this.taskElement = taskElement;
task = new TaskDAO().Read(taskElement.taskID);
worklogs = workLogDAO.GetList(task.Id);
foreach (WorkLog workLog in worklogs)
{
workLogsItems.Add(new WorkLogItems()
{
Work = workLog.Work, Name = workLog.AssignedUser.Firstname + " " + workLog.AssignedUser.Lastname, Date = workLog.CreatedAt.Day.ToString() + "-" + workLog.CreatedAt.Month.ToString() + "-" + workLog.CreatedAt.Year.ToString()
});
}
workloads.ItemsSource = workLogsItems;
}
catch (Exception exception)
{
utilities.GetNotifier().ShowError(utilities.HandleException(exception));
}
}
public TaskConfigurationModel CreateModel(TaskElement element)
{
var item = new TaskConfigurationModel
{
TaskId = element.Id,
TaskName = element.Name,
DisplayName = element.DisplayName,
ClientId = element.ClientId ?? 1,
};
if (!string.IsNullOrEmpty(element.LogName))
{
item.LogName = element.LogName;
}
if (element.HasMetaData)
{
foreach (var metaItem in element.MetaData)
{
item.AddMetaData(metaItem.Key, metaItem.Value);
}
}
if (element.IsContainer)
{
foreach (var taskElement in element.SubTasks)
{
var child = CreateModel(taskElement);
item.AddSubTask(child);
}
}
return(item);
}
public void NameIsCorrect()
{
var expected = Guid.NewGuid().ToString();
var sut = new TaskElement(expected, arbitraryValue);
Assert.Equal(expected, sut.Name);
}
public void SimulateTask(IAI _enemy, float _time, int index)
{
GameObject _go = new GameObject();
DummyEnemy _dummy = _go.AddComponent <DummyEnemy>();
_dummy.Startup(_enemy, _time);
for (int i = index; i < _taskElements.Count; i++)
{
TaskElement _taskElement = _taskElements[i];
switch (_taskElement.Action)
{
case AIActions.MoveFoward:
AAMoveForward.SimulateAction(_dummy, _taskElement.GetTarget(), i);
break;
case AIActions.LookAt:
AARotate.SimulateAction(_dummy, _taskElement.GetTarget(), i);
break;
case AIActions.Wait:
AAWait.SimulateAction(_dummy, _taskElement.Value, i);
break;
case AIActions.MoveTo:
AAMoveTo.SimulateAction(_dummy, _taskElement.GetTarget(), i);
break;
}
}
//_enemy.SetAction(new TaskAction(ActionType.UnsetTask, this, _dummy.Time));
GameObject.Destroy(_go);
}
private void cloneTaskElement(TaskElement taskElement)
{
id = taskElement.id;
title = taskElement.title;
taskDifficulties = taskElement.taskDifficulties;
reward = taskElement.reward;
story = taskElement.story;
}
public void AcceptCallsVisitor()
{
var sut = new TaskElement(arbitraryName, arbitraryValue);
var visitorStub = new Mock <ITaskVisitor>();
sut.Accept(visitorStub.Object);
visitorStub.Verify(v => v.Visit(sut));
}
public void RemoveTask(TaskElement task)
{
task.Minimize();
task.SetOpacity(0, () =>
{
tasks.Remove(task);
Destroy(task.gameObject);
});
}
public void FinishTask(TaskElement task, TaskElement.TaskState state, Action callback)
{
audioSource.clip = state == TaskElement.TaskState.Success ? success : error;
audioSource.Play();
task.SetIcon(state);
task.SetOpacity();
task.Minimize(callback);
}
public override void ProcessActivity(Activity activity, IBaseElement baseElement)
{
TaskElement taskElement = GetType <TaskElement>(baseElement);
activity.Name = taskElement.Name;
Implementation implementation = new Implementation();
Task task = new Task();
implementation.Item = task;
activity.Item = implementation;
}
public void addTask(Element elem)
{
var element = new TaskElement(elem.Type, elem.Id);
element.setPosition(x, (int)positionTask + 10);
FileElements.Add(element);
element.Generate();
element.Display(this.canvas);
x += (int)element.width + 15;
count++;
}
public TaskElement CreateTask(XElement element)
{
var item = new TaskElement
{
Id = (string)element.Attribute("id"),
Name = (string)element.Attribute("id"),
DisplayName = (string)element.Attribute("displayName"),
ClientId = (int?)element.Attribute("clientId"),
};
if (element.Attribute("name") != null)
{
item.Name = (string)element.Attribute("name");
}
if (element.Attribute("logName") != null)
{
item.LogName = (string)element.Attribute("logName");
}
if (element.HasElements && element.Element("Meta") != null)
{
CreateTaskMetaData(item, element);
}
if (item.ClientId.HasValue)
{
item.Id = string.Format("client.{0}.{1}", item.ClientId, item.Id);
return(item);
}
if (!metaData.HasEntries)
{
return(item);
}
string metaClientId;
if (!metaData.TryGetEntry("ClientId", out metaClientId))
{
return(item);
}
int clientId;
if (int.TryParse(metaClientId, out clientId))
{
item.ClientId = clientId;
}
return(item);
}
public async Task <TaskElementDto> AddAsync(TaskElementDto taskElementDto)
{
var taskElement = new TaskElement();
_mapper.Map(taskElementDto, taskElement);
taskElement.LastUpdatedTime = DateTime.UtcNow;
var taskElementDtoResult = _mapper.Map <TaskElementDto>(taskElement);
await _taskTransportRepository.Send(SocketConstants.TaskAdd, taskElementDtoResult);
await _taskRepository.InsertAsync(taskElement);
return(taskElementDtoResult);
}
void PreTask()
{
foreach (BricRoboTask br in _taskList)
{
TaskElement ele = new TaskElement(br);
tasks.Add(ele);
}
masterTimer = new MicroTimer(oneMsTick);
masterTimer.MicroTimerElapsed += new MicroTimer.MicroTimerElapsedEventHandler(
delegate {
Tick();
});
}
public TaskElement Add(string text, TaskElement.TaskState state = TaskElement.TaskState.Active)
{
audioSource.clip = added;
audioSource.Play();
GameObject instance = Instantiate(template.gameObject, body.transform);
TaskElement element = instance.GetComponent <TaskElement>();
element.SetText(text);
element.SetIcon(state);
tasks.Add(element);
return(element);
}
public void CreateTaskMetaData(TaskElement item, XElement element)
{
var metaElement = element.Element("Meta");
if (metaElement == null)
{
return;
}
var entries = metaElement.Elements("Entry")
.Where(x => x.Attribute("key") != null && x.Attribute("value") != null);
foreach (var entry in entries)
{
item.AddMetaData((string)entry.Attribute("key"), (string)entry.Attribute("value"));
}
}
public void ValueIsCorrect(decimal value1, decimal value2, decimal value3)
{
var expected = value1 + value2 + value3;
var e1 = new TaskElement(arbitraryName, value1);
var e2 = new TaskElement(arbitraryName, value2);
var e3 = new TaskElement(arbitraryName, value3);
var c1 = new TaskComposite(arbitraryName, components: new List <ITaskComponent> {
e2, e3
});
var rootComposite = new TaskComposite(arbitraryName, components: new List <ITaskComponent> {
e1, c1
});
var sut = new ValueTaskVisitor();
rootComposite.Accept(sut);
Assert.Equal(expected, sut.Value);
}
public EditTask(TaskElement taskElement)
{
this.taskElement = taskElement;
task = taskDAO.Read(taskElement.taskID);
InitializeComponent();
title.Text = task.Name;
description.Text = task.Description;
deadline.Text = task.DueDate.ToString("dd-MM-yyyy");
estimation.Text = task.EstimatedTime.ToString();
priority.Text = task.Priority.ToString();
try
{
StackPanel projectUsers = (StackPanel)FindName("ProjectUsers");
section = new SectionDAO().Read(task.SectionID);
List <User> users = new ProjectDAO().GetProjectUsers(section.ProjectId);
foreach (User user in users)
{
UserAvatar userAvatar = new UserAvatar(this, user.Id);
userAvatar.Uid = user.Id.ToString();
userAvatar.UserImage.ImageSource = new BitmapImage(new Uri(user.Picture));
userAvatar.ToolTip = user.Firstname + " " + user.Lastname;
if (task.AssignedUser != null)
{
if (task.AssignedUser.Id == user.Id)
{
AssignUser(userAvatar, user.Id);
}
}
projectUsers.Children.Add(userAvatar);
}
}
catch (Exception exception)
{
utilities.GetNotifier().ShowError(utilities.HandleException(exception));
}
}
private void ButtnCreateTask_Click(object sender, RoutedEventArgs e)
{
try
{
if (ValidateInput())
{
string taskName = title.Text;
string taskDescription = description.Text;
double taskEstimation = Double.Parse(estimation.Text);
int taskPriority = int.Parse(priority.Text);
DateTime taskDeadline = DateTime.Parse(deadline.Text);
User assignedUser = assignedUserID != 0 ? new UserDAO().Read(assignedUserID) : null;
Task task = new Task(null, null, assignedUser, sectionID, taskName, taskDescription, taskEstimation, taskPriority, taskDeadline);
int taskID = taskDAO.CreateTask(task);
if (taskDAO.Read(taskID) != null)
{
TaskElement taskElement = new TaskElement(taskID);
taskElement.TaskID.Name = "Task" + taskID;
taskElement.title.Text = taskName;
taskElement.description.Text = taskDescription;
if (assignedUser != null)
{
taskElement.avatar.ImageSource = new BitmapImage(new Uri(assignedUser.Picture));
taskElement.UserButton.ToolTip = assignedUser.Firstname + " " + assignedUser.Lastname;
}
currentSection.Children.Insert(currentSection.Children.Count - 1, taskElement);
MainController.Instance.Dashboard.UpdatePage();
this.Close();
}
}
}
catch (Exception exception)
{
utilities.GetNotifier().ShowError(utilities.HandleException(exception));
}
}
public void SetElement(TaskElement element)
{
_element = element;
for (int i = 0; i < comboBoxTag.Items.Count; i++)
{
if (comboBoxTag.Items[i].ToString() == element.TagName)
{
comboBoxTag.SelectedIndex = i;
break;
}
}
textBoxCss.Text = element.CssSelector;
textBoxId.Text = element.Id;
textBoxName.Text = element.Name;
textBoxClass.Text = element.Class;
textBoxType.Text = element.Type;
textBoxContent.Text = element.Content;
}
public void Initialize(string path, bool force = false)
{
try {
if (force)
{
TaskList = new List <Task>();
}
XmlDocument XMLDoc = new XmlDocument();
XMLDoc.Load(path);
Name = System.IO.Path.GetFileNameWithoutExtension(path);
foreach (XmlNode TaskElement in XMLDoc.DocumentElement.SelectNodes("task"))
{
XmlNode ID = TaskElement.SelectSingleNode("id"),
Name = TaskElement.SelectSingleNode("name"),
Source = TaskElement.SelectSingleNode("source"),
Destination = TaskElement.SelectSingleNode("destination"),
ExtensionRegex = TaskElement.SelectSingleNode("extensionRegex"),
NameRegex = TaskElement.SelectSingleNode("nameRegex"),
AttributeMatch = TaskElement.SelectSingleNode("attributeMatch"),
NameFormat = TaskElement.SelectSingleNode("format"),
Perform = TaskElement.SelectSingleNode("perform"),
FileTypeIndex = TaskElement.SelectSingleNode("fileType"),
Enabled = TaskElement.SelectSingleNode("enabled");
if (ID != null && Source != null && Destination != null && ExtensionRegex != null && NameRegex != null && NameFormat != null && FileTypeIndex != null)
{
TaskList.Add(new Task(Convert.ToInt32(ID.InnerText),
Name != null ? Name.InnerText : "Unknown",
Source.InnerText,
Destination.InnerText,
ExtensionRegex.InnerText,
NameRegex.InnerText,
AttributeMatch.InnerText,
NameFormat.InnerText,
Perform != null ? Perform.InnerText : "Copy",
Convert.ToInt16(FileTypeIndex.InnerText),
Enabled != null ? Convert.ToBoolean(Enabled.InnerText) : true));
}
}
} catch (Exception ex) {
Log.Write("TaskCollection::ReadGroup() Error -> Failed To Read TaskCollection XML Path - " + path + " [" + ex.Message + "]");
}
}
private void FetchConfigBoardWithTaskElement(int currentTE_ID)
{
TaskElement taskElement = taskElements[currentTE_ID];
storyText.text = taskElement.story;
for (int id = 0; id < taskElement.taskDifficulties.Count; id++)
{
string dif = taskElement.taskDifficulties[id];
int reward = taskElement.reward[id];
GameObject dS = UIHelper.PushAndGetPrefabToParent(diffPrefab, diffList.transform, 30);
dS.GetComponent <Button>().onClick.AddListener(delegate { DiffSelect(currentTE_ID, id); });
dS.transform.GetChild(0).GetComponent <Text>().text = dif;
dS.transform.GetChild(1).GetChild(0).GetComponent <Text>().text = reward.ToString();
dS.transform.GetChild(1).GetChild(1).GetComponent <Text>().text = difString[id];
StartCoroutine(ContentSizeUpdate(dS, dS.transform.GetChild(0).GetComponent <Text>().gameObject));
}
}
void Start()
{
//tempo read
string json = (Resources.Load("taskSelect") as TextAsset).ToString();
List <TaskElement> teList =
TaskSelectDataManager.Instance.taskElements = JsonConvert.DeserializeObject <List <TaskElement> >(json);
int i = 0;
foreach (TaskElement te in teList)
{
GameObject taskElementObj = UIHelper.PushAndGetPrefabToParent(taskElementPrefab, taskBoard.transform, 0); // offset is 0 because Canvas Group is doing everything for us OwO
TaskElement taskElement = taskElementObj.GetComponent <TaskElement>();
te.id = i++;
taskElement.UpdateTaskElement_ALL(te);
// Init selection (default -1 for this TE)
TaskSelectDataManager.Instance.selection.Add(-1);
}
}
public void DoTaskElement(TaskElement element)
{
Debug.WriteLine("Current taskelement:");
Debug.WriteLine("ID: " + element.Id + "\n Name:" + element.Name + "\n Description: " + element.Description);
if (element.TypeId != null)
{
Models.Type type = typeController.GetTypeAsync(element.TypeId).Result;
Debug.WriteLine("Required type: " + type.Name + "\n" + type.Description);
Debug.WriteLine("+++++++++++++");
List <ContainerPartContent> cpcList = containerPartContentController.GetContainerPartContentAsync(type.Id).Result;
if (cpcList != null)
{
var cpc = cpcList.FirstOrDefault();
ContainerPart containerPart = containerPartController.GetContainerPartAsync(cpc.ContainerPartId).Result;
Debug.WriteLine("There is/are " + cpc.Amount + " in the " + containerPart.Name + " containerpart.");
}
else
{
throw new Exception("There isn't containerpart which contains the given type.");
}
}
}
public TaskElement CreateTask(TaskElement parent, XElement element)
{
var item = new TaskElement
{
Id = (string)element.Attribute("id"),
Name = (string)element.Attribute("id"),
DisplayName = (string)element.Attribute("displayName"),
ClientId = parent.ClientId,
};
if (element.Attribute("name") != null)
{
item.Name = (string)element.Attribute("name");
}
if (element.Attribute("logName") != null)
{
item.LogName = (string)element.Attribute("logName");
}
else
{
item.LogName = parent.LogName;
}
if (element.HasElements && element.Element("Meta") != null)
{
CreateTaskMetaData(item, element);
}
if (item.ClientId.HasValue)
{
item.Id = string.Format("client.{0}.{1}", item.ClientId, item.Id);
}
return(item);
}
/// <summary>
/// Generate HTML documentation for all the tasks
/// </summary>
/// <param name="NameToTask">Map of task name to implementation</param>
/// <param name="OutputFile">Output file</param>
static void GenerateDocumentation(Dictionary <string, ScriptTask> NameToTask, FileReference OutputFile)
{
// Find all the assemblies containing tasks
Assembly[] TaskAssemblies = NameToTask.Values.Select(x => x.ParametersClass.Assembly).Distinct().ToArray();
// Read documentation for each of them
Dictionary <string, XmlElement> MemberNameToElement = new Dictionary <string, XmlElement>();
foreach (Assembly TaskAssembly in TaskAssemblies)
{
string XmlFileName = Path.ChangeExtension(TaskAssembly.Location, ".xml");
if (File.Exists(XmlFileName))
{
// Read the document
XmlDocument Document = new XmlDocument();
Document.Load(XmlFileName);
// Parse all the members, and add them to the map
foreach (XmlElement Element in Document.SelectNodes("/doc/members/member"))
{
string Name = Element.GetAttribute("name");
MemberNameToElement.Add(Name, Element);
}
}
}
// Create the output directory
if (FileReference.Exists(OutputFile))
{
FileReference.MakeWriteable(OutputFile);
}
else
{
DirectoryReference.CreateDirectory(OutputFile.Directory);
}
// Write the output file
LogInformation("Writing {0}...", OutputFile);
using (StreamWriter Writer = new StreamWriter(OutputFile.FullName))
{
Writer.WriteLine("<html>");
Writer.WriteLine(" <head>");
Writer.WriteLine(" <style>");
Writer.WriteLine(" table { border-collapse: collapse }");
Writer.WriteLine(" table, th, td { border: 1px solid black; }");
Writer.WriteLine(" </style>");
Writer.WriteLine(" </head>");
Writer.WriteLine(" <body>");
Writer.WriteLine(" <h1>BuildGraph Tasks</h1>");
foreach (string TaskName in NameToTask.Keys.OrderBy(x => x))
{
// Get the task object
ScriptTask Task = NameToTask[TaskName];
// Get the documentation for this task
XmlElement TaskElement;
if (MemberNameToElement.TryGetValue("T:" + Task.TaskClass.FullName, out TaskElement))
{
// Write the task heading
Writer.WriteLine(" <h2>{0}</h2>", TaskName);
Writer.WriteLine(" <p>{0}</p>", TaskElement.SelectSingleNode("summary").InnerXml.Trim());
// Start the parameter table
Writer.WriteLine(" <table>");
Writer.WriteLine(" <tr>");
Writer.WriteLine(" <th>Attribute</th>");
Writer.WriteLine(" <th>Type</th>");
Writer.WriteLine(" <th>Usage</th>");
Writer.WriteLine(" <th>Description</th>");
Writer.WriteLine(" </tr>");
// Document the parameters
foreach (string ParameterName in Task.NameToParameter.Keys)
{
// Get the parameter data
ScriptTaskParameter Parameter = Task.NameToParameter[ParameterName];
// Get the documentation for this parameter
XmlElement ParameterElement;
if (MemberNameToElement.TryGetValue("F:" + Parameter.FieldInfo.DeclaringType.FullName + "." + Parameter.Name, out ParameterElement))
{
string TypeName = Parameter.FieldInfo.FieldType.Name;
if (Parameter.ValidationType != TaskParameterValidationType.Default)
{
StringBuilder NewTypeName = new StringBuilder(Parameter.ValidationType.ToString());
for (int Idx = 1; Idx < NewTypeName.Length; Idx++)
{
if (Char.IsLower(NewTypeName[Idx - 1]) && Char.IsUpper(NewTypeName[Idx]))
{
NewTypeName.Insert(Idx, ' ');
}
}
TypeName = NewTypeName.ToString();
}
Writer.WriteLine(" <tr>");
Writer.WriteLine(" <td>{0}</td>", ParameterName);
Writer.WriteLine(" <td>{0}</td>", TypeName);
Writer.WriteLine(" <td>{0}</td>", Parameter.bOptional? "Optional" : "Required");
Writer.WriteLine(" <td>{0}</td>", ParameterElement.SelectSingleNode("summary").InnerXml.Trim());
Writer.WriteLine(" </tr>");
}
}
// Always include the "If" attribute
Writer.WriteLine(" <tr>");
Writer.WriteLine(" <td>If</td>");
Writer.WriteLine(" <td>Condition</td>");
Writer.WriteLine(" <td>Optional</td>");
Writer.WriteLine(" <td>Whether to execute this task. It is ignored if this condition evaluates to false.</td>");
Writer.WriteLine(" </tr>");
// Close the table
Writer.WriteLine(" <table>");
}
}
Writer.WriteLine(" </body>");
Writer.WriteLine("</html>");
}
}
/// <summary>
/// Generate HTML documentation for all the tasks
/// </summary>
/// <param name="NameToTask">Map of task name to implementation</param>
/// <param name="OutputFile">Output file</param>
static void GenerateDocumentation(Dictionary <string, ScriptTask> NameToTask, FileReference OutputFile)
{
// Find all the assemblies containing tasks
Assembly[] TaskAssemblies = NameToTask.Values.Select(x => x.ParametersClass.Assembly).Distinct().ToArray();
// Read documentation for each of them
Dictionary <string, XmlElement> MemberNameToElement = new Dictionary <string, XmlElement>();
foreach (Assembly TaskAssembly in TaskAssemblies)
{
string XmlFileName = Path.ChangeExtension(TaskAssembly.Location, ".xml");
if (File.Exists(XmlFileName))
{
// Read the document
XmlDocument Document = new XmlDocument();
Document.Load(XmlFileName);
// Parse all the members, and add them to the map
foreach (XmlElement Element in Document.SelectNodes("/doc/members/member"))
{
string Name = Element.GetAttribute("name");
MemberNameToElement.Add(Name, Element);
}
}
}
// Create the output directory
DirectoryReference.CreateDirectory(OutputFile.Directory);
FileReference.MakeWriteable(OutputFile);
Log("Writing {0}...", OutputFile);
// Parse the engine version
BuildVersion Version;
if (!BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
throw new AutomationException("Couldn't read Build.version");
}
// Write the output file
using (StreamWriter Writer = new StreamWriter(OutputFile.FullName))
{
Writer.WriteLine("Availability: NoPublish");
Writer.WriteLine("Title: BuildGraph Predefined Tasks");
Writer.WriteLine("Crumbs: %ROOT%, Programming, Programming/Development, Programming/Development/BuildGraph, Programming/Development/BuildGraph/BuildGraphScriptTasks");
Writer.WriteLine("Description: This is a procedurally generated markdown page.");
Writer.WriteLine("version: {0}.{1}", Version.MajorVersion, Version.MinorVersion);
Writer.WriteLine("parent:Programming/Development/BuildGraph/BuildGraphScriptTasks");
Writer.WriteLine();
foreach (string TaskName in NameToTask.Keys.OrderBy(x => x))
{
// Get the task object
ScriptTask Task = NameToTask[TaskName];
// Get the documentation for this task
XmlElement TaskElement;
if (MemberNameToElement.TryGetValue("T:" + Task.TaskClass.FullName, out TaskElement))
{
// Write the task heading
Writer.WriteLine("### {0}", TaskName);
Writer.WriteLine();
Writer.WriteLine(ConvertToMarkdown(TaskElement.SelectSingleNode("summary")));
Writer.WriteLine();
// Document the parameters
List <string[]> Rows = new List <string[]>();
foreach (string ParameterName in Task.NameToParameter.Keys)
{
// Get the parameter data
ScriptTaskParameter Parameter = Task.NameToParameter[ParameterName];
// Get the documentation for this parameter
XmlElement ParameterElement;
if (MemberNameToElement.TryGetValue("F:" + Parameter.FieldInfo.DeclaringType.FullName + "." + Parameter.Name, out ParameterElement))
{
string TypeName = Parameter.FieldInfo.FieldType.Name;
if (Parameter.ValidationType != TaskParameterValidationType.Default)
{
StringBuilder NewTypeName = new StringBuilder(Parameter.ValidationType.ToString());
for (int Idx = 1; Idx < NewTypeName.Length; Idx++)
{
if (Char.IsLower(NewTypeName[Idx - 1]) && Char.IsUpper(NewTypeName[Idx]))
{
NewTypeName.Insert(Idx, ' ');
}
}
TypeName = NewTypeName.ToString();
}
string[] Columns = new string[4];
Columns[0] = ParameterName;
Columns[1] = TypeName;
Columns[2] = Parameter.bOptional? "Optional" : "Required";
Columns[3] = ConvertToMarkdown(ParameterElement.SelectSingleNode("summary"));
Rows.Add(Columns);
}
}
// Always include the "If" attribute
string[] IfColumns = new string[4];
IfColumns[0] = "If";
IfColumns[1] = "Condition";
IfColumns[2] = "Optional";
IfColumns[3] = "Whether to execute this task. It is ignored if this condition evaluates to false.";
Rows.Add(IfColumns);
// Get the width of each column
int[] Widths = new int[4];
for (int Idx = 0; Idx < 4; Idx++)
{
Widths[Idx] = Rows.Max(x => x[Idx].Length);
}
// Format the markdown table
string Format = String.Format("| {{0,-{0}}} | {{1,-{1}}} | {{2,-{2}}} | {{3,-{3}}} |", Widths[0], Widths[1], Widths[2], Widths[3]);
Writer.WriteLine(Format, "", "", "", "");
Writer.WriteLine(Format, new string('-', Widths[0]), new string('-', Widths[1]), new string('-', Widths[2]), new string('-', Widths[3]));
for (int Idx = 0; Idx < Rows.Count; Idx++)
{
Writer.WriteLine(Format, Rows[Idx][0], Rows[Idx][1], Rows[Idx][2], Rows[Idx][3]);
}
// Blank line before next task
Writer.WriteLine();
}
}
}
}
public override void StartPhase()
{
base.StartPhase();
tasksController = TasksController.GetInstance();
task = tasksController?.Add(info);
}
