public void Constructs_ok(int threshold, bool expectedEnabled)
{
var settings = new ReportSettings("Html", threshold);
Assert.AreEqual("Html", settings.ReportType);
Assert.AreEqual(threshold, settings.AutoCondenseThreshold);
Assert.AreEqual(expectedEnabled, settings.AutoCondenseEnabled);
}
public void TestReport()
{
ReportSettings settings = new ReportSettings();
settings.ReportDir = Path.GetTempPath();
settings.ReportName = "Test";
Stream expected = ResourceManager.GetResource("SharpCover.Resources.ExpectedCoverageFile.xml", typeof(CoverageTests).Assembly);
Stream actual = ResourceManager.GetResource("SharpCover.Resources.ActualCoverageFile.xml", typeof(CoverageTests).Assembly);
Stream fixedfile = Coverage.FixActualFile(actual);
Coverage result = Coverage.LoadCoverage(expected, fixedfile);
ReportGenerator generator = new ReportGenerator();
Report report = generator.GenerateReport(result);
DeleteFiles(settings);
CheckFilesNotExist(settings);
SetGradient();
try
{
HtmlReport.Generate(settings, report);
CheckFilesExist(settings);
}
finally
{
DeleteFiles(settings);
Gradient.GetInstance().Points.Clear();
}
}
public SqlDataAccessStrategy(ReportSettings reportSettings)
{
if (reportSettings == null) {
throw new ArgumentNullException("reportSettings");
}
this.reportSettings = reportSettings;
}
public static ConnectionObject BuildConnectionObject (ReportSettings reportSettings)
{
if (reportSettings == null) {
throw new ArgumentNullException("reportSettings");
}
return ConnectionObject.CreateInstance(reportSettings.ConnectionString,
DbProviderFactories.GetFactory("System.Data.OleDb"));
}
public void AddGroupColumn ()
{
GroupColumn gc = new GroupColumn("GroupItem",1,ListSortDirection.Ascending);
ReportSettings rs = new ReportSettings();
rs.GroupColumnsCollection.Add(gc);
Assert.AreEqual(1,rs.GroupColumnsCollection.Count);
}
private void DeleteTempFiles(ReportSettings settings)
{
if(File.Exists(settings.ActualFilename))
File.Delete(settings.ActualFilename);
if(File.Exists(settings.ExpectedFilename))
File.Delete(settings.ExpectedFilename);
}
public TableStrategy(DataTable table,ReportSettings reportSettings):base(reportSettings)
{
if (table == null) {
throw new ArgumentNullException("table");
}
this.table = table;
}
public PreviewViewModel(ReportSettings reportSettings, PagesCollection pages)
{
this.Pages = pages;
FixedDocumentRenderer renderer = FixedDocumentRenderer.CreateInstance(reportSettings,Pages);
renderer.Start();
renderer.RenderOutput();
renderer.End();
this.Document = renderer.Document;
}
protected BaseListStrategy(ReportSettings reportSettings)
{
if (reportSettings == null) {
throw new ArgumentNullException("reportSettings");
}
this.ReportSettings = reportSettings;
this.IndexList = new IndexList("IndexList");
ExpressionEvaluator = new ExpressionEvaluatorFacade (null);
}
private static ReportSettings GetSettings(NameValueCollection nvc)
{
ReportSettings settings = new ReportSettings();
settings.ReportName = nvc[Constants.REPORT_NAME];
settings.BaseDir = nvc[Constants.BASE_DIR];
settings.ReportDir = nvc[Constants.REPORT_DIR];
return settings;
}
private void Preset(ReportSettings settings)
{
var preset = types.Find(x => x.Name.Equals(settings.ReportType, StringComparison.OrdinalIgnoreCase));
comboBoxOutputReportType.SelectedItem = preset;
labelDetails.Text = preset.Description;
checkBoxAutoCondense.Checked = settings.AutoCondenseEnabled;
groupBoxAutoCondense.Enabled = settings.AutoCondenseEnabled;
numericUpDownAutoCondenseThreshold.Value = settings.AutoCondenseThreshold;
UpdateAutoCondenseGroup();
}
private void CheckFilesExist(ReportSettings settings)
{
Assert.IsTrue(File.Exists(settings.ReportFilename));
Assert.IsTrue(File.Exists(settings.CssFilename));
Assert.IsTrue(File.Exists(settings.GetFilename("SharpCover", ".gif")));
Assert.IsTrue(new FileInfo(settings.ReportFilename).Length > 0);
Assert.IsTrue(new FileInfo(settings.CssFilename).Length > 0);
Assert.IsTrue(new FileInfo(settings.GetFilename("SharpCover", ".gif")).Length > 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="SharpCoverReportAction"/> class.
/// </summary>
public SharpCoverReportAction()
{
settings = new ReportSettings();
Gradient gradient = Gradient.GetInstance();
gradient.Points.Clear();
gradient.Add(new GradientPoint(0, 255, 0, 0));
gradient.Add(new GradientPoint(75, 200, 200, 0));
gradient.Add(new GradientPoint(100, 0, 200, 0));
}
public CollectionStrategy(IList list,ReportSettings reportSettings):base(reportSettings)
{
if (list.Count > 0) {
firstItem = list[0];
itemType = firstItem.GetType();
this.baseList = new DataCollection <object>(itemType);
this.baseList.AddRange(list);
}
this.listProperties = this.baseList.GetItemProperties(null);
}
public SqlDataAccessStrategy(ReportSettings reportSettings,ConnectionObject connectionObject)
{
if (reportSettings == null) {
throw new ArgumentNullException("reportSettings");
}
this.reportSettings = reportSettings;
if (connectionObject == null) {
this.connectionObject = ConnectionObjectFactory.BuildConnectionObject(reportSettings);
} else {
this.connectionObject = connectionObject;
}
}
public void TestProperties()
{
Assert.IsNotNull(this.action.Filenames);
Assert.IsNotNull(this.action.Settings);
ReportSettings rs = new ReportSettings();
this.action.Settings = rs;
Instrumenter instrumenter = new FileCopyInstrumenter(null);
this.action.Instrumenter = instrumenter;
Assert.AreEqual(rs, this.action.Settings);
Assert.AreEqual(instrumenter, this.action.Instrumenter);
}
/// <summary>
/// Initializes a new instance of the <see cref="Parser"/> class.
/// </summary>
/// <param name="Settings">The settings.</param>
public Parser(ReportSettings Settings)
{
this.settings = Settings;
this.coveragepoints = new List<CoveragePoint>();
AddCoveragePointDelegate addpointdel = new AddCoveragePointDelegate(this.AddCoveragePoint);
this.matchers = new List<Matcher>(6);
this.matchers.Add(new StatementMatcher(addpointdel));
this.matchers.Add(new ConditionalMatcher(addpointdel));
this.matchers.Add(new CatchBlockMatcher(addpointdel));
this.matchers.Add(new MethodMatcher(addpointdel));
this.matchers.Add(new FlattenMatcher(addpointdel));
this.matchers.Add(new UnflattenMatcher(addpointdel));
}
private static void AddFiles(StringCollection files, ReportSettings settings, string dirAndPattern)
{
string path = dirAndPattern;
if(path == null)
return;
if(path[0] != '\\')
path = Path.Combine(settings.BaseDir, dirAndPattern);
DirectoryInfo dir = new DirectoryInfo(Path.GetFullPath(Path.GetDirectoryName(path)));
string pattern = Path.GetFileName(dirAndPattern);
AddFiles(files, settings, dir, pattern);
}
/// <summary>
/// For internal use only
/// </summary>
/// <param name="reportSettings"></param>
/// <param name="pages"></param>
/// <param name="fileName"></param>
/// <param name="showOutput"></param>
/// <returns></returns>
public static PdfRenderer CreateInstance (ReportSettings reportSettings,PagesCollection pages,string fileName,bool showOutput) {
if ((pages == null) ||(pages.Count == 0)) {
throw new ArgumentNullException("pages");
}
if (String.IsNullOrEmpty(fileName)) {
throw new ArgumentNullException("fileName");
}
PdfRenderer instance = new PdfRenderer(pages);
instance.fileName = fileName;
instance.reportSettings = reportSettings;
instance.showOutput = showOutput;
return instance;
}
private static void AddFiles(StringCollection files, ReportSettings settings, DirectoryInfo dir, string pattern)
{
//Add matching files
foreach (FileInfo file in dir.GetFiles(pattern))
{
Trace.WriteLineIf(Logger.OutputType.TraceInfo, file.FullName, "Adding file");
files.Add(file.FullName);
}
//Recurse through sub-directories...
foreach (DirectoryInfo subdir in dir.GetDirectories())
{
AddFiles(files, settings, subdir, pattern);
}
}
/// <summary>
/// Generates the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="report">The report.</param>
public static void Generate(ReportSettings settings, Report report)
{
// Load the transform
XslCompiledTransform transform = LoadTransform("SharpCover.Report.xslt");
// Save the required stylesheet and images to the output folder
WriteResource(settings.CssFilename, "SharpCover.SharpCover.css", ResourceType.Text);
WriteResource(settings.GetFilename("SharpCover", ".gif"), "SharpCover.SharpCover.gif", ResourceType.Binary);
// Write the xml report to disk
WriteReport(report, settings.ReportXmlFilename);
// Convert the report to a format we can transform
XPathDocument doc = ConvertReportToXPathDocument(report);
// Do the transform and write the results to disk
WriteReport(transform, doc, settings.ReportFilename);
}
public SectionBounds (ReportSettings reportSettings,bool firstPage)
{
if (reportSettings == null) {
throw new ArgumentNullException("reportSettings");
}
this.firstPage = firstPage;
this.landscape = reportSettings.Landscape;
this.PageSize = reportSettings.PageSize;
this.printableArea = new Rectangle(reportSettings.LeftMargin,reportSettings.TopMargin,
reportSettings.PageSize.Width - reportSettings.RightMargin,
reportSettings.PageSize.Height - reportSettings.BottomMargin);
this.marginBounds = new Rectangle(reportSettings.LeftMargin,
reportSettings.TopMargin,
reportSettings.PageSize.Width - reportSettings.LeftMargin - reportSettings.RightMargin,
reportSettings.PageSize.Height - reportSettings.TopMargin - reportSettings.BottomMargin);
}
public void TestProperties()
{
Assert.IsNotNull(this.action.Filenames, "action.Filenames should no be null");
Assert.IsNotNull(this.action.Settings, "action.Settings should no be null");
Assert.IsNull(this.action.Instrumenter, "action.Instrumenter will be initialized on execute");
StringCollection sc = new StringCollection();
this.action.Filenames = sc;
ReportSettings rs = new ReportSettings();
this.action.Settings = rs;
List<IParse> parsers = new List<IParse>(1);
parsers.Add(new Parser(rs));
Instrumenter instrumenter = new FileCopyInstrumenter(parsers.ToArray());
this.action.Instrumenter = instrumenter;
Assert.AreEqual(sc, this.action.Filenames);
Assert.AreEqual(rs, this.action.Settings);
Assert.AreEqual(instrumenter, this.action.Instrumenter);
}
public void TestReportSettingsEquals()
{
TestUtils.InitializeInstallations();
var testReportInfoNoScript = new ReportInfo("Name", TestUtils.GetTestFilePath("UniqueReport.skyr"), new List <Tuple <string, string> >());
var testReportInfoWithScript = TestUtils.GetTestReportInfo();
Assert.IsTrue(Equals(testReportInfoNoScript,
new ReportInfo("Name", TestUtils.GetTestFilePath("UniqueReport.skyr"), new List <Tuple <string, string> >())));
Assert.IsFalse(Equals(testReportInfoNoScript, testReportInfoWithScript));
//TestUtils.GetTestReportSettings();
var emptyReportSettings = new ReportSettings(new List <ReportInfo>());
var reportSettingsWithScript = TestUtils.GetTestReportSettings();
Assert.IsTrue(Equals(emptyReportSettings, new ReportSettings(new List <ReportInfo>())));
var reportList = new List <ReportInfo>();
reportList.Add(testReportInfoNoScript);
var changedReportSettings = new ReportSettings(reportList);
Assert.IsFalse(Equals(emptyReportSettings, changedReportSettings));
Assert.IsFalse(Equals(changedReportSettings, reportSettingsWithScript));
}
private static void InitializeSummaryReport()
{
_frameworkParameters.RunConfiguration = ConfigurationManager.AppSettings["RunConfiguration"];
_timeStamp = TimeStamp.getInstance();
_reportSettings = InitializeReportSettings();
string theme = ConfigurationManager.AppSettings["ReportTheme"];
ReportTheme reportTheme =
ReportThemeFactory.GetReportsTheme((Framework_Reporting.ReportThemeFactory.Theme)Enum.Parse(typeof(Framework_Reporting.ReportThemeFactory.Theme), theme));
_report = new SeleniumReport(_reportSettings, reportTheme);
_report.InitializeReportTypes();
_report.InitializeResultSummary();
_report.AddResultSummaryHeading(_reportSettings.ProjectName +
" - " + " Automation Execution Result Summary");
_report.AddResultSummarySubHeading("Date & Time",
": " + Util.GetCurrentFormattedTime(ConfigurationManager.AppSettings["DateFormatString"]),
"OnError", ": " + ConfigurationManager.AppSettings["OnError"]);
_report.AddResultSummaryTableHeadings();
}
IEnumerable <IEntity> GetListFromReport(IRunState context, IEntity reportRef)
{
var reportSettings = new ReportSettings
{
InitialRow = 0,
PageSize = MaxResourcesInList,
SupportPaging = true,
CpuLimitSeconds = EDC.ReadiNow.Configuration.EntityWebApiSettings.Current.ReportCpuLimitSeconds
};
var reportingInterface = new ReportingInterface();
try
{
var result = reportingInterface.RunReport(reportRef.Id, reportSettings);
return(result.GridData.Where(row => row.EntityId > 0).Select(row => Entity.Get(row.EntityId)).ToList());
}
catch (TenantResourceLimitException ex)
{
throw new WorkflowRunException(ex.CustomerMessage, ex);
}
}
public DataTable GetReportTable(ReportSettings reportSettings)
{
string sql;
switch (reportSettings.ReportType)
{
case ReportType.Labors:
sql = GetLaborsReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.MatchEstimate:
sql = GetMatchEstimateReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.NotMatchEstimate:
sql = GetNotMatchEstimateReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.OverTime:
sql = GetOverTimeReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.TaskTypes:
sql = GetTaskTypesReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.TaskTimes:
sql = GetTaskTimesReportSqlCommand(reportSettings);
return(GetDataTableFromSql(sql));
case ReportType.Bonus:
return(GetBonusReportSqlCommand(reportSettings));
default:
return(GetDataTableFromSql("select * from labors"));
}
}
private void InitializeReportSettings()
{
reportPath = _frameworkParameters.RelativePath +
Util.GetFileSeparator() + "Results" +
Util.GetFileSeparator() + _timeStamp;
_reportSettings = new ReportSettings(reportPath,
testParameters.CurrentScenario +
"_" + testParameters.CurrentTestcase);
_reportSettings.DateFormatString = ConfigurationManager.AppSettings["DateFormatString"];
_reportSettings.LogLevel = Convert.ToInt32(ConfigurationManager.AppSettings["LogLevel"]);
_reportSettings.ProjectName = ConfigurationManager.AppSettings["ProjectName"];
_reportSettings.GenerateExcelReports =
Boolean.Parse(ConfigurationManager.AppSettings["ExcelReport"]);
_reportSettings.GenerateHtmlReports =
Boolean.Parse(ConfigurationManager.AppSettings["HtmlReport"]);
_reportSettings.IncludeTestDataInReport =
Boolean.Parse(ConfigurationManager.AppSettings["IncludeTestDataInReport"]);
_reportSettings.TakeScreenshotFailedStep =
Boolean.Parse(ConfigurationManager.AppSettings["TakeScreenshotFailedStep"]);
_reportSettings.TakeScreenshotPassedStep =
Boolean.Parse(ConfigurationManager.AppSettings["TakeScreenshotPassedStep"]);
}
private void Recurse(FileSystemEntry Entry, ReportIFSExplorer IFSExplorer)
{
if (Entry.Type.Equals(FileSystemEntry.Types.File))
{
ReportSettings settings = Session.ReportManager.GetReportSettings(Entry);
if (settings.Columns != null)
{
ReportResults.Add(new ReportResult()
{
Columns = settings.Columns,
Name = Entry.Name,
Path = Entry.Path,
MatchingProperty = "Column"
});
}
if (settings.Filters != null)
{
ReportResults.AddRange(settings.Filters.Select(x => new ReportResult()
{
Filters = settings.Filters,
Name = Entry.Name,
Path = Entry.Path,
MatchingProperty = $"Filter [{x.FieldID}] {x.OperatorTypeAsString} {x.ValueFrom} {x.ValueTo}"
}));
}
}
else
{
foreach (FileSystemEntry file in IFSExplorer.GetFileSystemEntries(Entry))
{
Recurse(file, IFSExplorer);
}
}
}
public void SortAscendingByTwoColumns()
{
SortColumn sc = new SortColumn("Last", System.ComponentModel.ListSortDirection.Ascending);
SortColumn sc1 = new SortColumn("RandomInt", System.ComponentModel.ListSortDirection.Ascending);
ReportSettings rs = new ReportSettings();
rs.SortColumnsCollection.Add(sc);
rs.SortColumnsCollection.Add(sc1);
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(this.contributorCollection, rs);
DataNavigator dataNav = dm.GetNavigator;
string v1 = String.Empty;
while (dataNav.MoveNext())
{
Contributor view = dataNav.Current as Contributor;
string v2 = view.Last + "-" + view.RandomInt;
//string ss = String.Format("< {0} > <{1}>",v1,v2);
//Console.WriteLine(ss);
//Console.WriteLine(v2);
Assert.LessOrEqual(v1, v2);
v1 = v2;
}
}
internal ReportResultCacheKey(ReportSettings reportSettings, IQueryRunnerCacheKey reportQueryKey, IQueryRunnerCacheKey rollupQueryKey)
{
if (reportSettings == null)
{
throw new ArgumentNullException("reportSettings");
}
if (reportQueryKey == null)
{
throw new ArgumentNullException("reportQueryKey");
}
// rollupQueryKey may be null
ReportQueryKey = reportQueryKey;
RollupQueryKey = rollupQueryKey;
Bools = PackBools(reportSettings);
ColumnCount = reportSettings.ColumnCount;
// The following reportSettings do not need to be covered in this key:
// - SupportPaging, PageSize, InitialRow (denied)
// - ReportParameters, Timezone, ReportOnType, QuickSearch, FilteredEntityIdentifiers, RelatedEntityFilters
// - UseStructuredQueryCache, RefreshCachedResult, RefreshCachedSql, RefreshCachedStructuredQuery
_hashCode = GenerateHashCode();
}
public void Expression_In_Text_Evaluate()
{
ReportSettings rs = new ReportSettings();
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(this.table, rs);
DataNavigator dataNav = dm.GetNavigator;
BaseDataItem bdi = new BaseDataItem()
{
Name = "MyDataItem",
ColumnName = "last",
Text = "=Substring(Fields!last,0,3)",
Expression = "=Substring(Fields!last,0,3)"
};
var ri = new ReportItemCollection();
ri.Add(bdi);
while (dataNav.MoveNext())
{
dataNav.Fill(ri);
DataRow r = dataNav.Current as DataRow;
string actual = r["last"].ToString();
Assert.That(actual.Substring(0, 3), Is.EqualTo(bdi.DBValue));
}
}
private void SetupViewer(ReportModel reportModel)
{
this.pages = new PagesCollection();
this.reportSettings = reportModel.ReportSettings;
this.AdjustDrawArea();
}
public PdfUnitConverter (Rectangle pageSize,ReportSettings reportsettings)
{
if (pageSize == null) {
throw new ArgumentNullException("pageSize");
}
if (reportsettings == null) {
throw new ArgumentNullException("reportsettings");
}
this.pageSize = pageSize;
this.reportsettings = reportsettings;
this.lowerLeftX = UnitConverter.FromPixel(this.reportsettings.LeftMargin);
this.lowerleftY = UnitConverter.FromPixel(this.reportsettings.BottomMargin);
this.upperRightX = PageSize.A4.Width;
this.upperRightY = PageSize.A4.Height;
}
/// <summary>
/// Generates a report from a set of changes using the specified settings
/// </summary>
/// <param name="InReportSettings">Report generation settings</param>
/// <param name="InChanges">Change data</param>
/// <param name="OutReportString">Output report string</param>
public static void GenerateReportFromChanges(ReportSettings InReportSettings, List <P4ParsedChangelist> InChanges, out String OutReportString)
{
// Sort everything into buckets based on category
ProjectCategory MainCategory = new ProjectCategory();
MainCategory.Name = "Main";
// We'll only create an "uncategorized" category if we need to (later)
ProjectCategory UncategorizedCategory = null;
// Process changes
foreach (var Changelist in InChanges)
{
foreach (var Subchange in Changelist.Subchanges)
{
ChangeDesc NewChangeDesc = new ChangeDesc();
// Store changelist number
NewChangeDesc.ChangelistNumber = Changelist.BaseChangelist.Id;
// Classify this change
if (Subchange.StartTag.StartTagName.Equals("Fix", StringComparison.InvariantCultureIgnoreCase))
{
NewChangeDesc.Type = EChangeType.Fix;
}
else if (Subchange.StartTag.StartTagName.Equals("Change", StringComparison.InvariantCultureIgnoreCase))
{
NewChangeDesc.Type = EChangeType.Change;
}
else if (Subchange.StartTag.StartTagName.Equals("New", StringComparison.InvariantCultureIgnoreCase))
{
NewChangeDesc.Type = EChangeType.New;
}
// Store the change description
NewChangeDesc.BriefDescription = Subchange.StartTag.BriefDescription;
// Store the extra description
if (Subchange.AuxiliaryTags.ContainsKey("extra"))
{
List <P4AuxiliaryTag> AuxTags = Subchange.AuxiliaryTags["extra"];
foreach (P4AuxiliaryTag CurAuxTag in AuxTags)
{
P4ExtraTag CurExtraTag = CurAuxTag as P4ExtraTag;
NewChangeDesc.ExtraDescription.Add(CurExtraTag.Description);
}
}
// Iterate over the types of tags attached to this change
ProjectCategory BestCategory = null;
foreach (var CurAuxTag in Subchange.AuxiliaryTags.Keys)
{
// Now iterate over the ordered list of tags of a single type attached to this change
List <P4AuxiliaryTag> CurAuxList = Subchange.AuxiliaryTags[CurAuxTag];
foreach (P4AuxiliaryTag CurTag in CurAuxList)
{
// TTP number
if (CurTag is P4TTPTag)
{
P4TTPTag TTPTag = (P4TTPTag)CurTag;
NewChangeDesc.TTPNumbers.Add(TTPTag.TTPNumber);
}
// Project (aka. category)
else if (CurTag is P4ProjTag)
{
if (BestCategory == null)
{
P4ProjTag ProjTag = (P4ProjTag)CurTag;
// Parse the string
String[] CategoryPath = ProjTag.Project.Split('.');
ProjectCategory SearchCategory = MainCategory;
foreach (var CurCategoryString in CategoryPath)
{
// Try to find an existing category at this level in the hierarchy
bool bFoundExistingCategory = false;
foreach (var CurCategory in SearchCategory.Subcategories)
{
if (CurCategory.Name.Equals(CurCategoryString, StringComparison.InvariantCultureIgnoreCase))
{
// Found an existing category at this level
bFoundExistingCategory = true;
// The subcategory we found now becomes the search path
SearchCategory = CurCategory;
break;
}
}
// If we didn't find a category go ahead and create one now
if (!bFoundExistingCategory)
{
var NewSubcategory = new ProjectCategory();
NewSubcategory.Name = CurCategoryString;
SearchCategory.Subcategories.Add(NewSubcategory);
// The new subcategory now becomes the search path
SearchCategory = NewSubcategory;
}
}
// We now have a subcategory to put this change into
BestCategory = SearchCategory;
}
else
{
// We already have a category for this change. Just ignore this entry.
}
}
}
}
// If the user didn't mention a category, then give it a default one
if (BestCategory == null)
{
if (UncategorizedCategory == null && InReportSettings.UncategorizedCategoryName.Length > 0)
{
var NewSubcategory = new ProjectCategory();
NewSubcategory.Name = InReportSettings.UncategorizedCategoryName;
}
// Place the item into the 'uncategorized' category
BestCategory = UncategorizedCategory;
}
if (BestCategory != null)
{
// Attach this change to the best category for it
BestCategory.Changes.Add(NewChangeDesc);
}
}
}
// Sort the data
SortCategoriesRecursively(InReportSettings, MainCategory);
// Write output buffer according to the user's configuration
using (StringWriter OutputWriter = new StringWriter())
{
// Omit the header name for the main category
bool bIncludeCategoryHeader = false;
int IndentLevel = 1;
WriteCategoryChangesRecursively(OutputWriter, InReportSettings, MainCategory, bIncludeCategoryHeader, IndentLevel);
// Store the report string
OutReportString = OutputWriter.ToString();
}
}
private bool ApplySettings(int selectedIndex)
{
bool applied = false;
try
{
string taskName = processUnits[selectedIndex].TaskName;
string taskDirectory = processUnits[selectedIndex].TaskDirectory;
string dateSuffix = DateTime.Now.ToString("yyyy-MM-dd");
if (!Directory.Exists(taskDirectory) || string.IsNullOrEmpty(taskName))
{
return(applied);
}
//Reports
ReportSettings rSetting = settings.ReportSettings;
string rDirectory = (rSetting.SaveInPlace) ? taskDirectory : rSetting.OutputFolder;
if (Directory.Exists(rDirectory))
{
if (rSetting.IsCheckingSelected)
{
string checkingFileName = (rSetting.AppendDate) ? (taskName + "-checking-" + dateSuffix) : (taskName + "-checking");
processUnits[selectedIndex].CheckingReport.PdfFile = System.IO.Path.Combine(rDirectory, checkingFileName + ".pdf");
processUnits[selectedIndex].CheckingReport.RtfFile = System.IO.Path.Combine(rDirectory, checkingFileName + ".rtf");
}
if (rSetting.IsPresentationSelected)
{
string presentationFileName = (rSetting.AppendDate) ? (taskName + "-presentation-" + dateSuffix) : (taskName + "-presentation");
processUnits[selectedIndex].PresentationReport.PdfFile = System.IO.Path.Combine(rDirectory, presentationFileName + ".pdf");
processUnits[selectedIndex].PresentationReport.RtfFile = System.IO.Path.Combine(rDirectory, presentationFileName + ".rtf");
}
if (rSetting.IsBCFSelected)
{
string bcfFileName = (rSetting.AppendDate) ? (taskName + "-" + dateSuffix + ".bcfzip") : (taskName + ".bcfzip");
processUnits[selectedIndex].BCFReport.File = System.IO.Path.Combine(rDirectory, bcfFileName);
}
if (rSetting.IsCoordinationSelected)
{
string coordFileName = (rSetting.AppendDate) ? (taskName + "-" + dateSuffix + ".xls") : (taskName + ".xls");
processUnits[selectedIndex].CoordReport.File = System.IO.Path.Combine(rDirectory, coordFileName);
if (File.Exists(rSetting.CoordinationTemplate))
{
processUnits[selectedIndex].CoordReport.TemplateFile = rSetting.CoordinationTemplate;
}
}
}
//Saving Solibri
SaveModelSettings sSetting = settings.SaveSolibriSettings;
string sDirectory = (sSetting.SaveInPlace) ? taskDirectory : sSetting.OutputFolder;
if (Directory.Exists(sDirectory))
{
string saveFileName = (sSetting.AppendDate) ? (taskName + "-" + dateSuffix + ".smc") : (taskName + ".smc");
processUnits[selectedIndex].SaveSolibri.File = System.IO.Path.Combine(sDirectory, saveFileName);
}
applied = true;
}
catch (Exception ex)
{
MessageBox.Show("Failed to apply settings.\n" + ex.Message, "Apply Settings", MessageBoxButton.OK, MessageBoxImage.Warning);
}
return(applied);
}
/// <summary>
/// Applies report settings to the structured query and also builds an appropriate query settings object.
/// </summary>
/// <param name="structuredQuery"></param>
/// <param name="queryReportSettings"></param>
/// <returns></returns>
private static PreparedQuery PrepareReportRun(StructuredQuery structuredQuery, ReportSettings queryReportSettings)
{
QuerySettings querySettings;
// Build the query engine settings
bool secureReports;
if (!_cachedSecureReports.HasValue)
{
DatabaseConfiguration dbConfiguration;
dbConfiguration = ConfigurationSettings.GetDatabaseConfigurationSection( );
if (dbConfiguration != null)
{
_cachedSecureReports = dbConfiguration.ConnectionSettings.SecureReports;
}
}
secureReports = _cachedSecureReports.Value;
// Set the time zone for the report
if (queryReportSettings.Timezone != null)
{
structuredQuery.TimeZoneName = queryReportSettings.Timezone.StandardName;
}
// Update the query engine settings
querySettings = new QuerySettings
{
SecureQuery = secureReports,
SupportPaging = queryReportSettings.SupportPaging,
FirstRow = queryReportSettings.InitialRow,
PageSize = queryReportSettings.PageSize,
QuickSearchTerm = queryReportSettings.QuickSearch,
SupportQuickSearch = !string.IsNullOrWhiteSpace(queryReportSettings.QuickSearch),
FullAggregateClustering = true,
RefreshCachedResult = queryReportSettings.RefreshCachedResult,
RefreshCachedSql = queryReportSettings.RefreshCachedSql,
CpuLimitSeconds = queryReportSettings.CpuLimitSeconds
};
if (queryReportSettings.ReportOnType.HasValue)
{
Model.IEntity typeEntity = Model.Entity.Get <Model.EntityType>(queryReportSettings.ReportOnType);
if (typeEntity == null)
{
throw new WebArgumentException("Not a valid type");
}
(( ResourceEntity )structuredQuery.RootEntity).EntityTypeId = queryReportSettings.ReportOnType.Value;
}
if (queryReportSettings.ReportParameters != null)
{
// Apply any filters for analyser
if (queryReportSettings.ReportParameters.AnalyserConditions != null &&
queryReportSettings.ReportParameters.AnalyserConditions.Count > 0)
{
ApplyAnalyserConditions(structuredQuery, queryReportSettings.ReportParameters.AnalyserConditions);
}
// Apply any filters for sorting
if (queryReportSettings.ReportParameters.SortColumns != null)
{
ApplySortOrder(structuredQuery, queryReportSettings.ReportParameters.SortColumns);
}
// Determine if main row report is to be ignored
querySettings.ResultSchemaOnly = queryReportSettings.ReportParameters.GroupAggregateRules != null && queryReportSettings.ReportParameters.GroupAggregateRules.IgnoreRows;
}
if (queryReportSettings.ReportRelationship != null)
{
ApplyRelatedResourceCondition(structuredQuery, queryReportSettings.ReportRelationship, querySettings);
}
if (queryReportSettings.RelatedEntityFilters != null)
{
ApplyRelatedEntityFilters(structuredQuery, queryReportSettings.RelatedEntityFilters);
}
if (queryReportSettings.FilteredEntityIdentifiers != null &&
queryReportSettings.FilteredEntityIdentifiers.Count > 0)
{
ApplyFilteredEntityIdentifiers(structuredQuery, queryReportSettings.FilteredEntityIdentifiers);
}
PreparedQuery preparedQuery = new PreparedQuery
{
QuerySettings = querySettings,
StructuredQuery = structuredQuery
};
return(preparedQuery);
}
/// <summary>
/// Runs the report.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="settings">The settings.</param>
/// <param name="suppressPreload">Pass true if the report has already been preloaded.</param>
/// <returns>ReportResult.</returns>
/// <exception cref="System.ArgumentException">@The report identifier resource is not a report.;reportId</exception>
public ReportResult RunReport(Model.Report report, ReportSettings settings, bool suppressPreload = false)
{
ReportCompletionData completionData = PrepareReport(report, settings, suppressPreload);
return(completionData.PerformRun( ));
}
public MockDataAccessStrategy(ReportSettings reportSettings)
{
this.reportSettings = reportSettings;
}
private FixedDocumentRenderer(ReportSettings reportSettings, PagesCollection pages) : base(pages)
{
this.pages = pages;
this.reportSettings = reportSettings;
this.docCreator = new FixedDocumentCreator();
}
public static FixedDocumentRenderer CreateInstance(ReportSettings reportSettings, PagesCollection pages)
{
var instance = new FixedDocumentRenderer(reportSettings, pages);
return(instance);
}
public static ReportSettings Map(this ReportSettingsDto runDto)
{
var run = new ReportSettings(runDto.RunsToDisplay, runDto.TestsToDisplay);
return(run);
}
public static void InitPage (ISinglePage singlePage,ReportSettings reportSettings)
{
singlePage.ReportFileName = reportSettings.FileName;
singlePage.ReportName = reportSettings.ReportName;
singlePage.ParameterHash = reportSettings.ParameterCollection.CreateHash();
}
public async Task Report()
{
try
{
var socketContext = Context as SocketCommandContext;
var guildsEmbed = new EmbedBuilder();
guildsEmbed.WithTitle("Reply with the number next to the guild you want to make the report in");
var mutualGuilds = socketContext.User.MutualGuilds.ToArray();
for (int i = 0; i < mutualGuilds.Length; i++)
{
guildsEmbed.AddField($"[{i + 1}] {mutualGuilds[i].Name} discord", mutualGuilds[i].Id);
}
await ReplyAsync(embed : guildsEmbed.Build());
SocketGuild guild;
while (true)
{
var result = await Interactivity.NextMessageAsync(timeout : TimeSpan.FromMinutes(1));
var message = result.Value;
if (message == null || message.Content == "cancel")
{
await ReplyAsync("You have timed out or canceled");
return;
}
try
{
guild = mutualGuilds[ushort.Parse(message.Content) - 1];
break;
}
catch
{
await ReplyAsync("Invalid number, please reply again with a valid number or ``cancel``");
}
}
ReportSettings settings = guild.LoadFromFile <ReportSettings>(false);
if (settings?.channelID == null || guild.GetChannel(settings.channelID ?? 0) == null)
{
await ReplyAsync("This guild does not currently have reporting set up, command canceled");
return;
}
SocketGuildUser gUser = guild.GetUser(Context.Message.Author.Id);
if (settings.requiredRole != null && !(gUser.RoleIDs().Contains(settings.requiredRole.Value) || gUser.GuildPermissions.Administrator))
{
await ReplyAsync("You are missing required role for reporting");
return;
}
if (settings.cooldown != null)
{
int messageAmount = 100;
var messages = await Context.Channel.GetMessagesAsync(messageAmount).Flatten().ToListAsync();
messages.OrderBy(msg => msg.CreatedAt);
while (messages.Last().CreatedAt.Offset > settings.cooldown.Value)
{
_ = ReplyAsync("Downloading more messages");
messageAmount += 100;
messages = await Context.Channel.GetMessagesAsync(messageAmount).Flatten().ToListAsync();
messages.OrderBy(msg => msg.Timestamp.Offset);
}
foreach (IMessage message in messages)
{
TimeSpan timeAgo = message.GetTimeAgo();
if (message.Author.IsBot && message.Content == "Report has been sent")
{
if (timeAgo > settings.cooldown.Value)
{
break;
}
else
{
await ReplyAsync($"You need to wait the full {settings.cooldown.Value.Humanize()}, {timeAgo.Humanize()} have passed from {message.GetJumpUrl()}");
return;
}
}
}
}
await ReplyAsync("Please reply with what you want to report");
var reportMsg = await Interactivity.NextMessageAsync(timeout : TimeSpan.FromMinutes(5));
if (!reportMsg.IsSuccess)
{
await ReplyAsync("Report aborted");
return;
}
var embed = new EmbedBuilder();
embed.WithAuthor(Context.Message.Author);
embed.WithTitle("Report");
embed.WithDescription(reportMsg.Value.Content);
embed.WithFooter("User ID: " + Context.Message.Author.Id);
embed.WithCurrentTimestamp();
string links = "";
if (reportMsg.Value.Attachments?.Count is not null or 0)
{
links = reportMsg.Value.Attachments.Select(attachment => attachment.ProxyUrl).ListItems(" ");
}
var channel = guild.GetTextChannel(settings.channelID.Value);
await channel.SendMessageAsync(embed : embed.Build());
if (!string.IsNullOrEmpty(links))
{
await channel.SendMessageAsync("The message above had these attachments: " + links);
}
await ReplyAsync("Report has been sent");
}
catch (Exception e)
{
ReplyAsync("Error: " + e);
}
}
private ReportParameter[] GetReportParameters(ParameterValue[] values)
{
string serverUrl;
string modelsFolder;
string company;
string languageCulture;
ReportParameter[] parameters = null;
string errMsg = null;
try
{
ReportUtility.GetSessionInfo(out serverUrl, out modelsFolder, out company, out languageCulture);
if (string.IsNullOrEmpty(serverUrl))
{
throw new InvalidOperationException(Resources.GetString(Report.NoServerUrl));
}
ReportSettings settings = new ReportSettings();
settings.ReportManagerUrl = serverUrl;
settings.RootFolder = modelsFolder;
settings.ReportPath = this.ReportPath;
string fullPath = settings.ResolveFullPath();
// Ask reporting services for a list of all reports and all the parameters for the currently selected report.
using (ReportingService2005 rs = new ReportingService2005())
{
// Provoke potential exceptions by validating the full path
settings.ValidateFullPath(fullPath);
rs.Url = settings.ResolvedServiceUrl;
rs.Credentials = System.Net.CredentialCache.DefaultCredentials;
parameters = rs.GetReportParameters(fullPath, null, values != null, values, null);
}
}
catch (System.Net.WebException)
{
errMsg = Resources.GetString(Report.cant_read_from_server);
}
catch (InvalidOperationException reportException)
{
errMsg = Microsoft.SharePoint.Utilities.SPHttpUtility.HtmlEncode(reportException.Message);
}
catch (ReportException reportException)
{
errMsg = AxRSReportWebPart.FormatMissingReportExceptionMessage(
reportException,
this.WebPartToEdit.CultureInfo,
this.WebPartToEdit.Title,
this.ReportPath);
}
catch (Exception exception)
{
errMsg = Microsoft.SharePoint.Utilities.SPHttpUtility.HtmlEncode(exception.Message);
}
if (!string.IsNullOrEmpty(errMsg))
{
this.AddErrorMessage(errMsg);
}
return parameters;
}
public void StandartPrinter()
{
ReportSettings settings = this.mockReportModel.ReportSettings;
Assert.AreEqual(true, settings.UseStandardPrinter, "Standarprinter has should be 'true");
}
public void PushPullModel()
{
ReportSettings settings = this.mockReportModel.ReportSettings;
Assert.AreEqual(GlobalEnums.PushPullModel.FormSheet, settings.DataModel, "Wrong PusPullModel");
}
public ExpressionRunner(Collection <ExportPage> pages, ReportSettings reportSettings, CollectionDataSource dataSource)
{
this.pages = pages;
this.dataSource = dataSource;
Visitor = new ExpressionVisitor(reportSettings);
}
/// <summary>
/// Runs the report specified by ID.
/// </summary>
/// <param name="reportId">The report unique identifier.</param>
/// <param name="settings">The settings for the report to be run.</param>
/// <returns>ReportResult.</returns>
/// <exception cref="System.ArgumentException">
/// The report identifier resource is not a report.
/// </exception>
/// <exception cref="PlatformSecurityException">
/// The user lacks read access to <paramref name="reportId"/>.
/// </exception>
public ReportResult RunReport(long reportId, ReportSettings settings)
{
ReportCompletionData completionData = PrepareReport(reportId, settings);
return(completionData.PerformRun( ));
}
public void Setup()
{
reportSettings = new ReportSettings();
}
/// <summary>
/// Runs the report.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="reportSettings">The settings.</param>
/// <param name="suppressPreload">Pass true if the report has already been preloaded.</param>
/// <returns>ReportResult.</returns>
/// <exception cref="System.ArgumentException">@The report identifier resource is not a report.;reportId</exception>
public ReportCompletionData PrepareReport(Model.Report report, ReportSettings reportSettings, bool suppressPreload = false)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
if (reportSettings == null)
{
reportSettings = new ReportSettings( );
}
StructuredQuery structuredQuery;
PreparedQuery preparedReport;
PreparedQuery preparedRollup;
using (EDC.ReadiNow.Diagnostics.Profiler.Measure("Prepare report run"))
using (MessageContext messageContext = new MessageContext("Reports"))
using (new SecurityBypassContext( ))
{
// Get the structured query
structuredQuery = GetStructuredQuery(report, reportSettings, suppressPreload);
// Handle metadata-only request
if (reportSettings.RequireSchemaMetadata)
{
ReportResult reportResult = new ReportResult(report, structuredQuery, null, null, null, reportSettings);
return(new ReportCompletionData(reportResult));
}
// Prepare query settings
preparedReport = PrepareReportRun(structuredQuery, reportSettings);
preparedReport.QuerySettings.Hint = "Rpt-" + report.Id.ToString( );
// Handle rollups
preparedRollup = PrepareReportRollupRun(report, preparedReport.StructuredQuery, reportSettings, preparedReport.QuerySettings);
}
Func <ReportResult> resultCallback = () =>
{
ReportResult reportResult = null;
QueryResult queryResult = null;
QueryResult rollupResult = null;
using (new SecurityBypassContext( ))
{
// Execute the query
queryResult = QueryRunner.ExecuteQuery(preparedReport.StructuredQuery, preparedReport.QuerySettings);
// Execute the rollup query
if (preparedRollup.StructuredQuery != null)
{
rollupResult = QueryRunner.ExecuteQuery(preparedRollup.StructuredQuery, preparedRollup.QuerySettings);
}
// Package up the result.
reportResult = new ReportResult(report,
preparedReport.StructuredQuery, queryResult,
preparedRollup.ClientAggregate, rollupResult,
reportSettings);
}
return(reportResult);
};
// Create cache key (null indicates report is not cacheable)
IQueryRunnerCacheKey reportCacheKey = null;
IQueryRunnerCacheKey rollupCacheKey = null;
ReportResultCacheKey reportResultCacheKey = null;
reportCacheKey = QueryRunnerCacheKeyProvider.CreateCacheKey(preparedReport.StructuredQuery, preparedReport.QuerySettings);
if (reportCacheKey != null)
{
if (preparedRollup.StructuredQuery != null)
{
rollupCacheKey = QueryRunnerCacheKeyProvider.CreateCacheKey(preparedRollup.StructuredQuery, preparedRollup.QuerySettings);
}
reportResultCacheKey = new ReportResultCacheKey(reportSettings, reportCacheKey, rollupCacheKey);
}
// Create completion result
ReportCompletionData completionData = new ReportCompletionData( );
completionData.ResultCallback = resultCallback;
completionData.ResultCacheKey = reportResultCacheKey;
completionData.CacheContextDuringPreparation = CacheContext.GetContext( );
return(completionData);
}
public ReportController(IOptions <ReportSettings> reportSettings, IReportService reportService)
{
_reportSettings = reportSettings.Value;
_reportService = reportService;
}
private PreparedQuery PrepareReportRollupRun(Model.Report report, StructuredQuery structuredQuery, ReportSettings reportSettings, QuerySettings nonRollupQuerySettings)
{
StructuredQuery rollupQuery = null;
ClientAggregate clientAggregate = null;
StructuredQuery optimisedQuery;
QuerySettings rollupSettings;
bool adhocRollup;
bool reportRollup;
adhocRollup = reportSettings.ReportParameters != null && reportSettings.ReportParameters.GroupAggregateRules != null;
reportRollup = !adhocRollup && report.ReportColumns.Any(rc => rc.ColumnRollup.Count > 0 || rc.ColumnGrouping.Count > 0);
if (adhocRollup)
{
clientAggregate = ApplyAdhocAggregates(reportSettings.ReportParameters.GroupAggregateRules, structuredQuery);
}
else if (reportRollup)
{
clientAggregate = new ClientAggregate(report, structuredQuery);
clientAggregate.IncludeRollup = true;
}
else if (report.RollupGrandTotals != null || report.RollupSubTotals != null || report.RollupOptionLabels != null)
{
return(new PreparedQuery
{
ClientAggregate = new ClientAggregate( )
});
}
else
{
return(new PreparedQuery( ));
}
// Clone the query, so that runs and rollups won't intefere with each others caches if they mutate the structure
// In particular, calculated columns get evaluated during execution and mutate the query .. but only if the result doesn't come from cache, but this interferes with the rollup cache key.
// Ideally, both calculations and optimisations would be provided in layers, and both applied, and cached, before either normal or rollup executions are run.
rollupQuery = structuredQuery.DeepCopy( );
// A poor proxy for determining that this is not a pivot chart.
bool isGroupedReport = !(reportSettings.ReportParameters != null &&
reportSettings.ReportParameters.GroupAggregateRules != null &&
reportSettings.ReportParameters.GroupAggregateRules.IgnoreRows);
if (isGroupedReport)
{
ReportRollupHelper.EnsureShowTotalsHasCount(rollupQuery, clientAggregate);
}
// Remove unused columns
bool supportQuickSearch = !string.IsNullOrWhiteSpace(reportSettings.QuickSearch);
optimisedQuery = ReportRollupHelper.RemoveUnusedColumns(rollupQuery, clientAggregate, supportQuickSearch);
rollupSettings = new QuerySettings
{
SecureQuery = nonRollupQuerySettings.SecureQuery,
SupportClientAggregate = true,
SupportPaging = false,
QuickSearchTerm = reportSettings.QuickSearch,
SupportQuickSearch = supportQuickSearch, // rollups query support quick search.
ClientAggregate = clientAggregate,
AdditionalOrderColumns = BuildAdditionOrderColumnDictionary(optimisedQuery, clientAggregate),
FullAggregateClustering = true,
Hint = "RptRollup-" + report.Id,
TargetResource = nonRollupQuerySettings.TargetResource,
IncludeResources = nonRollupQuerySettings.IncludeResources,
ExcludeResources = nonRollupQuerySettings.ExcludeResources
};
// Note : do not apply quick search filter to rollups (for scalability reasons)
PreparedQuery preparedQuery = new PreparedQuery
{
ClientAggregate = clientAggregate,
StructuredQuery = optimisedQuery,
QuerySettings = rollupSettings
};
return(preparedQuery);
}
private IDataNavigator PrepareDateTimeGrouping ()
{
Console.WriteLine("PrepareDateTimeGrouping ()");
GroupColumn gc = new GroupColumn("RandomDate",1,ListSortDirection.Ascending);
ReportSettings rs = new ReportSettings();
rs.GroupColumnsCollection.Add(gc);
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(this.table,rs);
return dm.GetNavigator;
}
public void SupportsAutoCondense_with_null_allReportTypes_should_throw_exception()
{
var settings = new ReportSettings("Html", 123);
settings.SupportsAutoCondense(null);
}
public void SortChildrenDescending()
{
ReportSettings rs = new ReportSettings();
GroupColumn gc = new GroupColumn("GroupItem",1,ListSortDirection.Ascending);
rs.GroupColumnsCollection.Add(gc);
SortColumn sc = new SortColumn("Last",ListSortDirection.Descending);
rs.SortColumnsCollection.Add(sc);
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(this.table,rs);
var dataNavigator = dm.GetNavigator;
string compare = String.Empty;
while (dataNavigator.MoveNext())
{
DataRow dr = dataNavigator.Current as DataRow;
var result = dr[3].ToString();
Assert.That(compare,Is.LessThan(result));
if (dataNavigator.HasChildren)
{
string compareChild = String.Empty;
var childNavigator = dataNavigator.GetChildNavigator;
do
{
DataRow childRow = childNavigator.Current as DataRow;
var childResult = childRow[1].ToString();
if (!String.IsNullOrEmpty(compareChild)) {
Assert.LessOrEqual(childResult,compareChild);
}
// Console.WriteLine("\t{0}",childResult);
compareChild = childResult;
}
while (childNavigator.MoveNext());
}
compare = result;
}
}
/// <summary>
/// Recursively writes formatted project category to a string buffer
/// </summary>
/// <param name="OutputWriter">Output string writer (buffer is appended to)</param>
/// <param name="InReportSettings">Settings</param>
/// <param name="InCategory">Category data to write</param>
/// <param name="bIncludeCategoryHeader">Include the category header></param>
/// <param name="InIndentLevel">Indent level</param>
static void WriteCategoryChangesRecursively(StringWriter OutputWriter, ReportSettings InReportSettings, ProjectCategory InCategory, bool bIncludeCategoryHeader, int InIndentLevel)
{
// Indent items beneath the header!
int NextIndentLevel = InIndentLevel;
if (bIncludeCategoryHeader)
{
NextIndentLevel += 1;
}
if (InReportSettings.Format == P4ParsedChangelist.EExportFormats.EF_PlainText)
{
if (bIncludeCategoryHeader)
{
// Category name header
for (int IndentIndex = 0; IndentIndex < InIndentLevel; ++IndentIndex)
{
OutputWriter.Write(InReportSettings.IndentText);
}
OutputWriter.Write(InReportSettings.BulletText);
OutputWriter.WriteLine(InCategory.Name);
}
}
// Recurse!
foreach (var CurSubcategory in InCategory.Subcategories)
{
bool bIncludeSubcategoryHeader = true;
WriteCategoryChangesRecursively(OutputWriter, InReportSettings, CurSubcategory, bIncludeSubcategoryHeader, NextIndentLevel);
}
if (InReportSettings.Format == P4ParsedChangelist.EExportFormats.EF_PlainText)
{
// Change description
foreach (var CurChange in InCategory.Changes)
{
String OneLineSummary = CurChange.BriefDescription;
// Prefix the summary with the "type" of change, if we need to
if (InReportSettings.bPrefixChangesWithType && CurChange.Type != EChangeType.Unknown)
{
String ChangeTypeName = String.Empty;
switch (CurChange.Type)
{
case EChangeType.Fix:
ChangeTypeName = "Fix";
break;
case EChangeType.Change:
ChangeTypeName = "Change";
break;
case EChangeType.New:
ChangeTypeName = "New";
break;
}
OneLineSummary = ChangeTypeName + ": " + OneLineSummary;
}
// Append the TTP numbers too if we need to
if (InReportSettings.bAppendTTPNumbersToOneLineSummary && CurChange.TTPNumbers.Count > 0)
{
OneLineSummary += " (";
bool bIsFirstTTPNumber = true;
foreach (var CurTTPNumber in CurChange.TTPNumbers)
{
if (!bIsFirstTTPNumber)
{
OneLineSummary += ", ";
}
OneLineSummary += "TTP " + CurTTPNumber.ToString();
bIsFirstTTPNumber = false;
}
OneLineSummary += ")";
}
// Append the P4 changelist numbers too if we need to
if (InReportSettings.bAppendChangelistNumbersToOneLineSummary)
{
OneLineSummary += " [CL " + CurChange.ChangelistNumber + "]";
}
// One-line summary
for (int IndentIndex = 0; IndentIndex < NextIndentLevel; ++IndentIndex)
{
OutputWriter.Write(InReportSettings.IndentText);
}
OutputWriter.Write(InReportSettings.BulletText);
OutputWriter.WriteLine(OneLineSummary);
// Extra description lines
{
foreach (string CurLine in CurChange.ExtraDescription)
{
// Indent
int ExtraTextIndentLevel = NextIndentLevel + 1;
for (int IndentIndex = 0; IndentIndex < ExtraTextIndentLevel; ++IndentIndex)
{
OutputWriter.Write(InReportSettings.IndentText);
}
OutputWriter.Write(InReportSettings.BulletText);
OutputWriter.WriteLine(CurLine);
}
}
}
}
}
// Генерация карты наладки
private void btnGenerate_Click(object sender, EventArgs e)
{
ReportSettings settings = AdditionalToolParameters.gostReportSettings;
GenerateFileReport(settings.DefaultReportPath, settings.DefaultReportName);
}
private IDataNavigator PrepareStringGrouping ()
{
GroupColumn gc = new GroupColumn("GroupItem",1,ListSortDirection.Ascending);
ReportSettings rs = new ReportSettings();
rs.GroupColumnsCollection.Add(gc);
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(this.contributorCollection,rs);
return dm.GetNavigator;
}
private void SetupViewer (ReportModel reportModel)
{
this.pages = new PagesCollection();
this.reportSettings = reportModel.ReportSettings;
this.AdjustDrawArea();
}
