private void FastExcelWriteAddRowDemo(FileInfo outputFile)
{
Console.WriteLine();
Console.WriteLine("DEMO WRITE 3");
Stopwatch stopwatch = new Stopwatch();
using (FastExcel.FastExcel fastExcel = new FastExcel.FastExcel(outputFile))
{
Worksheet worksheet = new Worksheet();
for (int rowNumber = 1; rowNumber < NumberOfRecords; rowNumber++)
{
worksheet.AddRow(1 * DateTime.Now.Millisecond
, 2 * DateTime.Now.Millisecond
, 3 * DateTime.Now.Millisecond
, 4 * DateTime.Now.Millisecond
, 45678854
, 87.01d
, "Test 2" + rowNumber
, DateTime.Now.ToLongTimeString());
}
stopwatch.Start();
Console.WriteLine("Writing using AddRow(params object[])...");
fastExcel.Write(worksheet, "sheet4");
}
Console.WriteLine(string.Format("Writing using AddRow(params object[]) took {0} seconds", stopwatch.Elapsed.TotalSeconds));
}
private static void GenerateUnreferencedAssembliesPage(Worksheet missingAssembliesPage, ReportingResult analysisResult)
{
List <string> missingAssembliesPageHeader = new List <string>()
{
LocalizedStrings.AssemblyHeader, LocalizedStrings.UsedBy, LocalizedStrings.MissingAssemblyStatus
};
int detailsRows = 0;
missingAssembliesPage.AddRow(missingAssembliesPageHeader.ToArray());
detailsRows++;
var unresolvedAssembliesMap = analysisResult.GetUnresolvedAssemblies();
foreach (var unresolvedAssemblyPair in unresolvedAssembliesMap.OrderBy(asm => asm.Key))
{
if (unresolvedAssemblyPair.Value.Any())
{
foreach (var usedIn in unresolvedAssemblyPair.Value)
{
missingAssembliesPage.AddRow(unresolvedAssemblyPair.Key, usedIn, LocalizedStrings.UnresolvedUsedAssembly);
detailsRows++;
}
}
else
{
missingAssembliesPage.AddRow(unresolvedAssemblyPair.Key, String.Empty, LocalizedStrings.UnresolvedUsedAssembly);
}
}
// Generate the pretty table
missingAssembliesPage.AddTable(1, detailsRows, 1, missingAssembliesPageHeader.ToArray());
missingAssembliesPage.AddColumnWidth(40, 40, 30);
}
private void GenerateBreakingChangesPage(Worksheet worksheet, IEnumerable <BreakingChangeDependency> breakingChanges)
{
var row = 1;
var header = new[]
{
"Break ID",
"API",
"Assembly",
"Title",
"Scope",
"Quirked",
"Requires Retargeting",
"Build Time",
"VersionBroken",
"Version Fixed",
"Details",
"Suggestion",
"Analyzer Status",
"Link",
"Investigated"
};
worksheet.AddRow(header);
foreach (var breakingChange in breakingChanges)
{
var rowContent = new object[]
{
breakingChange.Break.Id,
breakingChange.Member.MemberDocId,
breakingChange.DependantAssembly.ToString(),
breakingChange.Break.Title,
breakingChange.Break.ImpactScope.ToString(),
breakingChange.Break.IsQuirked.ToString((IFormatProvider)CultureInfo.CurrentUICulture),
breakingChange.Break.IsRetargeting.ToString((IFormatProvider)CultureInfo.CurrentUICulture),
breakingChange.Break.IsBuildTime.ToString((IFormatProvider)CultureInfo.CurrentUICulture),
breakingChange.Break.VersionBroken.ToString(),
breakingChange.Break.VersionFixed?.ToString() ?? string.Empty,
breakingChange.Break.Details,
breakingChange.Break.Suggestion,
breakingChange.Break.SourceAnalyzerStatus.ToString(),
string.IsNullOrWhiteSpace(breakingChange.Break.Link) ? "No link" : CreateHyperlink("Link", breakingChange.Break.Link),
string.Empty
};
worksheet.AddRow(rowContent);
row++;
}
worksheet.AddTable(1, row, 1, header);
worksheet.AddColumnWidth(10, 10, 30, 30, 20, 10, 10, 10, 10, 30, 30, 10, 10, 10);
}
private void GenerateSummaryPage(Worksheet summaryPage, ReportingResult analysisResult)
{
var targetNames = _mapper.GetTargetNames(analysisResult.Targets, alwaysIncludeVersion: true);
// This is the submission id
summaryPage.AddRow(LocalizedStrings.SubmissionId, AddSubmissionLink(analysisResult.SubmissionId));
// This is the description of the app
summaryPage.AddRow(LocalizedStrings.Description, _description);
// This is the target list that was submitted to the service.
summaryPage.AddRow(LocalizedStrings.Targets, string.Join(",", targetNames));
// Add an empty row.
summaryPage.AddRow();
if (analysisResult.GetAssemblyUsageInfo().Any())
{
var assemblyInfoHeader = new List <string> {
LocalizedStrings.AssemblyHeader, "Target Framework"
};
assemblyInfoHeader.AddRange(targetNames);
int tableRowCount = 0;
summaryPage.AddRow(assemblyInfoHeader.ToArray());
tableRowCount++;
foreach (var item in analysisResult.GetAssemblyUsageInfo().OrderBy(a => a.SourceAssembly.AssemblyIdentity))
{
var summaryData = new List <object>()
{
analysisResult.GetNameForAssemblyInfo(item.SourceAssembly), item.SourceAssembly.TargetFrameworkMoniker ?? string.Empty
};
// TODO: figure out how to add formatting to cells to show percentages.
summaryData.AddRange(item.UsageData.Select(pui => (object)Math.Round(pui.PortabilityIndex * 100.0, 2)));
summaryPage.AddRow(summaryData.ToArray());
tableRowCount++;
}
summaryPage.AddConditionalFormatting(6, analysisResult.GetAssemblyUsageInfo().Count(), 3, analysisResult.Targets.Count);
summaryPage.AddTable(5, tableRowCount, 1, assemblyInfoHeader.ToArray());
var columnWidths = new List <double>
{
ColumnWidths.SummaryPage.AssemblyName,
ColumnWidths.SummaryPage.TFM
};
columnWidths.AddRange(Enumerable.Repeat(ColumnWidths.Targets, analysisResult.Targets.Count)); // Targets
summaryPage.AddColumnWidth(columnWidths);
}
summaryPage.AddRow();
summaryPage.AddRow(LocalizedStrings.CatalogLastUpdated, _catalogLastUpdated.ToString("D", CultureInfo.CurrentCulture));
summaryPage.AddRow(LocalizedStrings.HowToReadTheExcelTable);
}
private void FastExcelWriteAddRowDemo(FileInfo outputFile)
{
Console.WriteLine();
Console.WriteLine("DEMO WRITE 3");
Stopwatch stopwatch = new Stopwatch();
using (FastExcel.FastExcel fastExcel = new FastExcel.FastExcel(outputFile))
{
Worksheet worksheet = new Worksheet();
for (int rowNumber = 1; rowNumber < NumberOfRecords; rowNumber++)
{
worksheet.AddRow(1 * DateTime.Now.Millisecond
, 2 * DateTime.Now.Millisecond
, 3 * DateTime.Now.Millisecond
, 4 * DateTime.Now.Millisecond
, 45678854
, 87.01d
, "Test 2" + rowNumber
, DateTime.Now.ToLongTimeString());
}
stopwatch.Start();
Console.WriteLine("Writing using AddRow(params object[])...");
fastExcel.Write(worksheet, "sheet4");
}
Console.WriteLine(string.Format("Writing using AddRow(params object[]) took {0} seconds", stopwatch.Elapsed.TotalSeconds));
}
private void GenerateNuGetInfoPage(Worksheet page, ReportingResult analysisResult)
{
bool showAssemblyName = analysisResult.NuGetPackages.Any(p => !string.IsNullOrEmpty(p.AssemblyInfo));
var headerList = new List <string>()
{
LocalizedStrings.PackageIdHeader
};
headerList.AddRange(_mapper.GetTargetNames(analysisResult.Targets));
if (showAssemblyName)
{
headerList.Add(LocalizedStrings.AssemblyHeader);
}
var header = headerList.ToArray();
page.AddRow(header);
int rowCount = 1;
foreach (var nugetInfo in analysisResult.NuGetPackages)
{
var rowContent = new List <string>()
{
nugetInfo.PackageId
};
foreach (var target in analysisResult.Targets)
{
var supported = nugetInfo.SupportedVersions.TryGetValue(target, out var version) ? version : LocalizedStrings.NotSupported;
rowContent.Add(supported);
}
if (showAssemblyName && nugetInfo.AssemblyInfo != null)
{
rowContent.Add(nugetInfo.AssemblyInfo);
}
page.AddRow(rowContent.ToArray());
rowCount++;
}
page.AddTable(1, rowCount, 1, header.ToArray());
page.AddColumnWidth(70, 40, 30, 30);
}
void GenerateXlsDocument(IQueryable <IGrouping <ITask, IActivity> > activities)
{
var workbook = new Workbook();
var worksheet = new Worksheet("Sheet1")
{
GenerateXmlMap = true
};
workbook.Worksheets.Add(worksheet);
Func <string, Type, Column> column = (label, type) =>
new Column(SR.GetString(LocalizationFile, label), type);
var columns = new List <Column>
{
column("Table.HeadingTime", typeof(DateTime)),
column("Table.HeadingUser", typeof(string)),
column("Table.HeadingTask", typeof(string)),
column("Table.HeadingActivity", typeof(string))
};
worksheet.Columns.AddRange(columns);
foreach (var item in activities.OrderByDescending(a => a.Key.StartTime).ToList())
{
var task = item.Key;
var subactivities = item.Where(d => d != null).OrderByDescending(d => d.ActivityTime);
if (!subactivities.Any())
{
worksheet.AddRow(task.StartTime, task.Username,
SR.GetString(LocalizationFile, "Task." + task.TaskType), string.Empty);
}
foreach (var activity in subactivities)
{
worksheet.AddRow(activity.ActivityTime, task.Username,
SR.GetString(LocalizationFile, "Task." + task.TaskType),
SR.GetString(LocalizationFile, "Activity." + activity.ActivityType));
}
}
workbook.WriteToResponse(Context, string.Format("VersioningReport-{0:yyyy-MM-dd-HH-mm}.xls", DateTime.Now));
}
private void CopyCells(Row from, int toRowNumber)
{
var newRow = targetSheet.AddRow(toRowNumber);
var cells = from.Cells.Select(c => c.Value);
foreach (Cell cell in cells)
{
newRow.AddCell(column: cell.Column, value: cell.Value, type: cell.Type);
}
}
private void button1_Click(object sender, EventArgs e)
{
// ExStart:AddRow
// Accessing first worksheet of the Grid
Worksheet sheet = gridDesktop1.Worksheets[0];
// Adding row to the worksheet
sheet.AddRow();
// ExEnd:AddRow
MessageBox.Show("Row added.");
}
private static void GenerateOrderPage(Worksheet page, AnalyzeResponse response)
{
page.AddRow(new[] { LocalizedStrings.RecommendedOrderDetails });
page.AddRow();
var header = new[] { LocalizedStrings.AssemblyHeader };
page.AddRow(header);
int detailsRows = 1;
foreach (var assembly in response.RecommendedOrder)
{
page.AddRow(assembly);
detailsRows++;
}
// Generate the pretty table
page.AddTable(3, detailsRows, 1, header.ToArray());
page.AddColumnWidth(100);
}
private static void GenerateUnreferencedAssembliesPage(Worksheet missingAssembliesPage, AnalyzeResponse response)
{
var missingAssembliesPageHeader = new[] { LocalizedStrings.AssemblyHeader, LocalizedStrings.UsedBy, LocalizedStrings.UnresolvedAssemblyStatus };
int detailsRows = 0;
missingAssembliesPage.AddRow(missingAssembliesPageHeader.ToArray());
detailsRows++;
var unresolvedAssembliesMap = response.ReportingResult.GetUnresolvedAssemblies();
foreach (var unresolvedAssemblyPair in unresolvedAssembliesMap.OrderBy(asm => asm.Key))
{
if (unresolvedAssemblyPair.Value.Any())
{
foreach (var usedIn in unresolvedAssemblyPair.Value)
{
missingAssembliesPage.AddRow(unresolvedAssemblyPair.Key, usedIn, LocalizedStrings.UnresolvedUsedAssembly);
detailsRows++;
}
}
else
{
missingAssembliesPage.AddRow(unresolvedAssemblyPair.Key, string.Empty, LocalizedStrings.UnresolvedUsedAssembly);
detailsRows++;
}
}
if (response.Request.NonUserAssemblies != null)
{
foreach (var unresolvedAssemblyPair in response.Request.NonUserAssemblies.OrderBy(asm => asm.AssemblyIdentity))
{
missingAssembliesPage.AddRow(unresolvedAssemblyPair.AssemblyIdentity, string.Empty, LocalizedStrings.SkippedAssembly);
detailsRows++;
}
}
// Generate the pretty table
missingAssembliesPage.AddTable(1, detailsRows, 1, missingAssembliesPageHeader);
missingAssembliesPage.AddColumnWidth(40, 40, 30);
}
private void GenerateExceptionsPage(Worksheet worksheet, IList <ExceptionInfo> throwingMembers, IList <FrameworkName> targets)
{
var exceptionsPageHeader = new List <string>()
{
LocalizedStrings.AssemblyHeader, LocalizedStrings.TargetMemberHeader, LocalizedStrings.ExceptionColumnHeader
};
exceptionsPageHeader.AddRange(_mapper.GetTargetNames(targets, alwaysIncludeVersion: true));
int exceptionRows = 0;
worksheet.AddRow(exceptionsPageHeader.ToArray());
exceptionRows++;
foreach (var member in throwingMembers.OrderBy(info => info.MemberDocId))
{
var exceptionsByType = member.ExceptionsThrown.GroupBy(exc => exc.Exception, (exception, exceptionList) => new { Key = exception, exceptions = exceptionList });
foreach (var grouping in exceptionsByType)
{
var rowContent = new List <object> {
member.DefinedInAssemblyIdentity, member.MemberDocId, grouping.Key
};
var groupsByTarget = grouping.exceptions.GroupBy(exc => new FrameworkName(exc.Platform, Version.Parse(exc.Version)), (framework, exceptionList) => new { Key = framework, exceptionsByPlatform = exceptionList });
foreach (var target in targets)
{
bool hasExceptions = false;
foreach (var exceptionsByTarget in groupsByTarget)
{
if (exceptionsByTarget.Key.Equals(target))
{
hasExceptions = true;
string resourceIDHolder = string.Empty;
foreach (var exception in exceptionsByTarget.exceptionsByPlatform.OrderBy(exc => exc.RID))
{
resourceIDHolder = string.Concat(resourceIDHolder, exception.RID + ";");
}
if (resourceIDHolder.Length > 0)
{
rowContent.Add(resourceIDHolder);
}
else
{
rowContent.Add(LocalizedStrings.NoExceptionNoted);
}
}
}
if (!hasExceptions)
{
rowContent.Add(LocalizedStrings.NoExceptionNoted);
}
}
worksheet.AddRow(rowContent.ToArray());
exceptionRows++;
}
}
worksheet.AddTable(1, exceptionRows, 1, exceptionsPageHeader.ToArray());
// Generate the columns
var columnWidths = new List <double>
{
ColumnWidths.DetailsPage.AssemblyName, // Assembly name
ColumnWidths.DetailsPage.TargetMember, // Target member
ColumnWidths.DetailsPage.TargetMember // Exception Width
};
columnWidths.AddRange(Enumerable.Repeat(ColumnWidths.Targets, targets.Count)); // Targets
worksheet.AddColumnWidth(columnWidths);
}
private void GenerateDetailsPage(Worksheet detailsPage, ReportingResult analysisResult)
{
var showAssemblyColumn = analysisResult.GetAssemblyUsageInfo().Any();
var detailsPageHeader = new List <string>()
{
LocalizedStrings.TargetTypeHeader, LocalizedStrings.TargetMemberHeader
};
if (showAssemblyColumn)
{
detailsPageHeader.Add(LocalizedStrings.AssemblyHeader);
}
detailsPageHeader.AddRange(_mapper.GetTargetNames(analysisResult.Targets, alwaysIncludeVersion: true));
detailsPageHeader.Add(LocalizedStrings.RecommendedChanges);
int detailsRows = 0;
detailsPage.AddRow(detailsPageHeader.ToArray());
detailsRows++;
// Dump out all the types that were identified as missing from the target
foreach (var item in analysisResult.GetMissingTypes().OrderByDescending(n => n.IsMissing))
{
if (item.IsMissing)
{
if (!showAssemblyColumn)
{
// for a missing type we are going to dump the type name for both the target type and target member columns
var rowContent = new List <object> {
AddLink(item.TypeName), AddLink(item.TypeName)
};
rowContent.AddRange(item.TargetStatus);
rowContent.Add(item.RecommendedChanges);
detailsPage.AddRow(rowContent.ToArray());
detailsRows++;
}
else
{
foreach (var assemblies in item.UsedIn)
{
string assemblyName = analysisResult.GetNameForAssemblyInfo(assemblies);
// for a missing type we are going to dump the type name for both the target type and target member columns
var rowContent = new List <object> {
AddLink(item.TypeName), AddLink(item.TypeName), assemblyName
};
rowContent.AddRange(item.TargetStatus);
rowContent.Add(item.RecommendedChanges);
detailsPage.AddRow(rowContent.ToArray());
detailsRows++;
}
}
}
foreach (var member in item.MissingMembers.OrderBy(type => type.MemberName))
{
if (showAssemblyColumn)
{
foreach (var assem in member.UsedIn.OrderBy(asm => asm.AssemblyIdentity))
{
string assemblyName = analysisResult.GetNameForAssemblyInfo(assem);
var rowContent = new List <object> {
AddLink(item.TypeName), AddLink(member.MemberName), assemblyName
};
rowContent.AddRange(member.TargetStatus);
rowContent.Add(member.RecommendedChanges);
detailsPage.AddRow(rowContent.ToArray());
detailsRows++;
}
}
else
{
var rowContent = new List <object> {
AddLink(item.TypeName), AddLink(member.MemberName)
};
rowContent.AddRange(member.TargetStatus);
rowContent.Add(member.RecommendedChanges);
detailsPage.AddRow(rowContent.ToArray());
detailsRows++;
}
}
}
// Generate the pretty tables
detailsPage.AddTable(1, detailsRows, 1, detailsPageHeader.ToArray());
// Generate the columns
var columnWidths = new List <double>
{
ColumnWidths.DetailsPage.TargetType, // Target type
ColumnWidths.DetailsPage.TargetMember, // Target member
ColumnWidths.DetailsPage.AssemblyName // Assembly name
};
columnWidths.AddRange(Enumerable.Repeat(ColumnWidths.Targets, analysisResult.Targets.Count)); // Targets
columnWidths.Add(ColumnWidths.DetailsPage.RecommendedChanges); // Recommended changes
detailsPage.AddColumnWidth(columnWidths);
}
protected void Page_PreRender(object sender, EventArgs e)
{
var pageNumber = GetPageNumber();
var pageSize = GetPageSize();
using (var connection = new DataConnection())
{
Expression <Func <ITask, bool> > taskFilter = t => true;
Expression <Func <ITaskTarget, bool> > targetFilter = t => true;
if (!string.IsNullOrWhiteSpace(Username.Text))
{
taskFilter = taskFilter.And(d => d.Username.Contains(Username.Text));
}
if (LogType.SelectedValue != "All" && !string.IsNullOrWhiteSpace(LogType.SelectedValue))
{
taskFilter = taskFilter.And(d => d.TaskType == LogType.SelectedValue);
}
if (DataType.SelectedValue != "All" && !string.IsNullOrWhiteSpace(DataType.SelectedValue))
{
targetFilter = targetFilter.And(d => d.TargetDataSourceId.Contains(string.Format(@"_interfaceType_='{0}'", DataType.SelectedValue.Replace(".", @"\."))));
}
var activities = from t in connection.Get <ITask>().Where(taskFilter)
join tt in connection.Get <ITaskTarget>().Where(targetFilter) on t.TaskTargetId equals tt.Id
join a in connection.Get <IActivity>() on t.Id equals a.TaskId into ats
from at in ats.DefaultIfEmpty()
select new
{
Time = at == null ? t.StartTime : at.ActivityTime,
t.Username,
t.TaskType,
ActivityType = at == null ? null : at.ActivityType,
t.CultureName,
TaskTarget = tt,
Activity = at
};
var from = FromDateWidget.SelectedDate;
var to = ToDateWidget.SelectedDate;
activities = activities.Where(d => d.Time >= from && d.Time < to.AddDays(1));
activities = activities.Where(item => !(item.ActivityType == null &&
new[] { "edit", "add", "rollback", "delete" }.Contains(item.TaskType.ToLower())))
.OrderByDescending(d => d.Time);
switch (SortColumn)
{
case Column.Time:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.Time)
: activities.OrderByDescending(d => d.Time);
break;
case Column.User:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.Username)
: activities.OrderByDescending(d => d.Username);
break;
case Column.Task:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.TaskType)
: activities.OrderByDescending(d => d.TaskType);
break;
}
string eventTarget = Request.Form["__EVENTTARGET"];
if (eventTarget == "export")
{
var workbook = new Workbook();
var worksheet = new Worksheet("Sheet1")
{
GenerateXmlMap = true
};
workbook.Worksheets.Add(worksheet);
Func <string, Type, XlsColumn> column = (label, type) =>
new XlsColumn(SR.GetString(LocalizationFileName, label), type);
var columns = new List <XlsColumn>
{
column("Table.HeadingTime", typeof(DateTime)),
column("Table.HeadingUser", typeof(string)),
column("Table.HeadingTask", typeof(string)),
column("Table.HeadingActivity", typeof(string)),
column("Table.HeadingTitle", typeof(string)),
column("Table.HeadingType", typeof(string))
};
if (IsMultiLocale)
{
columns.Add(new XlsColumn(SR.GetString("Composite.Plugins.XsltBasedFunction", "EditXsltFunction.LabelActiveLocales"), typeof(string)));
}
worksheet.Columns.AddRange(columns);
foreach (var item in activities)
{
var parameters = new object[]
{
item.Time,
item.Username ?? string.Empty,
item.TaskType != null?GetTaskLabel(item.TaskType) : string.Empty,
item.ActivityType != null?GetActivityLabel(item.ActivityType) : string.Empty,
GetTitle(item.TaskTarget),
GetTargetType(item.TaskTarget)
};
if (IsMultiLocale)
{
parameters = parameters.Concat(new object[] { GetCulture(item.CultureName) }).ToArray();
}
worksheet.AddRow(parameters);
}
workbook.WriteToResponse(Context, string.Format("ContentModificationLog-{0:yyyy-MM-dd-HH-mm}.xls", DateTime.Now));
return;
}
activities = activities.Skip(pageSize * (pageNumber - 1)).Take(pageSize + 1);
PrevPage.Attributes["client_isdisabled"] = (pageNumber == 1).ToString().ToLower();
NextPage.Attributes["client_isdisabled"] = (activities.Count() <= pageSize).ToString().ToLower();
var result = activities.Take(pageSize).ToList();
LogHolder.DataSource = result.Select(d =>
new
{
d.Time,
d.Username,
d.ActivityType,
ActivityLabel = string.IsNullOrEmpty(d.ActivityType) ? "" : GetActivityLabel(d.ActivityType),
d.TaskType,
TaskLabel = GetTaskLabel(d.TaskType),
Title = GetTitle(d.TaskTarget),
EntityToken = GetEntityToken(d.TaskTarget),
TargetType = GetTargetType(d.TaskTarget),
d.CultureName,
RestoreAction = GetRestoreAction(d.Activity)
}).ToList();
LogHolder.DataBind();
}
SetPageNumber(pageNumber);
}
public static void AddRow(this Worksheet ws, params object[] data) => ws.AddRow((IEnumerable <object>)data);
protected void Page_Load(object sender, EventArgs e)
{
var compareId = new Guid(Request["compare"]);
var compareToId = new Guid(Request["compareTo"]);
var compareData = DataFacade.GetData <IDataChanges>(d => d.ActivityId == compareId).ToList();
var compareToData = DataFacade.GetData <IDataChanges>(d => d.ActivityId == compareToId).ToList();
var compareReport = new XElement("CompareReport");
var targetIds = compareData.Select(d => d.TargetId).Union(compareToData.Select(d => d.TargetId));
Func <IEnumerable <IDataChanges>, Guid, XElement> getXml = (data, targetId) =>
XElement.Parse(data.Where(d => d.TargetId == targetId).Select(d => d.SerializedData).FirstOrDefault()
?? "<Data />");
foreach (var targetId in targetIds)
{
var compareXml = getXml(compareData, targetId);
var compareToXml = getXml(compareToData, targetId);
Guid?pageId = ExtractPageId(compareXml) ?? ExtractPageId(compareToXml);
var helper = new DataTypeHelper(targetId, pageId);
var Data = new XElement("Data", new XAttribute("caption", helper.GetCaption()));
var attributeNames = compareXml.Attributes().Select(a => a.Name.LocalName)
.Union(compareToXml.Attributes().Select(a => a.Name.LocalName))
.Except(helper.GetKeyPropertyNames());
foreach (var attributeName in attributeNames)
{
var compareField = compareXml.Attribute(attributeName);
var compareToField = compareToXml.Attribute(attributeName);
var property = new XElement("Property",
new XAttribute("Label", helper.GetFieldLabel(attributeName)),
new XAttribute("Equals", helper.EqualsValueAttributes(compareField, compareToField)),
new XAttribute("IsMarkup", ismarkupystify(helper.GetValue(compareField))),
new XElement("Compare", stringelingify(helper.GetValue(compareField))),
new XElement("CompareTo", stringelingify(helper.GetValue(compareToField)))
);
Data.Add(property);
}
compareReport.Add(Data);
}
var compareTable = new XElement("compareTable");
var sb = new StringBuilder();
var xws = new XmlWriterSettings()
{
OmitXmlDeclaration = true
};
using (var writer = XmlWriter.Create(sb, xws))
{
var settings = new XsltSettings(false, true);
var xslTransform = new XslCompiledTransform();
xslTransform.Load(
Server.MapPath(Path.Combine(Page.TemplateSourceDirectory, "compare.xslt")),
settings,
new XmlUrlResolver()
);
xslTransform.Transform(compareReport.CreateReader(), writer);
}
Holder.Controls.Add(new LiteralControl(sb.ToString()));
string eventTarget = Request.Form["__EVENTTARGET"];
if (eventTarget == "export")
{
var workbook = new Workbook();
var worksheet = new Worksheet("Sheet1")
{
GenerateXmlMap = true
};
workbook.Worksheets.Add(worksheet);
var columns = new List <Column>()
{
new Column(string.Empty, typeof(string)),
new Column(SR.GetString("Composite.Versioning.ContentVersioning", "Table.HeadingNew"), typeof(string)),
new Column(SR.GetString("Composite.Versioning.ContentVersioning", "Table.HeadingOld"), typeof(string))
};
worksheet.Columns.AddRange(columns);
foreach (var data in compareReport.Elements("Data"))
{
worksheet.AddRow(data.Attribute("caption").Value, string.Empty, string.Empty);
foreach (var property in data.Elements("Property"))
{
var equals = property.Attribute("Equals").Value == "true";
var label = property.Attribute("Label").Value;
var newvalue = property.Element("Compare").Value;
var oldvalue = property.Element("CompareTo").Value;
DateTime date;
if (DateTime.TryParse(newvalue, out date))
{
newvalue = date.ToString("yyyy-MM-dd HH:mm:ss");
}
if (DateTime.TryParse(oldvalue, out date))
{
oldvalue = date.ToString("yyyy-MM-dd HH:mm:ss");
}
worksheet.AddBoldRow(!equals, label, newvalue, oldvalue);
}
worksheet.AddRow(string.Empty, string.Empty, string.Empty);
}
workbook.WriteToResponse(Context, string.Format("VersioningReport-{0:yyyy-MM-dd-HH-mm}.xls", DateTime.Now));
return;
}
}
