private Dictionary <int, List <InstanceReportColumn> > GetSegmentScenarioCalendars(List <InstanceReportColumn> uniqueSegmentColumns)
{
Dictionary <int, List <InstanceReportColumn> > calendarsBySegment = new Dictionary <int, List <InstanceReportColumn> >();
foreach (InstanceReportColumn uSegCol in uniqueSegmentColumns)
{
List <InstanceReportColumn> uniqueCalendars = new List <InstanceReportColumn>();
foreach (InstanceReportColumn anyCol in this.Columns)
{
if (!uSegCol.SegmentAndScenarioEquals(anyCol))
{
continue;
}
if (!ReportUtils.Exists(uniqueCalendars, uCal => uCal.ReportingPeriodEquals(anyCol)))
{
//create a clone so that we can slowly digest this data without affecting other references
InstanceReportColumn clone = (InstanceReportColumn)anyCol.Clone();
uniqueCalendars.Add(clone);
}
}
if (uniqueCalendars.Count > 0)
{
calendarsBySegment[uSegCol.Id] = uniqueCalendars;
}
}
return(calendarsBySegment);
}
private void ValidateEquityStructure(string equityMembersXml, out XmlDocument membersXDoc)
{
membersXDoc = new XmlDocument();
bool hasBeginningBalance = ReportUtils.Exists(this.Rows, row => row.IsBeginningBalance);
if (!hasBeginningBalance)
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingBeginningBalance);
}
bool hasEndingBalance = ReportUtils.Exists(this.Rows, row => row.IsEndingBalance);
if (!hasEndingBalance)
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingEndingBalance);
}
string equityMembersXmlPath = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Rules, equityMembersXml);
if (!File.Exists(equityMembersXmlPath))
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingMembersFile);
}
try
{
membersXDoc.Load(equityMembersXmlPath);
}
catch
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MembersFileFormat);
}
}
private static List <string> GetSectionsList(IReadOnlyList <SegmentSection> segmentSections, ref int charsLength)
{
var items = new List <string>();
foreach (var section in segmentSections)
{
if (section.RevisionMarker != null && section.RevisionMarker.Type == RevisionMarker.RevisionType.Delete)
{
//ignore from the comparison process
}
else
{
if (section.Type == SegmentSection.ContentType.Text)
{
var strLists = ReportUtils.GetTextSections(section.Content);
foreach (var part in strLists)
{
foreach (var letter in part)
{
items.Add(letter.ToString());
charsLength++;
}
}
}
else
{
charsLength++;
items.Add(section.Content);
}
}
}
return(items);
}
private static IEnumerable <CveSummaryModel> SortCves(string sortedBy, IEnumerable <CveSummaryModel> cves)
{
switch (sortedBy)
{
case "severity":
return(ReportUtils.GetSortedCvesBySeverity(cves));
case "severityDesc":
return(ReportUtils.GetSortedCvesBySeverity(cves).Reverse());
case "name":
return(cves.OrderByDescending(x => x.Name));
case "nameDesc":
return(cves.OrderBy(x => x.Name));
case "frequency":
return(cves.OrderByDescending(x => x.Frequency));
case "frequencyDesc":
return(cves.OrderBy(x => x.Frequency));
default:
return(ReportUtils.GetSortedCvesBySeverity(cves));
}
}
public TimeSpan GetTimeLeftToEnd(ReportItem report)
{
TimeSpan hoursTarget = new TimeSpan(Settings.HoursTarget, 0, 0);
TimeSpan totalTime = ReportUtils.ToTimeSpan(report);
return(hoursTarget.Subtract(totalTime));
}
public IActionResult GetReport([FromBody] ReportInfo RequestInfo)
{
try
{
if (RequestInfo.reportType != null)
{
ReportUtils newReportUtils = new ReportUtils();
if (RequestInfo.reportType == "Overdue")
{
var overdue = newReportUtils.RunOverdueReport(RequestInfo.reportQty);
return(Json(overdue));
}
else if (RequestInfo.reportType == "Popular")
{
var Popular = newReportUtils.RunPopularReport(RequestInfo.reportQty);
return(Json(Popular));
}
else if (RequestInfo.reportType == "Customer")
{
var bestCust = newReportUtils.RunCustomerReport(RequestInfo.reportQty);
return(Json(bestCust));
}
}
return(NotFound($"Your Inputs are Bad! Report Type: {RequestInfo.reportType}, Report Quantity: {RequestInfo.reportQty}"));
}
catch (Exception e)
{
return(NotFound("Couldnt get A report, given the inputs! " + e));
}
}
public void CreateTargetMessages()
{
var statisticsTarget = new MonthlyStatisticsService().Calculate(ReportSummary);
if (!IsClosed)
{
HoursTargetMessage = $"Minha Meta é {ReportUtils.FormatHour(statisticsTarget.TimeTarget)} hrs";
if (statisticsTarget.TimeLeftToEnd.TotalMinutes > 0)
{
HoursPerDayMessage = $"Preciso de {ReportUtils.FormatHour(statisticsTarget.TimePerDay)} hrs por dia";
HoursLeftMessage = $"Faltam {ReportUtils.FormatHour(statisticsTarget.TimeLeftToEnd)} para acabar";
}
else
{
HoursPerDayMessage = "Você fechou suas horas!";
HoursLeftMessage = "";
}
}
else
{
HoursLeftMessage = "";
if (statisticsTarget.TimeLeftToEnd.TotalMinutes > 0)
{
HoursPerDayMessage = $"Faltou {ReportUtils.FormatHour(statisticsTarget.TimeLeftToEnd)} para acabar";
}
else
{
HoursPerDayMessage = "Você fechou suas horas!";
}
}
}
private TimeSpan GetTimePerDay(ReportItem report)
{
int daysLeftInMonth = DateTime.DaysInMonth(report.Year, report.Month) - DateTime.Now.Day + 1;
if (Settings.GetDaysOfWeek().Count() > 0)
{
daysLeftInMonth = ReportUtils.GetEffectiveDaysInMonth(Settings.GetDaysOfWeek());
}
if (daysLeftInMonth <= 0)
{
daysLeftInMonth = 1;
}
TimeSpan timeLeftToEnd = GetTimeLeftToEnd(report);
if (timeLeftToEnd.TotalMinutes > 0)
{
double minutesPerDay = timeLeftToEnd.TotalMinutes / daysLeftInMonth;
return(new TimeSpan(0, Convert.ToInt16(minutesPerDay), 0));
}
else
{
return(new TimeSpan(0, 0, 0));
}
}
private void DrawReportFooterSummary(PagingSetup pagingSetup, PdfDocument document,
RemovalNote removalNote, string removalUser)
{
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Justify,
pagingSetup.RegularLineHeight,
string.Format("Người hủy: {0} Ngày hủy: {1}",
removalUser, removalNote.RemovalDate.ToString(CommonConstant.DateFormatDisplay)));
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Justify,
pagingSetup.RegularLineHeight,
string.Format("Lý do hủy: {0}", removalNote.RemovalReason));
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Left,
pagingSetup.RegularLineHeight,
string.Format("Phương pháp hủy mẫu:.............................................................................................................................................."));
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Justify,
pagingSetup.RegularLineHeight,
string.Format("Quản lý mẫu kiểm tra:..........................................................................................................Ngày.....tháng.....năm....."));
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Justify,
pagingSetup.RegularLineHeight,
string.Format("Quản lý an toàn:..................................................................................................................Ngày.....tháng.....năm....."));
ReportUtils.DrawParagraphLine(pagingSetup, document,
pagingSetup.RegularFont, XParagraphAlignment.Justify,
pagingSetup.RegularLineHeight,
string.Format("Trưởng PTN phê duyệt:........................................................................................................Ngày.....tháng.....năm....."));
}
public IActionResult PrintAllEvents()
{
return(File(
PrintEvents(null, out DateTime generateTime),
MediaTypeNames.Application.Octet,
ReportUtils.BuildFileName("Events", generateTime, OutputFormat.Xml2003)));
}
private void DrawReportSummary(PagingSetup pagingSetup, PdfDocument document,
SampleSpecInfo sampleSpecInfo)
{
ReportUtils.IncreaseLineHeight(pagingSetup, document, pagingSetup.RegularLineHeight);
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Mã bệnh phẩm: {0}", sampleSpecInfo.SampleSpecId));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Tên bệnh nhân: {0}", sampleSpecInfo.PatientName));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Giới tính: {0}", sampleSpecInfo.SexDisplay));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Năm sinh: {0}", sampleSpecInfo.YearOfBirth));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Nguồn: {0}", sampleSpecInfo.LocationId));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Thời gian nhập: {0}", sampleSpecInfo.DateInputDisplay));
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
string.Format("Danh sách nhập"));
}
/// <summary>
/// Creates a list of unique columns based on their segments and scenarios.
/// </summary>
/// <returns></returns>
private List <InstanceReportColumn> GetSegmentScenarioColumnsForSegmentProcessing()
{
//#1 - this will be our X axis - a set of unique segments and scenarios
// It will be our "master" list of columns for the equity report
List <InstanceReportColumn> uniqueSegmentScenarioColumns = new List <InstanceReportColumn>();
for (int c = 0; c < this.Columns.Count; c++)
{
InstanceReportColumn column = this.Columns[c];
bool exists = ReportUtils.Exists(uniqueSegmentScenarioColumns,
tmp =>
{
if (!tmp.SegmentAndScenarioEquals(column))
{
return(false);
}
//if( !tmp.CurrencyEquals( column ) )
// return false;
return(true);
});
if (!exists)
{
//create a clone so that we can digest this data without affecting other references
InstanceReportColumn newColumn = (InstanceReportColumn)column.Clone();
uniqueSegmentScenarioColumns.Add(newColumn);
}
}
return(uniqueSegmentScenarioColumns);
}
/// <summary>
/// Determine if the other units within this instance are custom.
/// </summary>
/// <returns>A <see cref="bool"/> indicating if any of the other units
/// are custom.</returns>
public bool HasCustomUnits()
{
if (this.OtherUnits == null)
{
return(false);
}
return(ReportUtils.Exists(this.OtherUnits, InstanceReportColumn.IsCustomUnit));
}
public FileContentResult ExportHistory(string startDate, string endDate)
{
MemoryStream stream = new MemoryStream();
try
{
DateTime startDateValue = DateTime.Today.AddDays(-ExportHistoryDefaultRange);
DateTime endDateValue = DateTime.Today;
if (!string.IsNullOrEmpty(startDate))
{
startDateValue = DateTime.ParseExact(startDate,
CommonConstant.UniversalDateFormat, CultureInfo.InvariantCulture);
}
if (!string.IsNullOrEmpty(endDate))
{
endDateValue = DateTime.ParseExact(endDate,
CommonConstant.UniversalDateFormat, CultureInfo.InvariantCulture);
}
var reportDetailList = _reportService.GetExportHistory(new ReportService.GetExportHistoryParam()
{
EndDate = endDateValue,
StartDate = startDateValue
});
PagingSetup pagingSetup = ReportUtils.CreateDefaultPagingSetup();
pagingSetup.PageOrientation = PageOrientation.Landscape;
pagingSetup.PageSize = PageSize.A4;
PdfDocument document = ReportUtils.CreateDefaultPdfDocument(pagingSetup);
ReportUtils.DrawReportHeader(pagingSetup, document, "Thống kê mẫu đã xuất", labID);
ExportHistoryDrawReportSummary(pagingSetup, document, startDateValue, endDateValue);
var gridTable = new ReportGridTable <ReportExportHistoryInfo>()
{
Columns = ExportHistoryImportGridColumns(),
Datas = reportDetailList
};
ReportUtils.DrawGrid(gridTable, pagingSetup, document);
ReportUtils.DrawReportFooter(pagingSetup, document, labID);
document.Save(stream);
}
catch (BusinessException exception)
{
_logger.DebugFormat("BusinessException: {0}-{1}", exception.ErrorCode, exception.Message);
}
catch (Exception exception)
{
_logger.Error(string.Format("Iternal error {0}", exception));
}
stream.Flush();
return(File(stream.ToArray(), "application/pdf"));
}
public ExceptionProcessor(Context context, ReportField[] reportFields)
{
_context = context;
_reportFields = reportFields;
_appStartDate = new Time();
_appStartDate.SetToNow();
_interactionMode = CrashManager.Config.Mode;
_initialConfiguration = ReportUtils.GetCrashConfiguration(_context);
AndroidEnvironment.UnhandledExceptionRaiser += AndroidEnvironmentUnhandledExceptionRaiser;
}
private static bool DoCalendarsOverlap(Dictionary <int, List <InstanceReportColumn> > calendarsBySegment,
out List <InstanceReportColumn> allCalendars)
{
allCalendars = new List <InstanceReportColumn>();
bool contains = true;
foreach (KeyValuePair <int, List <InstanceReportColumn> > kvpCalendars in calendarsBySegment)
{
contains = true;
foreach (KeyValuePair <int, List <InstanceReportColumn> > kvpMatches in calendarsBySegment)
{
if (int.Equals(kvpCalendars.Key, kvpMatches.Key))
{
continue;
}
foreach (InstanceReportColumn match in kvpMatches.Value)
{
contains = ReportUtils.Exists(kvpCalendars.Value, cal => ContainsCalendar(cal, match, false, false));
if (!contains)
{
break;
}
}
if (!contains)
{
break;
}
}
if (contains)
{
allCalendars = kvpCalendars.Value;
break;
}
}
if (!contains)
{
return(false);
}
allCalendars.ForEach(
cal =>
{
foreach (Segment seg in cal.Segments)
{
cal.Labels.RemoveAll(ll => ll.Label == seg.ValueName);
}
cal.Segments = new ArrayList();
});
return(true);
}
public void WhenISendPutRequest(ApisEnum service, string endpoint, string body)
{
string endpointMapped = Mapper.MapValue(endpoint, helper.GetData());
string bodyMapped = Mapper.MapValue(body, helper.GetData());
IRequest request = RequestFactory.GetRequest(service, endpointMapped);
request.GetRequest().AddJsonBody(bodyMapped);
response = RequestManager.Put(client, request);
ReportUtils.AddJsonData("Request body", bodyMapped);
ReportUtils.AddJsonData("Response body", response.GetResponse().Content);
}
public ActionResult <CveSummaryModel> GetAllCve(string sortedBy)
{
var cves = ReportUtils.GetSortedCvesBySeverity(this.reports.GetCveSummary());
if (sortedBy != null)
{
cves = SortCves(sortedBy, cves);
}
return(Ok(cves));
}
public void CleanupFlowThroughColumns()
{
for (int rhIndex = 0; rhIndex < currentFilingSummary.MyReports.Count; rhIndex++)
{
ReportHeader rh = currentFilingSummary.MyReports[rhIndex] as ReportHeader;
//Equity reports that do not have segments still need to have flow through columns
//cleaned up because they were not processed with the regular equity processing logic
bool isEquityStatement = false;
if (ReportUtils.IsStatementOfEquityCombined(rh.LongName))
{
isEquityStatement = true;
}
if (isEquityStatement)
{
string instanceFile = Path.Combine(this.currentReportDirectory, rh.XmlFileName);
InstanceReport ir = InstanceReport.LoadXml(instanceFile);
if (ir.IsEquityReport)
{
continue;
}
}
if (rh.ReportType == ReportHeaderType.Sheet || rh.ReportType == ReportHeaderType.Notes)
{
if (cleanupStatementsOnly)
{
if (ReportUtils.IsStatement(rh.LongName) == true)
{
this.currentFilingSummary.TraceInformation("Process Flow-Through: " + rh.LongName);
InstanceReport.ElementSegmentCombinations allInUseElementsSegments = this.BuildInUseElementSegmentCombinationsForAllReports(rh);
this.CleanupColumns(rh, allInUseElementsSegments);
this.uniqueReportElementSegmentCombos.Remove(rh.XmlFileName);
}
}
else
{
this.currentFilingSummary.TraceInformation("Process Flow-Through: " + rh.LongName);
InstanceReport.ElementSegmentCombinations allInUseElementsSegments = this.BuildInUseElementSegmentCombinationsForAllReports(rh);
this.CleanupColumns(rh, allInUseElementsSegments);
this.uniqueReportElementSegmentCombos.Remove(rh.XmlFileName);
}
}
}
this.uniqueReportElements = new Dictionary <string, List <string> >();
this.uniqueReportSegments = new Dictionary <string, List <string> >();
this.uniqueReportElementSegmentCombos = new Dictionary <string, InstanceReport.ElementSegmentCombinations>();
}
public IActionResult PrintEventsByView(int viewID)
{
if (!viewLoader.GetView(viewID, out ViewBase view, out string errMsg))
{
throw new ScadaException(errMsg);
}
return(File(
PrintEvents(view, out DateTime generateTime),
MediaTypeNames.Application.Octet,
ReportUtils.BuildFileName("Events", generateTime, OutputFormat.Xml2003)));
}
public void ProcessBeginningAndEndingBalances()
{
//First, separate the duration columns and instant columns
ArrayList durationColumnIndex = new ArrayList();
ArrayList instantColumnIndex = new ArrayList();
for (int colIndex = 0; colIndex < this.Columns.Count; colIndex++)
{
InstanceReportColumn irc = this.Columns[colIndex] as InstanceReportColumn;
if (irc.MyContextProperty != null &&
irc.MyContextProperty.PeriodType == Element.PeriodType.duration)
{
durationColumnIndex.Add(colIndex);
}
else
{
instantColumnIndex.Add(colIndex);
}
}
//Process Cash & Cash Equivalents Beginning/Ending Balances
int beginingBalanceRowIndex = -1;
int endingBalanceRowIndex = -1;
for (int rowIndex = 0; rowIndex < this.Rows.Count; rowIndex++)
{
InstanceReportRow irr = this.Rows[rowIndex] as InstanceReportRow;
if (!irr.IsReportTitle && !irr.IsSegmentTitle && (irr.IsBeginningBalance || irr.IsEndingBalance))
{
if (irr.IsBeginningBalance)
{
beginingBalanceRowIndex = rowIndex;
HandleBalances(true, irr, durationColumnIndex, instantColumnIndex);
}
if (irr.IsEndingBalance)
{
endingBalanceRowIndex = rowIndex;
HandleBalances(false, irr, durationColumnIndex, instantColumnIndex);
}
}
}
//Check if one more step is necesary to realign the beginning/ending balances
if (ReportUtils.IsCashFlowFromOps(this.ReportName) &&
beginingBalanceRowIndex != -1 && endingBalanceRowIndex != -1)
{
RealignCashRows(durationColumnIndex, beginingBalanceRowIndex, endingBalanceRowIndex);
//Check if we should delete the "empty" instance column and possible extra duration columns
DeleteEmptyColumns(beginingBalanceRowIndex, endingBalanceRowIndex, instantColumnIndex, durationColumnIndex);
}
}
private void ExportHistoryDrawReportSummary(PagingSetup pagingSetup, PdfDocument document,
DateTime startDate, DateTime endDate)
{
var options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always);
ReportUtils.DrawParagraphLine(pagingSetup, document, new XFont("Tahoma", 12, XFontStyle.Bold, options),
XParagraphAlignment.Center, pagingSetup.RegularLineHeight,
string.Format("Từ ngày: {0} - Đến ngày: {1}",
startDate.ToString(CommonConstant.DateFormatDisplay),
endDate.ToString(CommonConstant.DateFormatDisplay)));
ReportUtils.IncreaseLineHeight(pagingSetup, document, pagingSetup.RegularLineHeight);
}
public SaveFileResult ReplaceOpenXML([FromBody] dynamic content)
{
var pdf = new PDF();
var serverAddr = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}/";
var targetPdfName = pdf.CreatePDFReport(content, serverAddr);
var returnResponse = new SaveFileResult();
returnResponse.FileName = targetPdfName;
ReportUtils reportUtils = new ReportUtils();
reportUtils.DeleteOldFiles();
return(returnResponse);
}
public bool HasPerShare()
{
if (this.MCU == null || this.MCU.UPS == null || this.MCU.UPS.Count == 0)
{
return(false);
}
if (ReportUtils.Exists(this.MCU.UPS, IsEPSUnit))
{
return(true);
}
return(false);
}
public bool HasMonetary()
{
if (this.MCU == null || this.MCU.UPS == null || this.MCU.UPS.Count == 0)
{
return(false);
}
if (ReportUtils.Exists(this.MCU.UPS, IsMonetaryUnit))
{
return(true);
}
return(false);
}
public bool HasExchangeRate()
{
if (this.MCU == null || this.MCU.UPS == null || this.MCU.UPS.Count == 0)
{
return(false);
}
if (ReportUtils.Exists(this.MCU.UPS, IsExchangeRateUnit))
{
return(true);
}
return(false);
}
private void DrawReportFooter(PagingSetup pagingSetup, PdfDocument document,
string userExportName, string userExportTo)
{
double signatureHeaderHeight = pagingSetup.RegularLineHeight;
double signatureContainerHeight = 100;
double signatureContentName = pagingSetup.RegularLineHeight;
double footerGridHeight = signatureHeaderHeight + signatureContainerHeight + signatureContentName;
if (!ReportUtils.IsHeightInPage(pagingSetup, document, footerGridHeight))
{
ReportUtils.BreakPage(pagingSetup, document);
}
ReportUtils.DrawGridLine(new List <CellDisplay>()
{
new CellDisplay()
{
Ratio = 50, DisplayText = "Người xuất mẫu", CellAlign = XStringFormats.Center, PaddingLeft = 10
},
new CellDisplay()
{
Ratio = 50, DisplayText = "Người nhận mẫu", CellAlign = XStringFormats.Center, PaddingLeft = 10
},
}, pagingSetup, document, pagingSetup.GridHeaderFont, signatureHeaderHeight);
ReportUtils.DrawGridLine(new List <CellDisplay>()
{
new CellDisplay()
{
Ratio = 50, DisplayText = "", CellAlign = XStringFormats.Center, PaddingLeft = 10
},
new CellDisplay()
{
Ratio = 50, DisplayText = "", CellAlign = XStringFormats.Center, PaddingLeft = 10
},
}, pagingSetup, document, pagingSetup.RegularFont, signatureContainerHeight);
ReportUtils.DrawGridLine(new List <CellDisplay>()
{
new CellDisplay()
{
Ratio = 50, DisplayText = userExportName, CellAlign = XStringFormats.Center, PaddingLeft = 10
},
new CellDisplay()
{
Ratio = 50, DisplayText = userExportTo, CellAlign = XStringFormats.Center, PaddingLeft = 10
},
}, pagingSetup, document, pagingSetup.RegularFont, signatureContentName);
}
public bool IsDimensionMatch(ColumnRowRequirement columnRowRequirement)
{
foreach (Segment mySeg in this.Segments)
{
bool dimensionExists = ReportUtils.Exists(columnRowRequirement.Segments,
iSeg => string.Equals(mySeg.DimensionInfo.dimensionId, iSeg.DimensionInfo.dimensionId));
if (!dimensionExists)
{
return(false);
}
}
return(true);
}
private void DrawReportSummary(PagingSetup pagingSetup, PdfDocument document,
RemovalNote removalNote)
{
var options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always);
ReportUtils.DrawParagraphLine(pagingSetup, document, new XFont("Tahoma", 12, XFontStyle.Bold, options),
XParagraphAlignment.Center, pagingSetup.RegularLineHeight,
string.Format("Mã hủy: {0}", removalNote.RemovalId));
ReportUtils.IncreaseLineHeight(pagingSetup, document, pagingSetup.RegularLineHeight);
ReportUtils.DrawParagraphLine(pagingSetup, document, PagingSetup.CreateDefaultPDFRegularFont(),
XParagraphAlignment.Left, pagingSetup.RegularLineHeight,
"Danh sách hủy: ");
}
public IActionResult GetAllCveHtml(string sortedBy)
{
var cves = ReportUtils.GetSortedCvesBySeverity(this.reports.GetCveSummary());
if (sortedBy != null)
{
cves = SortCves(sortedBy, cves);
ViewBag.SortedBy = sortedBy;
}
else
{
ViewBag.SortedBy = "severity";
}
return(View("~/Controllers/Pages/CVEGroupSummary.cshtml", cves));
}
