public void Verify_default_name_if_Work_item_type_does_not_esixts()
{
WordTemplateFolderManager sut = CreateSutForTemplate_1_A();
var expected = Path.Combine(GetTemplate1AFolder(), "WorkItem.docx");
Assert.That(sut.GetTemplateFor("This type does not exists"), Is.EqualTo(expected));
}
private static void PerformTemplateExport(ConnectionManager connection)
{
var wordFolderManager = new WordTemplateFolderManager(options.TemplateFolder);
var executor = new TemplateExecutor(wordFolderManager);
//now we need to ask user parameter value
Dictionary <string, Object> parameters = new Dictionary <string, object>();
foreach (var commandLineParam in options.Parameters)
{
var splitted = commandLineParam.Split('=');
if (splitted.Length == 2)
{
Log.Debug("Found parameter {paramName} in command line with value {value}", splitted[0], splitted[1]);
parameters[splitted[0]] = splitted[1];
}
else
{
Log.Error("Command line parameter {param} is not in the form name=value", commandLineParam);
}
}
foreach (var parameterName in wordFolderManager.TemplateDefinition.ParameterSection.Parameters.Keys)
{
if (!parameters.ContainsKey(parameterName))
{
Console.Write($"Parameter {parameterName}:");
parameters[parameterName] = Console.ReadLine();
}
}
var tempFileName = Path.GetTempPath() + Guid.NewGuid().ToString();
var generatedName = executor.GenerateFile(tempFileName, connection, options.TeamProject, parameters);
System.Diagnostics.Process.Start(generatedName);
}
public override void Dump(
StringBuilder stringBuilder,
Dictionary <string, object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
WorkItemManger workItemManger = PrepareWorkItemManager(connectionManager, teamProjectName);
parameters = parameters.ToDictionary(k => k.Key, v => v.Value); //clone
//If we do not have query parameters we have a single query or we can have parametrized query with iterationPath
var queries = PrepareQueries(parameters);
foreach (var query in queries)
{
var workItems = workItemManger.ExecuteQuery(query).Take(Limit);
foreach (var workItem in workItems.Where(ShouldExport))
{
var values = workItem.CreateDictionaryFromWorkItem();
foreach (var value in values)
{
stringBuilder.AppendLine($"{value.Key.PadRight(50, ' ')}={value.Value}");
}
}
}
}
private static WordTemplateFolderManager CreateSutForTemplate_1_A()
{
var templateA = GetTemplate1AFolder();
var sut = new WordTemplateFolderManager(templateA);
return(sut);
}
public void Verify_grab_docx_name_is_not_case_sensitive()
{
WordTemplateFolderManager sut = CreateSutForTemplate_1_A();
var expected = Path.Combine(GetTemplate1AFolder(), "Product Backlog Item.docx");
Assert.That(sut.GetTemplateFor("Product BACKLOG Item"), Is.EqualTo(expected));
}
/// <summary>
/// <para>Each section should be able to generate a part of the word file.</para>
/// <para>
/// Not all sections are used to manipulate word file, for those sections
/// this function could be not overriden
/// </para>
/// </summary>
/// <param name="manipulator"></param>
/// <param name="parameters"></param>
/// <param name="connectionManager"></param>
/// <param name="teamProjectName"></param>
public virtual void AssembleExcel(
ExcelManipulator manipulator,
Dictionary <string, Object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
}
/// <summary>
/// <para>Can simply dump information for work items, field etc. implementing
/// this method is completely optional</para>
/// </summary>
/// <param name="stringBuilder">A string builder to accumulate all the
/// data for dumping information</param>
/// <param name="parameters"></param>
/// <param name="connectionManager"></param>
/// <param name="teamProjectName"></param>
public virtual void Dump(
StringBuilder stringBuilder,
Dictionary <string, Object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
//Do nothing.
}
public TemplateInfo(String templateName, WordTemplateFolderManager wordTemplateFolderManager)
{
IsScriptTemplate = wordTemplateFolderManager.HasTemplateDefinition;
TemplateName = templateName;
WordTemplateFolderManager = wordTemplateFolderManager;
if (IsScriptTemplate)
{
//copy list of parameters
Parameters = wordTemplateFolderManager.TemplateDefinition.Parameters.ParameterNames.ToList();
}
}
public override void Assemble(
WordManipulator manipulator,
Dictionary <string, object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
parameters = parameters.ToDictionary(k => k.Key, v => v.Value); //clone
//If we do not have query parameters we have a single query or we can have parametrized query with iterationPath
var queries = PrepareQueries(parameters);
WorkItemManger workItemManger = new WorkItemManger(connectionManager);
workItemManger.SetTeamProject(teamProjectName);
foreach (var query in queries)
{
var workItems = workItemManger.ExecuteQuery(query).Take(Limit);
if (String.IsNullOrEmpty(TableTemplate))
{
foreach (var workItem in workItems)
{
if (!SpecificTemplates.TryGetValue(workItem.Type.Name, out var templateName))
{
templateName = wordTemplateFolderManager.GetTemplateFor(workItem.Type.Name);
}
else
{
templateName = wordTemplateFolderManager.GenerateFullFileName(templateName);
}
manipulator.InsertWorkItem(workItem, templateName, true, parameters);
}
}
else
{
//We have a table template, we want to export work item as a list
var tableFile = wordTemplateFolderManager.GenerateFullFileName(TableTemplate);
var tempFile = wordTemplateFolderManager.CopyFileInTempDirectory(tableFile);
using (var tableManipulator = new WordManipulator(tempFile, false))
{
tableManipulator.SubstituteTokens(parameters);
tableManipulator.FillTableWithCompositeWorkItems(true, workItems);
}
manipulator.AppendOtherWordFile(tempFile);
}
}
base.Assemble(manipulator, parameters, connectionManager, wordTemplateFolderManager, teamProjectName);
}
public TemplateInfo(String templateName, WordTemplateFolderManager wordTemplateFolderManager)
{
IsScriptTemplate = wordTemplateFolderManager.HasTemplateDefinition;
TemplateName = templateName;
WordTemplateFolderManager = wordTemplateFolderManager;
if (IsScriptTemplate)
{
//copy list of parameters
var tdef = wordTemplateFolderManager.TemplateDefinition;
Parameters =
tdef?.ParameterSection.Parameters
.Select(e => CreateParameterViewModel(tdef, e))
.ToList()
?? new List <ParameterViewModel>();
ArrayParameters = wordTemplateFolderManager.TemplateDefinition.ArrayParameterSection?.ArrayParameters ?? new Dictionary <String, String>();
}
}
private static void PerformTemplateExport(ConnectionManager connection)
{
var wordFolderManager = new WordTemplateFolderManager(options.TemplateFolder);
var executor = new TemplateExecutor(wordFolderManager);
//now we need to ask user parameter value
Dictionary <string, Object> parameters = new Dictionary <string, object>();
foreach (var parameterName in wordFolderManager.TemplateDefinition.Parameters.ParameterNames)
{
Console.Write($"Parameter {parameterName}:");
parameters[parameterName] = Console.ReadLine();
}
var tempFileName = Path.GetTempPath() + Guid.NewGuid().ToString() + ".docx";
executor.GenerateWordFile(tempFileName, connection, options.TeamProject, parameters);
System.Diagnostics.Process.Start(tempFileName);
}
public override void Assemble(
WordManipulator manipulator,
Dictionary <string, Object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
//ok we simply add a file to the manipulator, but remember we need to perform
//substitution.
var fileName = wordTemplateFolderManager.CopyFileInTempDirectory(FileName);
using (WordManipulator m = new WordManipulator(fileName, false))
{
m.SubstituteTokens(parameters);
}
//Simply append other file honoring the page break.
manipulator.AppendOtherWordFile(fileName, PageBreak);
File.Delete(FileName);
base.Assemble(manipulator, parameters, connectionManager, wordTemplateFolderManager, teamProjectName);
}
private static void AddTableContent(
WordManipulator manipulator,
List <WorkItem> workItems,
WordTemplateFolderManager template)
{
string tableFileName = template.GetTable("A", true);
using (var tableManipulator = new WordManipulator(tableFileName, false))
{
List <List <String> > table = new List <List <string> >();
foreach (WorkItem workItem in workItems)
{
List <String> row = new List <string>();
row.Add(workItem.Id.ToString());
row.Add(workItem.GetFieldValueAsString("System.AssignedTo"));
row.Add(workItem.AttachedFileCount.ToString());
table.Add(row);
}
tableManipulator.FillTable(true, table);
}
manipulator.AppendOtherWordFile(tableFileName);
File.Delete(tableFileName);
}
public override void AssembleExcel(
ExcelManipulator manipulator,
Dictionary <string, object> parameters,
ConnectionManager connectionManager,
WordTemplateFolderManager wordTemplateFolderManager,
string teamProjectName)
{
WorkItemManger workItemManger = PrepareWorkItemManager(connectionManager, teamProjectName);
//If we do not have query parameters we have a single query or we can have parametrized query with iterationPath
var queries = PrepareQueries(parameters);
foreach (var query in queries)
{
if (HierarchyMode?.Length > 0)
{
var hr = workItemManger.ExecuteHierarchicQuery(query, HierarchyMode);
manipulator.FillWorkItems(hr);
}
else
{
throw new NotSupportedException("This version of the program only support hierarchy mode for excel");
}
}
}
public void Verify_scan_folder_grab_name()
{
WordTemplateFolderManager sut = CreateSutForTemplate_1_A();
Assert.That(sut.Name, Is.EqualTo("TemplateA"));
}
