public ReportResult(ReportFormat format, string outReportName, string reportPath, ReportDataSource [] ds, SubreportProcessingEventHandler[] subReportProcessing = null)
{
var local = new LocalReport();
local.ReportPath = reportPath;
if (ds != null)
{
for(int i = 0 ; i < ds.Count() ; i++ )
local.DataSources.Add(ds[i]);
}
// подключение обработчиков вложенных отчетов
if (subReportProcessing != null)
{
for (int i = 0; i < subReportProcessing.Count(); i++ )
local.SubreportProcessing += subReportProcessing[i];
}
ReportType = format.ToString();
DeviceInfo = String.Empty;
ReportName = outReportName;
RenderBytes = local.Render(ReportType, DeviceInfo
, out this.MimiType
, out this.Encoding
, out this.FileExt
, out this.Streams
, out this.Warnings
);
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
_reportFormat = reportFormat;
_viewerParameters.ProcessingMode = mode;
if (mode == ProcessingMode.Local && localReportDataSources != null)
{
_viewerParameters.LocalReportDataSources = localReportDataSources;
}
_viewerParameters.ReportPath = reportPath;
_viewerParameters.ReportServerUrl = reportServerUrl ?? _viewerParameters.ReportServerUrl;
if (username != null || password != null)
{
_viewerParameters.Username = username;
_viewerParameters.Password = password;
}
ParseParameters(reportParameters);
}
private ActionResult DownloadReport(ReportFormat format)
{
return this.Report(
format,
ReportName,
new { Parameter1 = "Hello World!", Parameter2 = DateTime.Now, Parameter3 = 12345 });
}
public static string GetFileNameWithoutExtension(string fileName, ReportFormat.ExportType exportFormat)
{
switch (exportFormat)
{
case ReportFormat.ExportType.Excel:
if (fileName.IndexOf(FileSuffix.ExcelFileSuffix, StringComparison.CurrentCultureIgnoreCase) == -1)
{
return fileName;
}
else
{
return fileName.Split('.')[0];
}
case ReportFormat.ExportType.Pdf:
if (fileName.IndexOf(FileSuffix.Pdf, StringComparison.CurrentCultureIgnoreCase) == -1)
{
return fileName;
}
else
{
return fileName.Split('.')[0];
}
}
return String.Empty;
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IDictionary<string, object> reportParameters)
: this(reportFormat, reportPath, null, null, null, reportParameters)
{
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters)
: this(reportFormat, reportPath, null, null, null, reportParameters)
{
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath)
{
var reportRunner = new ReportRunner(reportFormat, reportPath);
return reportRunner.Run();
}
static ReportFormat()
{
Html = new ReportFormat { Code = ReportFormats.Html, Instruction = "HTML4.0" };
MHtml = new ReportFormat { Code = ReportFormats.MHtml, Instruction = "MHTML" };
Pdf = new ReportFormat { Code = ReportFormats.Pdf, Instruction = "PDF" };
Xlsx = new ReportFormat { Code = ReportFormats.Xlsx, Instruction = "EXCELOPENXML" };
Docx = new ReportFormat { Code = ReportFormats.Docx, Instruction = "WORDOPENXML" };
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, null, mode, localReportDataSources)
{
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IDictionary<string, object> reportParameters)
: this(reportFormat,
reportPath,
reportParameters != null ? reportParameters.ToList() : null)
{
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, reportParameters, mode, localReportDataSources)
{
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(reportFormat, reportPath, mode, localReportDataSources);
return reportRunner.Run();
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IDictionary<string, object> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat,
reportPath,
reportParameters != null ? reportParameters.ToList() : null,
mode,
localReportDataSources)
{
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportParameters);
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
object reportParameters)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters));
return reportRunner.Run();
}
private ActionResult DownloadReportMultipleValues(ReportFormat format)
{
return this.Report(
format,
ReportName,
new List<KeyValuePair<string, object>>
{
new KeyValuePair<string, object>("Parameter1", "Value 1"),
new KeyValuePair<string, object>("Parameter1", "Value 2"),
new KeyValuePair<string, object>("Parameter2", DateTime.Now),
new KeyValuePair<string, object>("Parameter2", DateTime.Now.AddYears(10)),
new KeyValuePair<string, object>("Parameter3", 12345)
});
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IDictionary<string, object> reportParameters)
: this(reportFormat,
reportPath,
reportServerUrl,
username,
password,
reportParameters != null ? reportParameters.ToList() : null)
{
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
public SizeInfo(IReport rpt, ReportFormat.PageType pageType)
{
this.report = rpt;
double tempValue = 0;
//PageSize
switch (pageType)
{
case ReportFormat.PageType.A3:
this.pageWidth = 420;
this.pageHeight = 297;
break;
case ReportFormat.PageType.A4:
this.pageWidth = 210;
this.pageHeight = 297;
break;
case ReportFormat.PageType.B4:
this.pageWidth = 257;
this.pageHeight = 364;
break;
case ReportFormat.PageType.B5:
this.pageWidth = 182;
this.pageHeight = 257;
break;
case ReportFormat.PageType.Letter:
this.pageWidth = 176;
this.pageHeight = 125;
break;
}
if (rpt.Format.Orientation == Orientation.Horizontal)
{
tempValue = this.pageWidth;
this.pageWidth = this.pageHeight;
this.pageHeight = tempValue;
}
this.pageWidth = UnitConversion.MMToPound(this.pageWidth);
this.pageHeight = UnitConversion.MMToPound(this.pageHeight);
this.currentDetailHeight = 0;
this.detailCaptionHeight = 0;
this.detailRowHeight = 0;
this.foldedRowCount = 1;
this.sheetWidth = GetSheetWidth();
this.fieldColumnCount = this.sheetWidth;
//this.totalPageCount = GetTotalPageCount();
}
public byte[] GetPropertyAppraisalReceiptReport(int orderId, string borrowerFirstName, string borrowerLastName, string creditCardType, string transactionId, string street, string zip, string state, string city, ReportFormat format)
{
var parameters = new ES.ParameterValue[]
{
new ES.ParameterValue { Label = "orderId", Name = "orderId", Value = orderId.ToString()},
new ES.ParameterValue { Label = "borrowerFirstName", Name = "borrowerFirstName", Value = borrowerFirstName},
new ES.ParameterValue { Label = "borrowerLastName", Name = "borrowerLastName", Value = borrowerLastName},
new ES.ParameterValue { Label = "creditCardType", Name = "creditCardType", Value = creditCardType},
new ES.ParameterValue { Label = "transactionId", Name = "transactionId", Value = transactionId},
new ES.ParameterValue { Label = "street", Name = "street", Value = street},
new ES.ParameterValue { Label = "zip", Name = "zip", Value = zip},
new ES.ParameterValue { Label = "state", Name = "state", Value = state},
new ES.ParameterValue { Label = "city", Name = "city", Value = city}
};
return GetReportInternal(ReportType.PropertyAppraisalReceipt, format, parameters);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportParameters,
mode,
localReportDataSources);
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
object reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters),
mode,
localReportDataSources);
return reportRunner.Run();
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IEnumerable<KeyValuePair<string, object>> reportParameters)
{
_reportFormat = reportFormat;
_viewerParameters.ReportPath = reportPath;
_viewerParameters.ReportServerUrl = reportServerUrl ?? _viewerParameters.ReportServerUrl;
if (username != null || password != null)
{
_viewerParameters.Username = username;
_viewerParameters.Password = password;
}
ParseParameters(reportParameters);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
reportParameters,
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportServerUrl">The URL for the report server.</param>
/// <param name="username">The report server username.</param>
/// <param name="password">The report server password.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username = null,
string password = null,
object reportParameters = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportServerUrl,
username,
password,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters));
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
object reportParameters,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters),
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IDictionary<string, object> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null,
string filename = null)
: this(reportFormat,
reportPath,
reportServerUrl,
username,
password,
reportParameters?.ToList(),
mode,
localReportDataSources,
filename)
{
}
private ActionResult DownloadReport(ReportFormat format, bool isLocalReport, string filename = null)
{
if (isLocalReport)
{
return this.Report(
format,
LocalReportName,
new { Parameter1 = "Test", Parameter2 = 123 },
ProcessingMode.Local,
new Dictionary<string, DataTable>
{
{ "Products", LocalData.GetProducts() },
{ "Cities", LocalData.GetCities() }
},
filename);
}
return this.Report(
format,
RemoteReportName,
new { Parameter1 = "Hello World!", Parameter2 = DateTime.Now, Parameter3 = 12345, Parameter4 = (DateTime?)null },
filename: filename);
}
public static string GetFullFileName(string fileName, ReportFormat.ExportType exportFormat)
{
string filePrefix = String.Empty;
if (fileName != String.Empty)
{
filePrefix = fileName.Split('.')[0];
}
else
{
filePrefix = fileName;
}
switch (exportFormat)
{
case ReportFormat.ExportType.Excel:
if (filePrefix.IndexOf(FileSuffix.ExcelFileSuffix, StringComparison.CurrentCultureIgnoreCase) == -1)
{
return filePrefix + FileSuffix.ExcelFileSuffix;
}
else
{
return fileName;
}
case ReportFormat.ExportType.Pdf:
if (filePrefix.IndexOf(FileSuffix.Pdf, StringComparison.CurrentCultureIgnoreCase) == -1)
{
return filePrefix + FileSuffix.Pdf;
}
else
{
return fileName;
}
}
return String.Empty;
}
string IReportBuilder.GetFilename(IReport report, ReportFormat reportFormat)
{
return(GetFilename(report, reportFormat));
}
/// <summary>
/// Parses the settings string into its configuration settings.
/// </summary>
/// <param name="settings"></param>
private void ParseSettings(string settings)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(settings);
// Get whether reporting is enabled.
enabled = Boolean.Parse(doc.DocumentElement.GetAttribute("enabled"));
if (Enabled)
{
// Get the frequency of the report generation.
XmlElement element = doc.DocumentElement.SelectSingleNode("generate") as XmlElement;
if (element != null)
{
string s = element.GetAttribute("frequency");
if (s != String.Empty)
{
frequency = ( ReportFrequency )Enum.Parse(
typeof(ReportFrequency),
s,
true);
}
else
{
log.Error("Invalid report settings format. No frequency attribute was specified.");
}
}
else
{
log.Error("Invalid report settings format. No generate element was specified.");
}
// All frequencies will have a time specified.
XmlElement child = element.SelectSingleNode("time") as XmlElement;
if (child != null)
{
DateTime dt = DateTime.Parse(child.InnerText);
timeOfDay = new TimeSpan(dt.Hour, dt.Minute, 0);
}
else
{
log.Error("Invalid report settings format. No time element was specified.");
}
// Depending on the frequency type, the time parameters will be different.
switch (frequency)
{
case ReportFrequency.Daily:
break;
case ReportFrequency.Weekly:
// Get the day of the week.
child = element.SelectSingleNode("dayofweek") as XmlElement;
if (child != null)
{
weekday = ( DayOfWeek )Enum.Parse(typeof(DayOfWeek), child.InnerText, true);
}
else
{
log.Error("Invalid report settings format. No day of week element was specified.");
}
break;
case ReportFrequency.Monthly:
// Get the day of the month.
child = element.SelectSingleNode("dayofmonth") as XmlElement;
if (child != null)
{
dayOfMonth = Convert.ToInt32(child.InnerText);
}
else
{
log.Error("Invalid report settings format. No day of month element was specified.");
}
break;
}
// Get the report location information.
element = doc.DocumentElement.SelectSingleNode("location") as XmlElement;
if (element != null)
{
isiFolder = (element.InnerText == "ifolder") ? true : false;
}
else
{
log.Error("Invalid report settings format. No location element was specified.");
}
// Get the report format.
element = doc.DocumentElement.SelectSingleNode("format") as XmlElement;
if (element != null)
{
format = ( ReportFormat )Enum.Parse(typeof(ReportFormat), element.InnerText, true);
}
else
{
log.Error("Invalid report settings format. No format element was specified.");
}
}
}
public ReportFormat UpdateReportFormat(ReportFormat reportFormat)
{
throw new NotSupportedException();
}
private void FormatReport(MovimientosStockListPorExpedienteRpt rpt, ReportFilter filter, ReportFormat format)
{
switch (format.Vista)
{
case EReportVista.Detallado:
{
rpt.HeaderDetallado.SectionFormat.EnableSuppress = false;
rpt.HeaderResumido.SectionFormat.EnableSuppress = true;
rpt.FooterExpediente.SectionFormat.EnableNewPageAfter = true;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["HeaderDetallado"].SectionFormat.EnableSuppress = false;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["Detalle"].SectionFormat.EnableSuppress = false;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["FooterDetallado"].SectionFormat.EnableSuppress = false;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["FooterResumido"].SectionFormat.EnableSuppress = true;
}
break;
case EReportVista.Resumido:
{
rpt.HeaderDetallado.SectionFormat.EnableSuppress = true;
rpt.HeaderResumido.SectionFormat.EnableSuppress = false;
rpt.FooterExpediente.SectionFormat.EnableNewPageAfter = false;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["HeaderDetallado"].SectionFormat.EnableSuppress = true;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["Detalle"].SectionFormat.EnableSuppress = true;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["FooterDetallado"].SectionFormat.EnableSuppress = true;
rpt.Subreports["StocksSubReport"].ReportDefinition.Sections["FooterResumido"].SectionFormat.EnableSuppress = false;
}
break;
}
rpt.ReportDefinition.ReportObjects["FacturaLB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.ReportDefinition.ReportObjects["AlbaranLB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.ReportDefinition.ReportObjects["BultosActualesLB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.ReportDefinition.ReportObjects["KgActualesLB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.Subreports["StocksSubReport"].ReportDefinition.ReportObjects["Albaran_TB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.Subreports["StocksSubReport"].ReportDefinition.ReportObjects["Factura_TB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.Subreports["StocksSubReport"].ReportDefinition.ReportObjects["BultosActuales_TB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
rpt.Subreports["StocksSubReport"].ReportDefinition.ReportObjects["KilosActuales_TB"].ObjectFormat.EnableSuppress = filter.SoloMermas;
}
public StockLineListRpt GetStockLineList(StockList list, ReportFilter filter, ReportFormat format)
{
StockLineListRpt doc = new StockLineListRpt();
//Si no existen elementos no tiene sentido un informe detallado. Además, falla en Crystal Reports
if (list.Count <= 0)
{
return(null);
}
List <StockPrint> print_list = new List <StockPrint>();
foreach (StockInfo item in list)
{
print_list.Add(StockPrint.New(item));
}
doc.SetDataSource(print_list);
FormatHeader(doc);
FormatReport(doc, filter, format);
return(doc);
}
protected virtual string GetFilename(IReport report, ReportFormat reportFormat)
{
return(report.GetFilename(this.GetFileExtension(reportFormat)));
}
/// <summary>
/// Creates a report format.
/// </summary>
/// <param name="reportFormat">The report format to create.</param>
/// <returns>Returns the created report format.</returns>
public ReportFormat CreateReportFormat(ReportFormat reportFormat)
{
return(this.Client.Post <ReportFormat, ReportFormat>("format", reportFormat));
}
protected OrderQuickReportsViewModel(Order selectedOrder, ReportFormat format)
{
Format = format;
SelectedOrder = selectedOrder;
}
string IReportBuilder.GetContentType(ReportFormat reportFormat)
{
return(GetContentType(reportFormat));
}
byte[] IReportBuilder.Save(ReportFormat reportFormat)
{
return(Save(reportFormat));
}
protected abstract string GetContentType(ReportFormat reportFormat);
/// <summary>
/// Creates a report format.
/// </summary>
/// <param name="reportFormat">The report format to create.</param>
/// <returns>Returns the created report format.</returns>
public ReportFormat CreateReportFormat(ReportFormat reportFormat)
{
return(this.reportExecutor.CreateReportFormat(reportFormat));
}
public XslReportCreator(ReportFormat format)
{
_format = format;
}
public MovimientosStockListPorExpedienteRpt GetMovimientosStockListAgrupado(ExpedienteList items,
ProductInfo producto,
SerieInfo serie,
ReportFilter filter,
ReportFormat format)
{
MovimientosStockListPorExpedienteRpt doc = new MovimientosStockListPorExpedienteRpt();
List <ExpedientePrint> pList = new List <ExpedientePrint>();
List <StockPrint> movs = new List <StockPrint>();
StockList stocks = null;
int movsCount = 0;
foreach (ExpedientInfo item in items)
{
if (filter.SoloStock)
{
if ((item.StockKilos == 0) || (item.StockBultos == 0))
{
continue;
}
}
movsCount = movs.Count;
stocks = (item.Stocks == null) ? StockList.GetListByExpediente(item.Oid, false) : item.Stocks;
foreach (StockInfo stock in stocks)
{
if (filter.SoloMermas)
{
if ((stock.OidAlbaran != 0) || (stock.Kilos >= 0))
{
continue;
}
}
if ((filter.FechaIni <= stock.Fecha) && (stock.Fecha <= filter.FechaFin))
{
if ((producto == null) && (serie == null))
{
movs.Add(StockPrint.New(stock));
}
else if (producto != null)
{
if ((producto.Oid == stock.OidProducto) && (serie == null))
{
movs.Add(StockPrint.New(stock));
}
else if ((producto.Oid == stock.OidProducto) && (serie.Oid == stock.OidSerie))
{
movs.Add(StockPrint.New(stock));
}
}
else if (serie.Oid == stock.OidSerie)
{
movs.Add(StockPrint.New(stock));
}
}
}
if (movsCount < movs.Count)
{
pList.Add(item.GetPrintObject());
}
}
//Si no existen conceptos, no tiene sentido un informe detallado. Además, falla en Crystal Reports
if (movs.Count <= 0)
{
return(null);
}
doc.SetDataSource(pList);
doc.Subreports["StocksSubReport"].SetDataSource(movs);
FormatHeader(doc);
FormatReport(doc, filter, format);
return(doc);
}
/// <summary>
/// Obtiene el tablero de control en formato pdf o excel
/// </summary>
/// <param name="delegation">Delegación donde se consultara el tablero de control</param>
/// <param name="nameChildCareCenter">Nombre de la estancia donde se consultaran el tablero de control</param>
/// <param name="typeChildCareCenter">Tipo de la estancia donde se consultara el tablero de control</param>
/// <param name="operador">Operador que realiza el proceso</param>
/// <param name="starDate">Limite inferior para la consulta del tablero de control</param>
/// <param name="endDate">Limite superior para la consulta del tablero de control</param>s
/// <param name="data">Objeto con la información con la cual se construye el tablero de control</param>
/// <param name="format">Indica el formato de salida deseado (pdf o excel)</param>
/// <returns>Arreglo de bytes con el tablero generado</returns>
public byte[] GetDashboardEbdis(string delegation, string nameChildCareCenter, string typeChildCareCenter, string operador,
string starDate, string endDate, DashboardData data, ReportFormat format)
{
var report = BuildEbdisDashboard(delegation, nameChildCareCenter, typeChildCareCenter, operador, starDate, endDate, data);
var dashboard = report.ExportToStream(format == ReportFormat.Excel ? ExportFormatType.Excel : ExportFormatType.PortableDocFormat);
using (MemoryStream ms = new MemoryStream())
{
dashboard.CopyTo(ms);
return(ms.ToArray());
}
}
public static IReporter Create(ReportFormat format) => format switch
{
/// <summary>
/// Obtiene el certificado de uso de salas en *.pdf o *.xls
/// </summary>
/// <param name="delegation">Delegación donde se consultara el certificado de uso de salas</param>
/// <param name="nameChildCareCenter">Nombre de la estancia donde se consultaran las salas</param>
/// <param name="operador">Operardor que realiza el proceso</param>
/// <param name="city">Ciudada donde se encuantra la estancia</param>
/// <param name="cycle">Ciclo a consultar</param>
/// <param name="capacity">Capacidad instalada de la estancia</param>
/// <param name="listRoom">lista de salas</param>
/// <param name="format">formato del reporte</param>
/// <returns>Arreglo de bytes con el certificado de uso de salas generado</returns>
public byte[] GetCertificateUseRoom(string delegation, string nameChildCareCenter, string operador, string city, string cycle,
int capacity, IEnumerable <CertificateRoom> listRoom, ReportFormat format)
{
var report = BuildEbdisCertificateUseRoom(delegation, nameChildCareCenter, operador, city, cycle, capacity, listRoom);
var certificate = report.ExportToStream(format == ReportFormat.Excel ? ExportFormatType.Excel : ExportFormatType.PortableDocFormat);
using (MemoryStream ms = new MemoryStream())
{
certificate.CopyTo(ms);
return(ms.ToArray());
}
}
/// <summary>
/// Obtiene el reporte de indicadores en formato pdf o excel
/// </summary>
/// <param name="delegation">Delegación donde se consultaran los indicadores</param>
/// <param name="operador">Operador que realiza el proceso</param>
/// <param name="starDate">Limite inferior para la consulta de los indicadores</param>
/// <param name="endDate">Limite superior para la consulta de los indicadores</param>
/// <param name="documentationRuledInTime">Numero de tramites dictaminados en tiempo</param>
/// <param name="acceptedRequests">Número de solicitudes aceptadas</param>
/// <param name="rejectedRequests">Número de solicitudes rechazadas</param>
/// <param name="totalReceivedRequests">Numero total de solicitudes recibidos</param>
/// <param name="pitsSoldViaWeb">Número de fosas vendida vía web</param>
/// <param name="requestsInTime">Numero trámites realizados en el tiempo establecido</param>
/// <param name="documentationRuleTimes">Lista con (Fecha dictaminación documentación - Fecha de recepción de documentación) </param>
/// <param name="format">Indica el formato de salida deseado</param>
/// <returns>Arreglo de bytes con el reporte generado</returns>
public byte[] GetIndicatorsPitStream(string delegation, string operador, string starDate, string endDate,
int documentationRuledInTime, int acceptedRequests, int rejectedRequests, int totalReceivedRequests, int pitsSoldViaWeb,
int requestsInTime, IEnumerable <int> documentationRuleTimes, ReportFormat format)
{
var report = BuildPitIndicators(delegation, operador, starDate, endDate, documentationRuledInTime, acceptedRequests, rejectedRequests, totalReceivedRequests,
pitsSoldViaWeb, requestsInTime, documentationRuleTimes);
var PitIndicators = report.ExportToStream(format == ReportFormat.Excel ? ExportFormatType.Excel : ExportFormatType.PortableDocFormat);
using (MemoryStream ms = new MemoryStream())
{
PitIndicators.CopyTo(ms);
return(ms.ToArray());
}
}
public static OrderQuickReportsViewModel Create(Order selectedOrder, ReportFormat format)
{
return(ViewModelSource.Create(() => new OrderQuickReportsViewModel(selectedOrder, format)));
}
public static CsvReportRecordReader CreateReportRecordReader(string filePath, ReportFormat format)
{
switch (format)
{
case ReportFormat.Csv:
return(new CsvReportRecordReader(
new FileStream(filePath, FileMode.Open), ','));
case ReportFormat.Tsv:
return(new CsvReportRecordReader(
new FileStream(filePath, FileMode.Open), '\t'));
}
return(null);
}
protected abstract byte[] Save(ReportFormat reportFormat);
public RowReportStreamReader(string filePath, ReportFormat format)
{
csvReportRecordReader = RowReportRecordReaderFactory.CreateReportRecordReader(filePath, format);
recordReader = new RowReportRecordReader(csvReportRecordReader);
}
protected abstract string GetFileExtension(ReportFormat reportFormat);
void BindGalleryQuickReportsFormatItem(int index, ReportFormat parameter)
{
galleryQuickReports.Gallery.Groups[0].Items[index].BindCommand(() => ViewModel.QuickReportFormat(parameter), ViewModel, () => parameter);
}
string IReportBuilder.GetFileExtension(ReportFormat reportFormat)
{
return(GetFileExtension(reportFormat));
}
public bool CanQuickReport(ReportFormat format)
{
return(SelectedEntity != null);
}
/// <summary>
/// Updates a report format.
/// </summary>
/// <param name="id">The id of the report format to update.</param>
/// <param name="reportFormat">The updated report format.</param>
/// <returns>Returns the update report format.</returns>
public ReportFormat UpdateReportFormat(Guid id, ReportFormat reportFormat)
{
return(this.Client.Put <ReportFormat, ReportFormat>($"format/{id}", reportFormat));
}
/// <summary>
/// Update an existing scheduled report
/// </summary>
/// <param name="idReport">The ID of the report to update</param>
/// <param name="idSite">ID of the piwik site</param>
/// <param name="description">Description of the report</param>
/// <param name="period">A piwik period</param>
/// <param name="hour">Defines the hour at which the report will be sent</param>
/// <param name="reportType">The report type</param>
/// <param name="reportFormat">The report format</param>
/// <param name="includedStatistics">The included statistics</param>
/// <param name="emailMe">true if the report should be sent to the own user</param>
/// <param name="additionalEmails">A string array of additional email recipients</param>
/// <returns>True if update was successful</returns>
public Boolean updateReport(
int idReport,
int idSite,
string description,
PiwikPeriod period,
int hour,
ReportType reportType,
ReportFormat reportFormat,
List<Statistic> includedStatistics,
Boolean emailMe,
string[] additionalEmails = null
)
{
Dictionary<string, Object> additionalParameters = new Dictionary<string, Object>()
{
{ "emailMe", emailMe.ToString().ToLower() },
{ "displayFormat", 1 },
{ "additionalEmails", additionalEmails }
};
Parameter[] p =
{
new SimpleParameter("idReport", idReport),
new SimpleParameter("idSite", idSite),
new SimpleParameter("description", description),
new PeriodParameter("period", period),
new SimpleParameter("hour", hour),
new SimpleParameter("reportType", reportType.ToString()),
new SimpleParameter("reportFormat", reportFormat.ToString()),
new ArrayParameter("reports", includedStatistics.Select(i => i.ToString()).ToArray(), false),
new DictionaryParameter("parameters", additionalParameters)
};
return this.sendRequest<Boolean>("updateReport", new List<Parameter>(p));
}
static ReportFormatTest()
{
ConstructorArgumentValidationTestScenarios
.RemoveAllScenarios()
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <ReportFormat>
{
Name = "constructor should throw ArgumentException when parameter 'displayTimestamp' is false and parameter 'timestampFormat' is not null",
ConstructionFunc = () =>
{
var result = new ReportFormat(
false,
A.Dummy <DateTimeFormat>());
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "displayTimestamp is false, but timestampFormat is not null", },
});
EquatableTestScenarios
.RemoveAllScenarios()
.AddScenario(() =>
{
var referenceObjectForEquatableTestScenarios = A.Dummy <ReportFormat>().Whose(_ => _.DisplayTimestamp == true);
var result = new EquatableTestScenario <ReportFormat>
{
Name = "Default Code Generated Scenario",
ReferenceObject = referenceObjectForEquatableTestScenarios,
ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new ReportFormat[]
{
new ReportFormat(
referenceObjectForEquatableTestScenarios.DisplayTimestamp,
referenceObjectForEquatableTestScenarios.TimestampFormat,
referenceObjectForEquatableTestScenarios.Options),
},
ObjectsThatAreNotEqualToReferenceObject = new ReportFormat[]
{
new ReportFormat(
A.Dummy <ReportFormat>().Whose(_ => !_.DisplayTimestamp.IsEqualTo(referenceObjectForEquatableTestScenarios.DisplayTimestamp)).DisplayTimestamp,
null),
new ReportFormat(
referenceObjectForEquatableTestScenarios.DisplayTimestamp,
A.Dummy <ReportFormat>().Whose(_ => !_.TimestampFormat.IsEqualTo(referenceObjectForEquatableTestScenarios.TimestampFormat)).TimestampFormat),
new ReportFormat(
referenceObjectForEquatableTestScenarios.DisplayTimestamp,
referenceObjectForEquatableTestScenarios.TimestampFormat,
A.Dummy <ReportFormat>().Whose(_ => !_.Options.IsEqualTo(referenceObjectForEquatableTestScenarios.Options)).Options),
},
ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[]
{
A.Dummy <object>(),
A.Dummy <string>(),
A.Dummy <int>(),
A.Dummy <int?>(),
A.Dummy <Guid>(),
},
};
return(result);
});
DeepCloneWithTestScenarios
.RemoveAllScenarios()
.AddScenario(() =>
new DeepCloneWithTestScenario <ReportFormat>
{
Name = "DeepCloneWithTimestampFormat should deep clone object and replace TimestampFormat with the provided timestampFormat",
WithPropertyName = "TimestampFormat",
SystemUnderTestDeepCloneWithValueFunc = () =>
{
var systemUnderTest = A.Dummy <ReportFormat>().Whose(_ => _.DisplayTimestamp == true);
var referenceObject = A.Dummy <ReportFormat>().ThatIs(_ => !systemUnderTest.TimestampFormat.IsEqualTo(_.TimestampFormat));
var result = new SystemUnderTestDeepCloneWithValue <ReportFormat>
{
SystemUnderTest = systemUnderTest,
DeepCloneWithValue = referenceObject.TimestampFormat,
};
return(result);
},
})
.AddScenario(() =>
new DeepCloneWithTestScenario <ReportFormat>
{
Name = "DeepCloneWithOptions should deep clone object and replace Options with the provided options",
WithPropertyName = "Options",
SystemUnderTestDeepCloneWithValueFunc = () =>
{
var systemUnderTest = A.Dummy <ReportFormat>();
var referenceObject = A.Dummy <ReportFormat>().ThatIs(_ => !systemUnderTest.Options.IsEqualTo(_.Options));
var result = new SystemUnderTestDeepCloneWithValue <ReportFormat>
{
SystemUnderTest = systemUnderTest,
DeepCloneWithValue = referenceObject.Options,
};
return(result);
},
});
}
