public IEnumerable<SimpleNameValueCollection> exportResponses(ExportOptions exportOptions)
        {
            String authToken = new Authentication(exportOptions.getAPIUrl()).getAuthenticationToken(exportOptions.getUserName(), exportOptions.getPassword());
                ServiceOperationResultOfPagedListResultOfTabularResponseExportDataVUqw3SxCVUqw3SxC serviceOperationResult =
                    client.ExportResponsesTabular(authToken,
                    exportOptions.getSurveyId(),
                    exportOptions.getPageNumber(),
                    exportOptions.getResultsPerPage(),
                    exportOptions.getFilterField(),
                    exportOptions.getFilterValue(),
                    exportOptions.getSortField(),
                    exportOptions.getSortAscending(),
                    exportOptions.getPeriod(),
                    exportOptions.getDtStart(),
                    exportOptions.getDtEnd(),
                    exportOptions.getDetailedResponseInfo(),
                    exportOptions.getDetailedUserInfo(),
                    exportOptions.getIncludeOpenEndedResults(),
                    exportOptions.getIncludeAliases(),
                    exportOptions.getIncludeHiddenItems(),
                    exportOptions.getIncludeIncompleteResponses(),
                    exportOptions.getStripHTMLTagsFromAnswers(),
                    exportOptions.getStripHTMLTagsFromQuestions(),
                    exportOptions.getMergeAnswersForSelectMany());
              if (!serviceOperationResult.CallSuccess)
              { throw new System.ArgumentException(); }

            return getServiceOperationResult(serviceOperationResult);
        }
        public void VistaPrevia(string key)
        {
            try
            {
                ReportDocument objRpt = new ReportDocument();
                DataSet ds = (DataSet)this.GetDataReport(key);

                //string reportPath = Application.StartupPath + "\\Reporte\\co_ordenCompra_rpt.rpt";
                string reportPath = "C:\\Reportes\\CR_Cliente_rpt01.rpt";
                objRpt.Load(reportPath);

                DiskFileDestinationOptions crDiskFileDestinationOption = new DiskFileDestinationOptions();
                PdfRtfWordFormatOptions crFormatTypeOption = new PdfRtfWordFormatOptions();
                ExportOptions crExportOptions = new ExportOptions();

                objRpt.SetDataSource(ds.Tables[0]);
                string strfolder = "C:\\Reporte\\";
                crDiskFileDestinationOption.DiskFileName = strfolder + "Cliente.pdf";

                crExportOptions = objRpt.ExportOptions;
                crExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
                crExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;

                crExportOptions.ExportDestinationOptions = crDiskFileDestinationOption;
                crExportOptions.ExportFormatOptions = crFormatTypeOption;
                crystalReportViewer1.ReportSource = objRpt;
                //objRpt.Export();

            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }
Beispiel #3
0
        private void ExportarEXCEL(ReportDocument rep)
        {
            String ruta_exportacion;

            ruta_exportacion = Server.MapPath(System.Configuration.ConfigurationSettings.AppSettings["ruta_exportacion_pdf"]);
            //ruta_exportacion = System.Configuration.ConfigurationSettings.AppSettings["ruta_exportacion_pdf"];

            ExportOptions exportOpts = new ExportOptions();
            DiskFileDestinationOptions diskOpts = new DiskFileDestinationOptions();

            exportOpts = rep.ExportOptions;
            exportOpts.ExportFormatType = ExportFormatType.Excel;

            exportOpts.ExportDestinationType = ExportDestinationType.DiskFile;
            diskOpts.DiskFileName = ruta_exportacion + Session.SessionID.ToString() + ".xls";
            exportOpts.DestinationOptions = diskOpts;

            rep.Export();

            Response.ClearContent();
            Response.ClearHeaders();

            Response.AddHeader ("Content-Disposition", "attachment;filename=Morosidad.xls");
            Response.ContentType = "application/vnd.ms-excel";
            Response.WriteFile(diskOpts.DiskFileName.ToString());
            Response.Flush();
            Response.Close();
            System.IO.File.Delete(diskOpts.DiskFileName.ToString());
        }
		private void GenerateWord()
		{
            ReportDocument rpt = new ReportDocument();
            rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/GeneralLedger.rpt"));

			ExportOptions exportop = new ExportOptions();
			DiskFileDestinationOptions dest = new DiskFileDestinationOptions();
			
			string strPath = Server.MapPath(@"\retailplus\temp\");

			string strFileName = "generalledger_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".doc";
			if (System.IO.File.Exists(strPath + strFileName))
				System.IO.File.Delete(strPath + strFileName);

			dest.DiskFileName = strPath + strFileName;

			exportop = rpt.ExportOptions;
	
			SetDataSource(rpt);

			exportop.DestinationOptions = dest;
			exportop.ExportDestinationType = ExportDestinationType.DiskFile;
			exportop.ExportFormatType = ExportFormatType.WordForWindows;
			rpt.Export();   rpt.Close();    rpt.Dispose();
			
			fraViewer.Attributes.Add("src","/retailplus/temp/" + strFileName);
		}
Beispiel #5
0
        private void ExportarPDF(ReportDocument rep)
        {
            String ruta_exportacion;

            ruta_exportacion = Server.MapPath(System.Configuration.ConfigurationSettings.AppSettings["ruta_exportacion_pdf"]);
            //ruta_exportacion = System.Configuration.ConfigurationSettings.AppSettings["ruta_exportacion_pdf"];

            ExportOptions exportOpts = new ExportOptions();
            DiskFileDestinationOptions diskOpts = new DiskFileDestinationOptions();

            exportOpts = rep.ExportOptions;
            exportOpts.ExportFormatType = ExportFormatType.PortableDocFormat;

            exportOpts.ExportDestinationType = ExportDestinationType.DiskFile;
            diskOpts.DiskFileName = ruta_exportacion + Session.SessionID.ToString() + ".pdf";
            exportOpts.DestinationOptions = diskOpts;

            rep.Export();

            Response.ClearContent();
            Response.ClearHeaders();
            Response.ContentType = "application/pdf";
            Response.WriteFile(diskOpts.DiskFileName.ToString());
            Response.Flush();
            Response.Close();
            System.IO.File.Delete(diskOpts.DiskFileName.ToString());
        }
Beispiel #6
0
		private void GeneratePDF()
		{
            ReportDocument rpt = new ReportDocument();
            rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/ChartOfAccountsSummary.rpt"));

			ExportOptions exportop = new ExportOptions();
			DiskFileDestinationOptions dest = new DiskFileDestinationOptions();
			
			string strPath = Server.MapPath(@"\RetailPlus\temp\");

			string strFileName = "po_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".pdf";
			if (System.IO.File.Exists(strPath + strFileName))
				System.IO.File.Delete(strPath + strFileName);

			dest.DiskFileName = strPath + strFileName;

			exportop = rpt.ExportOptions;
	
			SetDataSource(rpt);

			exportop.DestinationOptions = dest;
			exportop.ExportDestinationType = ExportDestinationType.DiskFile;
			exportop.ExportFormatType = ExportFormatType.PortableDocFormat;
			rpt.Export();   rpt.Close();    rpt.Dispose();
			
			fraViewer.Attributes.Add("src","/RetailPlus/temp/" + strFileName);
		}
Beispiel #7
0
        public virtual void Write(ContentItem item, ExportOptions options, XmlTextWriter writer)
        {
            WriteSingleItem(item, options, writer);

            foreach (ContentItem child in item.Children)
                Write(child, options, writer);
        }
        public void Exportar(string key)
        {
            try
            {
                ReportDocument objRpt = new ReportDocument();
                DataSet ds = (DataSet)this.GetDataReport(key);

                string reportPath = "C:\\Reportes\\CRTejTicket_rpt.rpt";
                objRpt.Load(reportPath);

                ExportOptions crExportOptions = new ExportOptions();

                objRpt.SetDataSource(ds.Tables[0]);
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.InitialDirectory = Environment.SpecialFolder.MyDocuments.ToString();
                saveFileDialog.Filter = "Document (*.pdf)|*.PDF";
                saveFileDialog.FilterIndex = 1;
                saveFileDialog.FileName = "Etiqueta.pdf";
                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    objRpt.ExportToDisk(ExportFormatType.PortableDocFormat, saveFileDialog.FileName); ;
                }

                crExportOptions = objRpt.ExportOptions;
                objRpt.Export();

            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }
Beispiel #9
0
		protected DataExportContextBase(ExportOptions exportOptions)
		{
			ExportOptions = exportOptions;

			if (ExportOptions.IntoClipboard)
			{
				ClipboardData = new MemoryStream();
			}
		}
Beispiel #10
0
        public virtual void WriteSingleItem(ContentItem item, ExportOptions options, XmlTextWriter writer)
        {
            using (ElementWriter itemElement = new ElementWriter("item", writer))
            {
                WriteDefaultAttributes(itemElement, item);

                foreach (IXmlWriter xmlWriter in GetWriters(options))
                    xmlWriter.Write(item, writer);
            }
        }
Beispiel #11
0
		internal static IEnumerable<ContentItem> GetChildren(ContentItem item, ExportOptions options)
		{
			if (!options.IsFlagSet(ExportOptions.ExcludePages) && !options.IsFlagSet(ExportOptions.ExcludeParts))
				return item.Children;
			else if (options.IsFlagSet(ExportOptions.ExcludePages))
				return item.Children.Where(c => !c.IsPage);
			else if (options.IsFlagSet(ExportOptions.ExcludeParts))
				return item.Children.Where(c => c.IsPage);
			return Enumerable.Empty<ContentItem>();
		}
Beispiel #12
0
        public static string GeneratePlainText(Subtitle subtitle, ExportOptions exportOptions)
        {
            var sb = new StringBuilder();
            foreach (Paragraph p in subtitle.Paragraphs)
            {
                if (exportOptions.ShowLineNumbers)
                {
                    sb.Append(p.Number);
                    if (exportOptions.AddNewlineAfterLineNumber)
                        sb.AppendLine();
                    else
                        sb.Append(' ');
                }
                if (exportOptions.ShowTimecodes)
                {
                    if (exportOptions.TimeCodeSrt)
                        sb.Append(p.StartTime + exportOptions.TimeCodeSeparator + p.EndTime);
                    else if (exportOptions.TimeCodeHHMMSSFF)
                        sb.Append(p.StartTime.ToHHMMSSFF() + exportOptions.TimeCodeSeparator + p.EndTime.ToHHMMSSFF());
                    else
                        sb.Append(p.StartTime.TotalMilliseconds + exportOptions.TimeCodeSeparator + p.EndTime.TotalMilliseconds);

                    if (exportOptions.AddNewlineAfterTimeCodes)
                        sb.AppendLine();
                    else
                        sb.Append(' ');
                }
                string s = p.Text;
                if (exportOptions.RemoveStyling)
                {
                    s = HtmlUtil.RemoveHtmlTags(s, true);
                }
                if (exportOptions.FormatUnbreak)
                {
                    sb.Append(Utilities.UnbreakLine(s));
                }
                else
                {
                    sb.Append(s);
                }
                if (exportOptions.AddNewAfterText)
                    sb.AppendLine();
                if (exportOptions.AddNewAfterText2)
                    sb.AppendLine();
                if (!exportOptions.AddNewAfterText && !exportOptions.AddNewAfterText2)
                    sb.Append(' ');
            }
            string text = sb.ToString().Trim();
            if (exportOptions.FormatMergeAll)
            {
                text = text.Replace(Environment.NewLine, " ");
                text = text.FixExtraSpaces();
            }
            return text;
        }
Beispiel #13
0
 private IEnumerable<IXmlWriter> GetWriters(ExportOptions options)
 {
     if ((options & ExportOptions.OnlyDefinedProperties) == ExportOptions.OnlyDefinedProperties)
         yield return new DefinedPropertyXmlWriter(definitions);
     else
         yield return new PropertyXmlWriter();
     yield return new PropertyCollectionXmlWriter();
     yield return new ChildXmlWriter();
     yield return new AuthorizationRuleXmlWriter();
     yield return new LanguageSettingXmlWriter();
 }
Beispiel #14
0
        public static void GenerateReport(string FileName, ReportDocument rpt, System.Web.UI.Control ClientScriptBlockControl, ExportFormatType pvtExportFormatType)
        {
            try
            {
                ExportOptions exportop = new ExportOptions();
                DiskFileDestinationOptions dest = new DiskFileDestinationOptions();

                string strFileExtensionName = ".pdf";
                switch (pvtExportFormatType)
                {
                    case ExportFormatType.PortableDocFormat: strFileExtensionName = ".pdf"; exportop.ExportFormatType = ExportFormatType.PortableDocFormat; break;
                    case ExportFormatType.WordForWindows: strFileExtensionName = ".doc"; exportop.ExportFormatType = ExportFormatType.WordForWindows; break;
                    case ExportFormatType.Excel: strFileExtensionName = ".xls"; exportop.ExportFormatType = ExportFormatType.Excel; break;
                }

                string strPath = System.Web.HttpContext.Current.Server.MapPath(@"\retailplus\temp\");
                string strFileName = FileName + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + strFileExtensionName;

                if (System.IO.File.Exists(strPath + strFileName))
                    System.IO.File.Delete(strPath + strFileName);

                dest.DiskFileName = strPath + strFileName;
                exportop.DestinationOptions = dest;
                exportop.ExportDestinationType = ExportDestinationType.DiskFile;
                rpt.Export(exportop); //rpt.Close(); rpt.Dispose();
                
                // remove the error
                if (pvtExportFormatType == ExportFormatType.WordForWindows || pvtExportFormatType == ExportFormatType.Excel || pvtExportFormatType == ExportFormatType.PortableDocFormat)
                {
                    // the maximum report processing jobs limit configured by your system administrator has been reached.
                    rpt.Close(); rpt.Dispose();
                }

                if (pvtExportFormatType == ExportFormatType.PortableDocFormat)
                {
                    string newWindowUrl = Constants.ROOT_DIRECTORY + "/temp/" + strFileName;
                    string javaScript = "window.open('" + newWindowUrl + "');";
                    System.Web.UI.ScriptManager.RegisterClientScriptBlock(ClientScriptBlockControl, ClientScriptBlockControl.GetType(), "openwindow", javaScript, true);
                }
                else
                {
                    string newWindowUrl = Constants.ROOT_DIRECTORY + "/temp/" + strFileName;
                    string javaScript = "window.open('" + newWindowUrl + "','_self');";
                    System.Web.UI.ScriptManager.RegisterClientScriptBlock(ClientScriptBlockControl, ClientScriptBlockControl.GetType(), "openwindow", javaScript, true);

                    //System.Diagnostics.Process p = new System.Diagnostics.Process();
                    //p.StartInfo.FileName = System.Web.HttpContext.Current.Server.MapPath(Constants.ROOT_DIRECTORY + "/temp/" + strFileName);
                    //p.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
                    //p.Start();
                }
            }
            catch (Exception ex) { throw ex; }
        }
Beispiel #15
0
 private IEnumerable<IXmlWriter> GetWriters(ExportOptions options)
 {
     if((options & ExportOptions.OnlyDefinedDetails) == ExportOptions.OnlyDefinedDetails)
         yield return new DefinedDetailXmlWriter(definitions);
     else
         yield return new DetailXmlWriter();
     yield return new DetailCollectionXmlWriter();
     yield return new ChildXmlWriter();
     yield return new AuthorizationXmlWriter();
     if ((options & ExportOptions.ExcludeAttachments) == ExportOptions.Default)
         yield return new AttachmentXmlWriter();
 }
Beispiel #16
0
	    public virtual void Export(ContentItem item, ExportOptions options, HttpResponse response)
		{
			response.ContentType = GetContentType();
			response.AppendHeader("Content-Disposition", "attachment;filename=" + GetExportFilename(item));

			using (var output = GetTextWriter(response))
			{
				Export(item, options, output);
				output.Flush();
			}
			response.End();
		}
        public void PrintReport(string key)
        {
            try
            {
                ReportDocument objRpt = new ReportDocument();
                DataSet ds = (DataSet)this.GetDataReport(key);

                string reportPath = "C:\\Reportes\\CRIngreso_etiqueta02.rpt";
                objRpt.Load(reportPath);

                DiskFileDestinationOptions crDiskFileDestinationOption = new DiskFileDestinationOptions();
                PdfRtfWordFormatOptions crFormatTypeOption = new PdfRtfWordFormatOptions();
                ExportOptions crExportOptions = new ExportOptions();

                objRpt.SetDataSource(ds.Tables[0]);
                string strfolder = "C:\\Reporte\\";
                crDiskFileDestinationOption.DiskFileName = strfolder + "Etiqueta.pdf";

                crExportOptions = objRpt.ExportOptions;
                crExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
                crExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;
                crExportOptions.ExportDestinationOptions = crDiskFileDestinationOption;
                crExportOptions.ExportFormatOptions = crFormatTypeOption;
                objRpt.Export();

                this.printDialog1.Document = this.printDocument1;
                DialogResult dr = this.printDialog1.ShowDialog();
                if (dr == DialogResult.OK)
                {

                    PageMargins margins;

                    margins = objRpt.PrintOptions.PageMargins;
                    margins.bottomMargin = 250;
                    margins.leftMargin = 250;
                    margins.rightMargin = 250;
                    margins.topMargin = 250;
                    objRpt.PrintOptions.ApplyPageMargins(margins);

                    string PrinterName = this.printDocument1.PrinterSettings.PrinterName;
                    objRpt.PrintOptions.PrinterName = PrinterName;
                    objRpt.PrintToPrinter(1, false, 0, 0);

                }

            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }
Beispiel #18
0
		public JsonDataExportContext(ExportOptions exportOptions, IReadOnlyList<ColumnHeader> columns, IDataExportConverter dataExportConverter)
			: base(exportOptions)
		{
			_columns = columns;
			_dataExportConverter = dataExportConverter;

			var columnHeaders = _columns
				.Select((h, i) => String.Format(MaskJsonValue, h.Name.Replace("{", "{{").Replace("}", "}}").Replace(QuoteCharacter, EscapedQuote), i));

			var jsonTemplateBuilder = new StringBuilder();
			jsonTemplateBuilder.AppendLine("  {{");
			jsonTemplateBuilder.AppendLine(String.Join($",{Environment.NewLine}", columnHeaders));
			jsonTemplateBuilder.Append("  }}");
			_jsonRowTemplate = jsonTemplateBuilder.ToString();
		}
Beispiel #19
0
		public virtual void Export(ContentItem item, ExportOptions options, TextWriter output)
		{
			var xmlOutput = new XmlTextWriter(output) {Formatting = XmlFormatting};
		    xmlOutput.WriteStartDocument();

			using (var envelope = new ElementWriter("n2", xmlOutput))
			{
				envelope.WriteAttribute("version", GetType().Assembly.GetName().Version.ToString());
				envelope.WriteAttribute("exportVersion", 2);
				envelope.WriteAttribute("exportDate", Utility.CurrentTime());

				itemWriter.Write(item, options, xmlOutput);
			}

			xmlOutput.WriteEndDocument();
			xmlOutput.Flush();
		}
Beispiel #20
0
        public virtual void Export(ContentItem item, ExportOptions options, TextWriter output)
        {
            XmlTextWriter xmlOutput = new XmlTextWriter(output);
            xmlOutput.Formatting = XmlFormatting;
            xmlOutput.WriteStartDocument();

            using (ElementWriter envelope = new ElementWriter("zeus", xmlOutput))
            {
                envelope.WriteAttribute("version", GetType().Assembly.GetName().Version.ToString());
                envelope.WriteAttribute("exportVersion", 1);
                envelope.WriteAttribute("exportDate", DateTime.Now);

                itemWriter.Write(item, options, xmlOutput);
            }

            xmlOutput.WriteEndDocument();
            xmlOutput.Flush();
        }
        /// <summary>
        /// Sự kiện xuất Format options
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExport_Click(object sender, EventArgs e)
        {
            string fileName = "E:\\ReportSource\\Report_Test\\Report_Test\\bin\\Export.xls";
            SaveFileDialog save = new SaveFileDialog();
            save.Filter = "Crystal report |(*.rpt)| Portable Document Format |(*.pdf)| MS Excel 97-2003 |(*.xls)| MS Excel 97-2003 (Data Only)|(*.xls)| MS Word |(*.doc)|";

            ExportOptions _exportOpts = new ExportOptions();
            DiskFileDestinationOptions _diskDesOpts = new DiskFileDestinationOptions();
            _exportOpts = report.ExportOptions;
            if (save.FileName != "")
            {
                switch (save.FilterIndex)
                {

                    case 1:
                        _exportOpts.ExportFormatType = ExportFormatType.CrystalReport;
                        break;
                    case 2:
                        _exportOpts.ExportFormatType = ExportFormatType.PortableDocFormat;
                        Export_Opts _frmExpOpts = new Export_Opts();
                        _frmExpOpts.ShowDialog();
                        break;
                    case 3:
                        _exportOpts.ExportFormatType = ExportFormatType.Excel;
                        ExcelFormatOption _frmExFormatOpts = new ExcelFormatOption();
                        _frmExFormatOpts.ShowDialog();
                        break;
                    case 4:
                        _exportOpts.ExportFormatType = ExportFormatType.ExcelRecord;
                        _frmExFormatOpts = new ExcelFormatOption();
                        _frmExFormatOpts.ShowDialog();
                        break;
                    case 5:
                        _exportOpts.ExportFormatType = ExportFormatType.WordForWindows;
                        _frmExpOpts = new Export_Opts();
                        _frmExpOpts.ShowDialog();
                        break;
                }
            }
            //Ổ đĩa lưu giữ file
            _exportOpts.ExportDestinationType = ExportDestinationType.DiskFile;
            _diskDesOpts.DiskFileName = fileName;
            _exportOpts.DestinationOptions = _diskDesOpts;
        }
Beispiel #22
0
        private void btnExport_Click(object sender, EventArgs e)
        {
            RPT.rpt_single_category myReport  = new RPT.rpt_single_category();
            PdfFormatOptions        pdfformat = new PdfFormatOptions();
            //crate export qptions
            ExportOptions export = new ExportOptions();
            //create object for destination
            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();

            //set the path of destination
            dfoptions.DiskFileName = @"F:\المحاسبة\Program\ProductsHB\Categories.pdf";
            export = myReport.ExportOptions;
            export.ExportDestinationType    = ExportDestinationType.DiskFile;
            export.ExportFormatType         = ExportFormatType.PortableDocFormat;
            export.ExportFormatOptions      = pdfformat;
            export.ExportDestinationOptions = dfoptions;

            myReport.SetParameterValue("@id", Convert.ToInt32(txtID.Text));
            myReport.Export();
            MessageBox.Show("!تم حفظ اللائحة بنجاح", "تم", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        private void btn_Sava_Excel_Click_1(object sender, EventArgs e)
        {
            try
            {
                this.Cursor = Cursors.WaitCursor;

                RPT.RPT_PRODUCT_ALL myreport = new RPT.RPT_PRODUCT_ALL();

                //create export options
                ExportOptions expoert = new ExportOptions();

                //create object for destination
                DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();

                ExcelFormatOptions exelformat = new ExcelFormatOptions();
                //set the path of destionation
                SaveFileDialog ofd = new SaveFileDialog();
                ofd.Filter = "ملفات exel | *.xls";
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    dfoptions.DiskFileName = ofd.FileName;
                }

                expoert = myreport.ExportOptions;

                expoert.ExportDestinationType = ExportDestinationType.DiskFile;

                expoert.ExportFormatType = ExportFormatType.Excel;

                expoert.ExportFormatOptions      = exelformat;
                expoert.ExportDestinationOptions = dfoptions;
                myreport.Export();
                this.Cursor = Cursors.Default;
                MessageBox.Show("تم حفظ الملف بنجاح", "الحفظ", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch
            {
                return;
            }
        }
Beispiel #24
0
        private void GenerateWord()
        {
            ReportDocument rpt = new ReportDocument();

            switch (cboView.SelectedItem.Value)
            {
            case "0":
                rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/ChartOfAccountsDetails.rpt"));
                break;

            case "1":
                rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/ChartOfAccountsSummary.rpt"));
                break;
            }

            ExportOptions exportop          = new ExportOptions();
            DiskFileDestinationOptions dest = new DiskFileDestinationOptions();

            string strPath = Server.MapPath(@"\retailplus\temp\");

            string strFileName = "chartofacc_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".doc";

            if (System.IO.File.Exists(strPath + strFileName))
            {
                System.IO.File.Delete(strPath + strFileName);
            }

            dest.DiskFileName = strPath + strFileName;

            exportop = rpt.ExportOptions;

            SetDataSource(rpt);

            exportop.DestinationOptions    = dest;
            exportop.ExportDestinationType = ExportDestinationType.DiskFile;
            exportop.ExportFormatType      = ExportFormatType.WordForWindows;
            rpt.Export();   rpt.Close();    rpt.Dispose();

            fraViewer.Attributes.Add("src", "/retailplus/temp/" + strFileName);
        }
Beispiel #25
0
        private void btnSelectPdf_Click(object sender, EventArgs e)
        {
            RPT.RPT_SINGLE_CATEGORE myreport = new RPT.RPT_SINGLE_CATEGORE();

            //create export options
            ExportOptions expoert = new ExportOptions();

            //create object for destination
            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();

            PdfFormatOptions pdfformat = new PdfFormatOptions();

            //set the path of destionation
            SaveFileDialog ofd = new SaveFileDialog();

            ofd.Filter = "ملفات pdf | *.pdf";
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                dfoptions.DiskFileName = ofd.FileName;
            }


            expoert = myreport.ExportOptions;

            expoert.ExportDestinationType = ExportDestinationType.DiskFile;

            expoert.ExportFormatType = ExportFormatType.PortableDocFormat;

            expoert.ExportFormatOptions      = pdfformat;
            expoert.ExportDestinationOptions = dfoptions;

            // set parameters
            myreport.SetParameterValue("@ID", Convert.ToInt32(txtID.Text));

            // make refresh
            // myreport.Refresh();

            myreport.Export();
            MessageBox.Show("تم حفظ الملف بنجاح", "الحفظ", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        private void button7_Click(object sender, EventArgs e)
        {
            try
            {
                RPT.RPT_All_Medicines MedsReport = new RPT.RPT_All_Medicines();

                //Create export options
                ExportOptions EXO = new ExportOptions();

                //Excel Format Options object
                ExcelFormatOptions ExcelFormat = new ExcelFormatOptions();

                //Create object for destination
                DiskFileDestinationOptions DFDO = new DiskFileDestinationOptions();

                //Set the path of destination
                DFDO.DiskFileName = @"D:\MedicineList.xls";

                //Options
                EXO = MedsReport.ExportOptions;
                //
                EXO.ExportDestinationType = ExportDestinationType.DiskFile;
                //
                EXO.ExportFormatType = ExportFormatType.Excel;
                //
                EXO.ExportFormatOptions = ExcelFormat;
                //
                EXO.ExportDestinationOptions = DFDO;

                //Export
                MedsReport.Export();

                //Show message
                MessageBox.Show("تم تصدير اللائحة بنجاح", "عملية التصدير", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch
            {
                MessageBox.Show("حدث خطأ ما", "خطأ", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Beispiel #27
0
        private void btnSaveCatPro_Click(object sender, EventArgs e)
        {
            saveFileDialog1.Title    = "Save to:";
            saveFileDialog1.FileName = "Categories Details.pdf";
            saveFileDialog1.Filter   = "PDF file |*.pdf";

            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                string Path = saveFileDialog1.FileName;

                RPT.RPT_SINGLE_CATEGORIE myReport = new RPT.RPT_SINGLE_CATEGORIE();

                // Create Export Option
                ExportOptions export = new ExportOptions();

                // Create Obect For Destination
                DiskFileDestinationOptions dfoption = new DiskFileDestinationOptions();

                PdfFormatOptions pdfformat = new PdfFormatOptions();

                // Set The Path Of Destination
                dfoption.DiskFileName = Path;

                export = myReport.ExportOptions;

                export.ExportDestinationType = ExportDestinationType.DiskFile;

                export.ExportFormatType = ExportFormatType.PortableDocFormat;

                export.ExportFormatOptions = pdfformat;

                export.ExportDestinationOptions = dfoption;

                myReport.SetParameterValue("@ID", Convert.ToInt32(txtID.Text));

                myReport.Export();

                MessageBox.Show("Liste Exportée avec Succès", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
Beispiel #28
0
        private void StreamToClient(Stream stream, ExportOptions options, Lazy <NameValueCollection> headers, IPrincipal user)
        {
            var old     = CurrentOperationContext.Headers.Value;
            var oldUser = CurrentOperationContext.User.Value;

            try
            {
                CurrentOperationContext.Headers.Value = headers;
                CurrentOperationContext.User.Value    = user;

                Database.TransactionalStorage.Batch(accessor =>
                {
                    var bufferStream = new BufferedStream(stream, 1024 * 64);

                    using (var cts = new CancellationTokenSource())
                        using (var timeout = cts.TimeoutAfter(DatabasesLandlord.SystemConfiguration.DatabaseOperationTimeout))
                            using (var streamWriter = new StreamWriter(bufferStream))
                                using (var writer = new JsonTextWriter(streamWriter))
                                {
                                    writer.WriteStartObject();
                                    writer.WritePropertyName("Results");
                                    writer.WriteStartArray();

                                    var exporter = new SmugglerExporter(Database, options);

                                    exporter.Export(item => WriteToStream(writer, item, timeout), cts.Token);

                                    writer.WriteEndArray();
                                    writer.WriteEndObject();
                                    writer.Flush();
                                    bufferStream.Flush();
                                }
                });
            }
            finally
            {
                CurrentOperationContext.Headers.Value = old;
                CurrentOperationContext.User.Value    = oldUser;
            }
        }
Beispiel #29
0
        protected override TemplatedLink CreateLink()
        {
            SimpleLink link = new SimpleLink();

#if SILVERLIGHT
            link.ExportServiceUri = ReportHeaderTemplateDataContext.exportServiceUrl;
#else
            link.PaperKind = System.Drawing.Printing.PaperKind.A4;
            if (!string.IsNullOrEmpty(BasePage.session.User._Printer))
            {
                link.PrintingSystem.PageSettings.PrinterName = BasePage.session.User._Printer;
            }
#endif
            link.PrintingSystem.ExportOptions.Html.EmbedImagesInHTML = true;
            ExportOptions      options      = link.PrintingSystem.ExportOptions;
            ExportOptionKind[] OptionsKinds = new ExportOptionKind[] {
                ExportOptionKind.PdfConvertImagesToJpeg,
                ExportOptionKind.PdfACompatibility,
                ExportOptionKind.PdfDocumentAuthor,
                ExportOptionKind.PdfDocumentKeywords,
                ExportOptionKind.PdfDocumentSubject,
                ExportOptionKind.PdfDocumentKeywords,
            };
            if (ReportHeaderTemplateDataContext._Landscape)
            {
                link.Landscape = true;
            }
            link.Margins.Right  = 5;
            link.Margins.Left   = 5;
            link.Margins.Top    = 10;
            link.Margins.Bottom = 10;
            options.SetOptionsVisibility(OptionsKinds, true);
            link.PageHeaderData     = ReportHeaderTemplateDataContext;
            link.PageHeaderTemplate = PageHeaderTemplate;
            link.DetailTemplate     = DetailTemplate;
            link.DetailCount        = ReportDetailsTemplateDataContext.BalanceReportlist.Count;
            link.CreateDetail      += link_CreateDetail;
            return(link);
        }
    /// <summary>
    /// Saves the song data in a .chart format to the specified path.
    /// </summary>
    /// <param name="filepath">The path and filename to save to.</param>
    /// <param name="forced">Will the notes from each chart have their flag properties saved into the file?</param>
    public void Save(string filepath, ExportOptions exportOptions)
    {
        string saveErrorMessage;

        try
        {
            new ChartWriter(filepath).Write(this, exportOptions, out saveErrorMessage);

            Debug.Log("Save complete!");

            if (saveErrorMessage != string.Empty)
            {
                saveError = true;
                ErrorMessage.errorMessage = "Save completed with the following errors: " + Globals.LINE_ENDING + saveErrorMessage;
            }
        }
        catch (System.Exception e)
        {
            saveError = true;
            ErrorMessage.errorMessage = Logger.LogException(e, "Save failed!");
        }
    }
Beispiel #31
0
        private void Export(ExportFormatType pvtExportFormatType)
        {
            ReportDocument rpt = new ReportDocument();
            rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/_StockTransactionReport.rpt"));

            SetDataSource(rpt);

            ExportOptions exportop = new ExportOptions();
            DiskFileDestinationOptions dest = new DiskFileDestinationOptions();
            string strPath = Server.MapPath(@"\retailplus\temp\");
            string strFileExtensionName = ".pdf";
            switch (pvtExportFormatType)
            {
                case ExportFormatType.PortableDocFormat: strFileExtensionName = ".pdf"; exportop.ExportFormatType = ExportFormatType.PortableDocFormat; break;
                case ExportFormatType.WordForWindows: strFileExtensionName = ".doc"; exportop.ExportFormatType = ExportFormatType.WordForWindows; break;
                case ExportFormatType.Excel: strFileExtensionName = ".xls"; exportop.ExportFormatType = ExportFormatType.Excel; break;
            }
            string strFileName = "tranreport_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + strFileExtensionName;
            if (System.IO.File.Exists(strPath + strFileName))
                System.IO.File.Delete(strPath + strFileName);

            dest.DiskFileName = strPath + strFileName;
            exportop.DestinationOptions = dest;
            exportop.ExportDestinationType = ExportDestinationType.DiskFile;
            rpt.Export(exportop); //rpt.Close(); rpt.Dispose(); 

            if (pvtExportFormatType == ExportFormatType.PortableDocFormat)
            {
                rpt.Close(); rpt.Dispose();
                Response.Redirect(Constants.ROOT_DIRECTORY + "/temp/" + strFileName, false);
            }
            else 
            {
                CRViewer.ReportSource = rpt;
                Session["ReportDocument"] = rpt;
                CRSHelper.OpenExportedReport(strFileName); // OpenExportedReport(strFileName);
            }
            
        }
Beispiel #32
0
        private int WriteStrings(Stream s, IList <TFString> strings, ExportOptions options, Ofs3Data file)
        {
            int result   = 0;
            var tfString = strings.FirstOrDefault(x => x.Offset == file.StartOffset);

            if (tfString != null)
            {
                var str = tfString.Translation;

                if (tfString.Visible && !string.IsNullOrEmpty(str))
                {
                    if (options.CharReplacement != 0)
                    {
                        str = Utils.ReplaceChars(str, options.CharReplacementList);
                    }

                    str = SAOProject.WritingReplacements(str);

                    s.WriteStringZ(str, options.SelectedEncoding);

                    result = str.GetLength(options.SelectedEncoding) + 1;
                }
                else
                {
                    s.WriteStringZ(tfString.Original, options.SelectedEncoding);

                    result = tfString.Original.GetLength(options.SelectedEncoding) + 1;
                }

                while (s.Position % file.Padding != 0)
                {
                    s.WriteValueU8(0);

                    result++;
                }
            }

            return(result);
        }
Beispiel #33
0
        public void ExportOptionsTest()
        {
            var           mock = new Mock <IExporterModel>();
            ExportOptions opts = null;

            mock.Setup(m => m.Export(It.IsAny <ExportOptions>())).Callback <ExportOptions>(e => opts = e);

            var vm = new ExporterVM(mock.Object, new Mock <IMessageService>().Object, new Mock <IXLogger>().Object, new Mock <IAboutService>().Object);

            vm.Filter           = "*.sld*";
            vm.Format           = Format_e.Pdf | Format_e.Html;
            vm.IsTimeoutEnabled = true;
            vm.Timeout          = 30;
            vm.OutputDirectory  = "D:\\outdir";

            vm.ExportCommand.Execute(null);

            Assert.AreEqual("*.sld*", opts.Filter);
            Assert.IsTrue(new string[] { "html", "pdf" }.SequenceEqual(opts.Format));
            Assert.AreEqual(30, opts.Timeout);
            Assert.AreEqual("D:\\outdir", opts.OutputDirectory);
        }
Beispiel #34
0
        public static string ExportList(List <ExportRecordDTO> result, ExportOptions options, int totalRows,
                                        Func <Document, Table, object> _pdfOvveride = null)
        {
            var link = string.Empty;

            switch (options.Type)
            {
            case Type.PDF:
                link = ExportListToPDF(options, result, totalRows, _pdfOvveride);
                break;

            case Type.EXCEL:
                link = ExportListToOffice(options, "xls", result, totalRows);
                break;

            case Type.WORD:
                link = ExportListToOffice(options, "doc", result, totalRows);
                break;
            }

            return(link);
        }
Beispiel #35
0
        private void btnSaveAll_Click(object sender, EventArgs e)
        {
            RPT.rpt_all_categories rpt    = new RPT.rpt_all_categories();
            ExportOptions          export = new ExportOptions();

            export = rpt.ExportOptions;

            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();
            string PdfReportsPath = Application.StartupPath.Substring(0, (Application.StartupPath.Length - 10)) + @"\PdfReports\";

            dfoptions.DiskFileName          = PdfReportsPath + "AllCategoryList-" + DateTime.Now.ToString("dddd, dd MMMM yyyy") + ".pdf";
            export.ExportDestinationOptions = dfoptions;
            export.ExportDestinationType    = ExportDestinationType.DiskFile;

            PdfFormatOptions pdf = new PdfFormatOptions();

            export.ExportFormatOptions = pdf;
            export.ExportFormatType    = ExportFormatType.PortableDocFormat;
            rpt.Refresh();
            rpt.Export();
            MessageBox.Show("All Category List Exported Successfully", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
Beispiel #36
0
        /// ************************************************************************************
        /// NOMBRE:             Exportar_Reporte_PDF
        /// DESCRIPCIÓN:        Método que guarda el reporte generado en formato PDF en la ruta
        ///                     especificada.
        /// PARÁMETROS:         Reporte.- Objeto de tipo documento que contiene el reporte a guardar.
        ///                     Nombre_Reporte.- Nombre que se le dio al reporte.
        /// USUARIO CREO:       Juan Alberto Hernández Negrete.
        /// FECHA CREO:         3/Mayo/2011 18:19 p.m.
        /// USUARIO MODIFICO:
        /// FECHA MODIFICO:
        /// CAUSA MODIFICACIÓN:
        /// *************************************************************************************
        public static void Exportar_Reporte_PDF(ReportDocument Reporte, String Nombre_Reporte_Generar, Page Server)
        {
            ExportOptions Opciones_Exportacion = new ExportOptions();
            DiskFileDestinationOptions Direccion_Guardar_Disco = new DiskFileDestinationOptions();
            PdfRtfWordFormatOptions    Opciones_Formato_PDF    = new PdfRtfWordFormatOptions();

            try
            {
                if (Reporte is ReportDocument)
                {
                    Direccion_Guardar_Disco.DiskFileName          = Server.MapPath(Nombre_Reporte_Generar);
                    Opciones_Exportacion.ExportDestinationOptions = Direccion_Guardar_Disco;
                    Opciones_Exportacion.ExportDestinationType    = ExportDestinationType.DiskFile;
                    Opciones_Exportacion.ExportFormatType         = ExportFormatType.PortableDocFormat;
                    Reporte.Export(Opciones_Exportacion);
                }
            }
            catch (Exception Ex)
            {
                throw new Exception("Exportar_Reporte_PDF. Error: [" + Ex.Message + "]");
            }
        }
Beispiel #37
0
        private void _btnExportarXls_Click(object sender, EventArgs e)
        {
            try
            {
                string         nombreArchivo = string.Empty;
                SaveFileDialog sfDialog      = new SaveFileDialog();
                sfDialog.InitialDirectory = "c:\\";
                sfDialog.Title            = "Guardar Reporte XLS como";
                sfDialog.Filter           = "Archivos XLS|*.xls|Todos Archivos|*.*";
                sfDialog.FileName         = "";
                if (sfDialog.ShowDialog() != DialogResult.Cancel)
                {
                    nombreArchivo = sfDialog.FileName;
                    // Declarar variables y obtener las opciones de exportación.
                    ExportOptions              exportOpts      = new ExportOptions();
                    ExcelFormatOptions         excelFormatOpts = new ExcelFormatOptions();
                    DiskFileDestinationOptions diskOpts        = new DiskFileDestinationOptions();
                    exportOpts = _docRpt.ExportOptions;

                    // Establecer las opciones de formato de Excel.
                    excelFormatOpts.ExcelUseConstantColumnWidth = false;
                    exportOpts.ExportFormatType = ExportFormatType.Excel;
                    exportOpts.FormatOptions    = excelFormatOpts;

                    // Establecer las opciones de archivo de disco y de exportación.
                    exportOpts.ExportDestinationType = ExportDestinationType.DiskFile;
                    diskOpts.DiskFileName            = nombreArchivo;
                    exportOpts.DestinationOptions    = diskOpts;

                    _docRpt.Export();
                    AbrirArchivo(sfDialog.FileName);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Exportar : " + ex.Message);
                PistaMgr.Instance.Error("Reportes.ExportarXLS", ex);
            }
        }
Beispiel #38
0
        private void WriteString(Stream s, TFString tfString, ExportOptions options)
        {
            var pos   = s.Position;
            var zeros = new byte[64];

            s.WriteBytes(zeros);
            s.Seek(pos, SeekOrigin.Begin);

            string   str;
            Encoding enc;
            bool     replace;

            if (tfString.Original == tfString.Translation)
            {
                str     = tfString.Original;
                enc     = Encoding;
                replace = false;
            }
            else
            {
                str     = tfString.Translation;
                enc     = options.SelectedEncoding;
                replace = options.CharReplacement != 0;
            }
            if (replace)
            {
                str = Utils.ReplaceChars(str, options.CharReplacementList);
            }
            str = Yakuza0Project.WritingReplacements(str);

            if (str.GetLength(options.SelectedEncoding) >= 64)
            {
                str = str.Substring(0, 63);
            }

            s.WriteStringZ(str, enc);

            s.Seek(pos + 64, SeekOrigin.Begin);
        }
Beispiel #39
0
        public System.Xml.Schema.XmlSchema ExportXsd <T>(params Type[] knownTypes)
        {
            Type tp = typeof(T);
            XsdDataContractExporter exporter = new XsdDataContractExporter();

            // Use the ExportOptions to add the Possessions type to the
            // collection of KnownTypes.
            if (knownTypes != null)
            {
                ExportOptions eOptions = new ExportOptions();
                foreach (Type kt in knownTypes)
                {
                    eOptions.KnownTypes.Add(kt);
                }
                exporter.Options = eOptions;
            }

            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            if (exporter.CanExport(tp))
            {
                exporter.Export(tp);
                //Console.WriteLine("number of schemas: {0}", exporter.Schemas.Count)
                //Console.WriteLine()
                var    mySchemas                   = exporter.Schemas;
                var    XmlNameValue                = exporter.GetRootElementName(tp);
                string EmployeeNameSpace           = XmlNameValue.Namespace;
                System.Xml.Schema.XmlSchema schema = null;
                foreach (System.Xml.Schema.XmlSchema schema_loopVariable in mySchemas.Schemas(EmployeeNameSpace))
                {
                    schema = schema_loopVariable;
                    schema.Write(ms);
                }
            }
            System.Xml.Schema.XmlSchema xd = new System.Xml.Schema.XmlSchema();
            ms.Position = 0;
            xd          = System.Xml.Schema.XmlSchema.Read(ms, new System.Xml.Schema.ValidationEventHandler(XmlSchema_ValidationCallBack));
            return(xd);
        }
        public void ExportReport(string fullPathXmlFileName, string fullPathReportGeneratorFileName, string fullPathEndOfRunReportPdfFileName)
        {
            if (string.IsNullOrEmpty(fullPathXmlFileName) || string.IsNullOrEmpty(fullPathReportGeneratorFileName) || string.IsNullOrEmpty(fullPathEndOfRunReportPdfFileName))
            {
                return;
            }

            try
            {
                if (FormatReport(fullPathXmlFileName, fullPathReportGeneratorFileName) == false)
                {
                    return;
                }

                // Declare variables and get the export options.
                ExportOptions              exportOpts    = new ExportOptions();
                PdfFormatOptions           pdfFormatOpts = new PdfFormatOptions();
                DiskFileDestinationOptions diskOpts      = new DiskFileDestinationOptions();
                exportOpts = cryRptDoc.ExportOptions;

                // Set the pdf format options.
                exportOpts.ExportFormatType = ExportFormatType.PortableDocFormat;
                exportOpts.FormatOptions    = pdfFormatOpts;

                // Set the disk file options and export.
                exportOpts.ExportDestinationType = ExportDestinationType.DiskFile;
                diskOpts.DiskFileName            = fullPathEndOfRunReportPdfFileName;
                exportOpts.DestinationOptions    = diskOpts;
                cryRptDoc.Export();

                // Close the report
                cryRptDoc.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Beispiel #41
0
        protected override TemplatedLink CreateLink()
        {
            SimpleLink link = new SimpleLink();

#if SILVERLIGHT
            link.ExportServiceUri = ReportHeaderDataContext.exportUri;
#endif
            link.PrintingSystem.ExportOptions.Html.EmbedImagesInHTML = true;
#if !SILVERLIGHT
            link.PrintingSystem.Graph.PageBackColor = System.Drawing.Color.Transparent;
            if (!string.IsNullOrEmpty(BasePage.session.User._Printer))
            {
                link.PrintingSystem.PageSettings.PrinterName = BasePage.session.User._Printer;
            }
#endif
            ExportOptions      options      = link.PrintingSystem.ExportOptions;
            ExportOptionKind[] OptionsKinds = new ExportOptionKind[] {
                ExportOptionKind.PdfConvertImagesToJpeg,
                ExportOptionKind.PdfACompatibility,
                ExportOptionKind.PdfDocumentAuthor,
                ExportOptionKind.PdfDocumentKeywords,
                ExportOptionKind.PdfDocumentSubject,
                ExportOptionKind.PdfDocumentKeywords,
            };
            options.SetOptionsVisibility(OptionsKinds, true);

            ((DevExpress.Xpf.Printing.LinkBase)(link)).Margins.Left  = 40;
            ((DevExpress.Xpf.Printing.LinkBase)(link)).Margins.Right = 20;
            link.PageHeaderData     = ReportHeaderDataContext;
            link.PageHeaderTemplate = PageHeaderTemplate;
            link.DetailTemplate     = DetailTemplate;
#if !SILVERLIGHT
            link.PaperKind = System.Drawing.Printing.PaperKind.A4;
#endif
            link.DetailCount   = 1;
            link.CreateDetail += link_CreateDetail;
            return(link);
        }
Beispiel #42
0
        public virtual void WriteChildPartsWithZones(ContentItem item, ExportOptions options, XmlTextWriter writer)
        {
            var itemsInZones = item.Children.GroupBy(x => x.ZoneName);

            foreach (var zone in itemsInZones)
            {
                using (var zoneElement = new ElementWriter("section", writer))
                {
                    zoneElement.WriteAttribute("class", "zone");
                    zoneElement.WriteAttribute("id", zone.Key);

                    foreach (var childItem in zone)
                    {
                        using (var partElement = new ElementWriter("part", writer))
                        {
                            partElement.WriteAttribute("id", childItem.ID);
                            WriteSingleItem(childItem, options, writer);
                            WriteChildPartsWithZones(childItem, options, writer); // recursively until there are no more zones
                        }
                    }
                }
            }
        }
Beispiel #43
0
        public async Task Export(ExportOptions opts)
        {
            m_CurrentCancellationToken = new CancellationTokenSource();

            var logWriter = new LogWriter();
            var prgHander = new ProgressHandler();

            logWriter.Log             += OnLog;
            prgHander.ProgressChanged += OnProgressChanged;

            try
            {
                using (var exporter = new Exporter(logWriter, prgHander))
                {
                    await exporter.Export(opts, m_CurrentCancellationToken.Token).ConfigureAwait(false);
                }
            }
            finally
            {
                logWriter.Log             += OnLog;
                prgHander.ProgressChanged += OnProgressChanged;
            }
        }
Beispiel #44
0
        private void btnSaveCat_Click(object sender, EventArgs e)
        {
            RPT.rpt_single_category rpt = new RPT.rpt_single_category();
            rpt.SetParameterValue("@id", Int32.Parse(txtCatId.Text));
            ExportOptions export = new ExportOptions();

            export = rpt.ExportOptions;

            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();
            string PdfReportsPath = Application.StartupPath.Substring(0, (Application.StartupPath.Length - 10)) + @"\PdfReports\";

            dfoptions.DiskFileName          = PdfReportsPath + "CategoryList-" + DateTime.Now.ToString("dddd, dd MMMM yyyy") + ".pdf";
            export.ExportDestinationOptions = dfoptions;
            export.ExportDestinationType    = ExportDestinationType.DiskFile;

            PdfFormatOptions pdf = new PdfFormatOptions();

            export.ExportFormatOptions = pdf;
            export.ExportFormatType    = ExportFormatType.PortableDocFormat;

            rpt.Export();
            MessageBox.Show("Category Product List Exported Successfully", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
Beispiel #45
0
        /// *************************************************************************************
        /// NOMBRE: Exportar_Reporte_PDF
        ///
        /// DESCRIPCIÓN: Método que guarda el reporte generado en formato PDF en la ruta
        ///              especificada.
        ///
        /// PARÁMETROS: Reporte.- Objeto de tipo documento que contiene el reporte a guardar.
        ///             Nombre_Reporte.- Nombre que se le dará al reporte.
        ///
        /// USUARIO CREO: Juan Alberto Hernández Negrete.
        /// FECHA CREO: 3/Mayo/2011 18:19 p.m.
        /// USUARIO MODIFICO:
        /// FECHA MODIFICO:
        /// CAUSA MODIFICACIÓN:
        /// *************************************************************************************
        protected void Exportar_Reporte_PDF(ReportDocument Reporte, String Nombre_Reporte, string Ruta_PDF)
        {
            ExportOptions Opciones_Exportacion = new ExportOptions();
            DiskFileDestinationOptions Direccion_Guardar_Disco = new DiskFileDestinationOptions();
            PdfRtfWordFormatOptions    Opciones_Formato_PDF    = new PdfRtfWordFormatOptions();

            Ruta_PDF = @Server.MapPath(Ruta_PDF) + Nombre_Reporte;
            try
            {
                if (Reporte is ReportDocument)
                {
                    Direccion_Guardar_Disco.DiskFileName          = Ruta_PDF;
                    Opciones_Exportacion.ExportDestinationOptions = Direccion_Guardar_Disco;
                    Opciones_Exportacion.ExportDestinationType    = ExportDestinationType.DiskFile;
                    Opciones_Exportacion.ExportFormatType         = ExportFormatType.PortableDocFormat;
                    Reporte.Export(Opciones_Exportacion);
                }
            }
            catch (Exception Ex)
            {
                throw new Exception("Error al exportar el reporte. Error: [" + Ex.Message + "]");
            }
        }
Beispiel #46
0
        private void WriteString(Stream s, TFString str, ExportOptions options)
        {
            if (str.Original == str.Translation)
            {
                var aux = str.Original;

                aux = Yakuza0Project.WritingReplacements(aux);

                s.WriteStringZ(aux, Encoding);
            }
            else
            {
                var aux = str.Translation;
                if (options.CharReplacement != 0)
                {
                    aux = Utils.ReplaceChars(aux, options.CharReplacementList);
                }

                aux = Yakuza0Project.WritingReplacements(aux);

                s.WriteStringZ(aux, options.SelectedEncoding);
            }
        }
        private void exportpdfbtn_Click(object sender, EventArgs e)
        {
            All_Cat_Report             report   = new All_Cat_Report();
            ExportOptions              export   = new ExportOptions();
            DiskFileDestinationOptions dfoption = new DiskFileDestinationOptions();
            PdfFormatOptions           pdf      = new PdfFormatOptions();
            SaveFileDialog             save     = new SaveFileDialog();

            save.Filter           = "ملف اكسيل | *.pdf";
            save.InitialDirectory = @"C:\";
            if (save.ShowDialog() == DialogResult.OK)
            {
                dfoption.DiskFileName = save.FileName;
                export = report.ExportOptions;
                export.ExportDestinationType    = ExportDestinationType.DiskFile;
                export.ExportFormatType         = ExportFormatType.PortableDocFormat;
                export.ExportFormatOptions      = pdf;
                export.ExportDestinationOptions = dfoption;
                report.Refresh();
                report.Export();
                MessageBox.Show("تمت العملية بنجاح", "معلومة", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
Beispiel #48
0
        protected override ResultStatus Export()
        {
            //讀取資料
            DataTable rep = dao50040.ListAll(txtStartDate.DateTimeValue, txtEndDate.DateTimeValue, ls_sort_type, li_val, ls_fcm_no, ls_kind_id2, dbName, "Y");

            if (rep.Rows.Count <= 0)
            {
                MessageDisplay.Info(string.Format("{0},{1},無任何資料!", txtStartDate.Text, this.Text), GlobalInfo.ResultText);
                return(ResultStatus.Fail);
            }

            //存CSV (ps:輸出csv 都用ascii)
            string etfFileName = "50040_" + DateTime.Now.ToString("yyyy.MM.dd-hh.mm.ss") + ".csv";

            etfFileName = Path.Combine(GlobalInfo.DEFAULT_REPORT_DIRECTORY_PATH, etfFileName);
            ExportOptions csvref = new ExportOptions();

            csvref.HasHeader = true;
            csvref.Encoding  = System.Text.Encoding.GetEncoding(950);//ASCII
            Common.Helper.ExportHelper.ToCsv(rep, etfFileName, csvref);

            return(ResultStatus.Success);
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            ClUtilitarios = new Cl_Utilitarios();
            DataSet Ds_Datos = new DataSet();

            Ds_Datos = ((DataSet)Session["Boleta"]);
            Reporte.PrintOptions.PaperOrientation = PaperOrientation.Portrait;
            Reporte.SetDataSource(Ds_Datos);
            string NomReporte = NomReporte = Guid.NewGuid().ToString() + ".pdf";
            string url        = Server.MapPath(".") + @"\" + DirRep + NomReporte;
            DiskFileDestinationOptions options2 = new DiskFileDestinationOptions
            {
                DiskFileName = url
            };
            ExportOptions exportOptions = Reporte.ExportOptions;

            exportOptions.ExportDestinationType    = ExportDestinationType.DiskFile;
            exportOptions.ExportFormatType         = ExportFormatType.PortableDocFormat;
            exportOptions.ExportDestinationOptions = options2;
            Reporte.Export();
            url = DirApp + DirRepLong + NomReporte;
            base.Response.Redirect(url);
        }
Beispiel #50
0
        private IEnumerable <IXmlWriter> GetWriters(ExportOptions options)
        {
            if ((options & ExportOptions.OnlyDefinedDetails) == ExportOptions.OnlyDefinedDetails)
            {
                yield return(new DefinedDetailXmlWriter(definitions));
            }
            else
            {
                yield return(new DetailXmlWriter());
            }
            yield return(new DetailCollectionXmlWriter());

            yield return(new ChildXmlWriter(options));

            yield return(new AuthorizationXmlWriter());

            yield return(new PersistablePropertyXmlWriter(definitions));

            if ((options & ExportOptions.ExcludeAttachments) == ExportOptions.Default)
            {
                yield return(new AttachmentXmlWriter(fs));
            }
        }
        private void exportToPdfAll_Click(object sender, EventArgs e)
        {
            RPT.rpt_all_categories myReport = new RPT.rpt_all_categories();

            //Create Export Options
            ExportOptions export = new ExportOptions();

            //Create Object For destination
            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();

            //Create Object For Excel Format
            PdfFormatOptions pdfformat = new PdfFormatOptions();

            //Set the path of destination
            dfoptions.DiskFileName = @"E:\CategoriesList.pdf";

            //Set Report Options to crystal export options
            export = myReport.ExportOptions;

            //Set Destination type
            export.ExportDestinationType = ExportDestinationType.DiskFile;

            //Set the type of document
            export.ExportFormatType = ExportFormatType.PortableDocFormat;

            //format the excel document
            export.ExportFormatOptions = pdfformat;

            //Set Destination option
            export.ExportDestinationOptions = dfoptions;

            myReport.Refresh();
            //Export the report
            myReport.Export();

            MessageBox.Show("List Exported Successfully !", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        private void ExportToPdfCurrent_Click(object sender, EventArgs e)
        {
            RPT.rpt_single_category myReport = new RPT.rpt_single_category();

            //Create Export Options
            ExportOptions export = new ExportOptions();

            //Create Object For destination
            DiskFileDestinationOptions dfoptions = new DiskFileDestinationOptions();

            //Create Object For Excel Format
            PdfFormatOptions pdfformat = new PdfFormatOptions();

            //Set the path of destination
            dfoptions.DiskFileName = @"E:\CategoryDetails.pdf";

            //Set Report Options to crystal export options
            export = myReport.ExportOptions;

            //Set Destination type
            export.ExportDestinationType = ExportDestinationType.DiskFile;

            //Set the type of document
            export.ExportFormatType = ExportFormatType.PortableDocFormat;

            //format the excel document
            export.ExportFormatOptions = pdfformat;

            //Set Destination option
            export.ExportDestinationOptions = dfoptions;

            myReport.SetParameterValue("@id", Convert.ToInt32(txtID.Text));
            //Export the report
            myReport.Export();

            MessageBox.Show("List Exported Successfully !", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        public void PrintReport(string key)
        {
            try
            {
                //----------------------------------------
                ReportDocument objRpt = new ReportDocument();
                DataSet ds = (DataSet)this.GetDataReport(key);

                string reportPath = "C:\\Reportes\\CRIngreso_etiqueta02.rpt";
                objRpt.Load(reportPath);

                DiskFileDestinationOptions crDiskFileDestinationOption = new DiskFileDestinationOptions();
                PdfRtfWordFormatOptions crFormatTypeOption = new PdfRtfWordFormatOptions();
                ExportOptions crExportOptions = new ExportOptions();

                objRpt.SetDataSource(ds.Tables[0]);
                string strfolder = "C:\\Reporte\\";
                crDiskFileDestinationOption.DiskFileName = strfolder + "Etiqueta.pdf";
                crExportOptions = objRpt.ExportOptions;
                crExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
                crExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;
                crExportOptions.ExportDestinationOptions = crDiskFileDestinationOption;
                crExportOptions.ExportFormatOptions = crFormatTypeOption;
                objRpt.Export();
                //---------------------------------------
                 ////string PrinterName = this.printDocument1.PrinterSettings.PrinterName;
                 //string NombreImpresora = "";

                 ////for (int i = 0; i < PrinterSettings.InstalledPrinters.Count; i++)
                 ////{
                 ////    PrinterSettings a = new PrinterSettings();
                 ////    a.PrinterName = PrinterSettings.InstalledPrinters[i].ToString();
                 ////    if (a.IsDefaultPrinter)
                 ////    {

                 ////        PrinterName = PrinterSettings.InstalledPrinters[i].ToString();
                 ////    }
                 ////}

                //this.printDialog1.Document = this.printDocument1;
                //DialogResult dr = this.printDialog1.ShowDialog();
                //if (dr == DialogResult.OK)
                //     {
                         PageMargins margins;
                         margins = objRpt.PrintOptions.PageMargins;
                         margins.bottomMargin = 250;
                         margins.leftMargin = 250;
                         margins.rightMargin = 250;
                         margins.topMargin = 250;
                         objRpt.PrintOptions.ApplyPageMargins(margins);
                     //string PrinterName = this.printDocument1.PrinterSettings.PrinterName;
                     //                    ////objRpt.PrintOptions.PrinterName = PrinterName;
                    objRpt.PrintOptions.PrinterName = GetImpresoraDefecto();
                         //objRpt.PrintOptions.PrinterName = PrinterName;
                         objRpt.PrintToPrinter(1, false, 0, 0);
                     //}

            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }
    protected void Page_Load(object sender, EventArgs e)
    {
        ReportDocument rpt = new ReportDocument();

        string type = null;

        try
        {
            type = Request.QueryString["type"].ToString();
        }
        catch
        {
        }

        try{
            if (type != null)
                switch (type.ToLower())
                {
                    case "narrativeplan":

                        rpt.Load(Server.MapPath("rpt_narrative.rpt"));
                        rpt.SetParameterValue("@key_local_plan_narrative_id", Convert.ToInt32(Request.QueryString["Keyid"].ToString()));
                        //rpt.SetParameterValue("@p_key_local_plan_id", "-1");
                        rpt.SetDatabaseLogon(WebConfigurationManager.AppSettings["CrystalUserName"].ToString(), WebConfigurationManager.AppSettings["CrystalUserPassWord"].ToString());
                        //rpt.SetDatabaseLogon("sa", "666ming");
                        break;

                    case "rpt_multi_narratives":

                        rpt.Load(Server.MapPath("rpt_multi_narratives.rpt"));
                        //rpt.SetParameterValue("@key_local_plan_narrative_id", Convert.ToInt32(Request.QueryString["rcid"].ToString()));
                        rpt.SetParameterValue("@p_key_local_plan_id", Convert.ToInt32(Request.QueryString["PlanId"].ToString()));
                        rpt.SetDatabaseLogon(WebConfigurationManager.AppSettings["CrystalUserName"].ToString(), WebConfigurationManager.AppSettings["CrystalUserPassWord"].ToString());
                     //   rpt.SetDatabaseLogon("sa", "666ming");
                        break;

                    default:
                        break;
                }

          ExportOptions exp = new ExportOptions();
            //exp.ExportFormatType = ExportFormatType.PortableDocFormat;
            //exp.FormatOptions = new PdfRtfWordFormatOptions();

            //      DiskFileDestinationOptions diskOpts = new DiskFileDestinationOptions();
            //diskOpts.DiskFileName = AppDomain.CurrentDomain.BaseDirectory.Trim() +  ".pdf";
            //exp.ExportDestinationOptions = diskOpts;
            //rpt.Export(exp);
            //CrystalReportViewer1.ReportSource = rpt;

            // Export to PDF

            exp.ExportFormatType = ExportFormatType.PortableDocFormat;
            exp.FormatOptions = new PdfRtfWordFormatOptions();
            ExportRequestContext req = new ExportRequestContext();
            req.ExportInfo = exp;

            System.IO.Stream st;
            //rpt.FormatEngine.PrintOptions.PaperSize = PaperSize.PaperA4;
            //rpt.FormatEngine.PrintOptions.PaperOrientation = PaperOrientation.Portrait;
            st = rpt.FormatEngine.ExportToStream(req);
            Response.ClearHeaders();
            Response.ClearContent();
            Response.Buffer = true;
            Response.ContentType = "application/pdf";

            byte[] b = new byte[st.Length + 1];
            st.Read(b, 0, Convert.ToInt32(st.Length));
            Response.BinaryWrite(b);
            Response.Flush();
            Response.End();

        }
        catch (Exception ex)
        {
            Response.Write(ex);
        }
    }
Beispiel #55
0
        private void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                FilePath = saveFileDialog1.FileName;

                ExportOptions eo = new ExportOptions();
                eo.ExportDestinationType = ExportDestinationType.DiskFile;
                string Extension = Path.GetExtension(FilePath);

                switch (Extension.ToUpper().Trim())
                {
                    case ".DOC":
                        eo.ExportFormatType = ExportFormatType.WordForWindows;
                        break;
                    case ".DOCX":
                        eo.ExportFormatType = ExportFormatType.WordForWindows;
                        break;
                    case ".XLS":
                        eo.ExportFormatType = ExportFormatType.Excel;
                        break;
                    case ".XLSX":
                        eo.ExportFormatType = ExportFormatType.Excel;
                        break;
                    case ".PDF":
                        eo.ExportFormatType = ExportFormatType.PortableDocFormat;
                        break;
                    default:
                        eo.ExportFormatType = ExportFormatType.WordForWindows;
                        break;
                }


                DiskFileDestinationOptions DestOption = new DiskFileDestinationOptions();
                DestOption.DiskFileName = FilePath;
                eo.ExportDestinationOptions = DestOption;


                ma_nv = oThongTinCNVC.txt_MaNV.Text;

                oCNVC.MaNV = oCNVC_CMND_HoChieu.MaNV = oCNVC_ThongTinPhu.MaNV =
                        oCNVC_ThongTinTuyenDung.MaNV = oCNVC_ChinhTri.MaNV = oCNVC_ChinhTriExt.Ma_NV =
                        oCNVC_ChuyenMonTongQuat.MaNV = oCNVC_DienBienSK.MaNV = oCNVC_DaoTaoBoiDuong.MaNV =
                        oCNVC_QTr_CongTac_OU.MaNV = oCNVC_LSBiBat.MaNV = oCNVC_QHGiaDinh.MaNV = oCNVC_QuanHeToChuc.MaNV = ma_nv;

                Init_Table_CNVC_QTr_CongTac_OU_ChinhTri_ChucVu();
                Prepare_ThongTinAll();

                DataTable dt_ThongTinTuyenDung = oCNVC_ThongTinTuyenDung.GetData();
                

                Reports.NV_BoNoiVu rpt = new Reports.NV_BoNoiVu();

                rpt.Database.Tables["ThongTinChinh"].SetDataSource(dt_ThongTinChinh);
                rpt.Database.Tables["CMND_HoChieu"].SetDataSource(dt_CMND);
                rpt.Database.Tables["ThongTinPhu"].SetDataSource(dt_ThongTinPhu);
                rpt.Database.Tables["ThongTinTuyenDung"].SetDataSource(dt_ThongTinTuyenDung);
                rpt.Database.Tables["ChucDanh_ChucVu"].SetDataSource(dt_ChucDanh_ChucVu);
                rpt.Database.Tables["ThongTinLuong"].SetDataSource(dt_ThongTinLuong);
                rpt.Database.Tables["ChuyenMonTongQuat"].SetDataSource(dt_ChuyenMonTongQuat);
                rpt.Database.Tables["ChinhTri"].SetDataSource(dt_ChinhTri);
                rpt.Database.Tables["ChinhTriExt"].SetDataSource(dt_ChinhTriExt);
                rpt.Database.Tables["ChinhTri_HCCB"].SetDataSource(dt_Chinh_Tri_HCCB);
                rpt.Database.Tables["SucKhoe"].SetDataSource(dt_SucKhoe);
                rpt.Database.Tables["DaoTaoBoiDuong"].SetDataSource(dt_DaoTaoBoiDuong);
                rpt.Database.Tables["QtrCtac_ChucVuChinhTri"].SetDataSource(dt_CNVC_QTr_CongTac_OU_ChinhTri_ChucVu);
                rpt.Database.Tables["QHGiaDinh"].SetDataSource(dt_CNVC_QHGiaDinh_nuoc_ngoai);
                rpt.Database.Tables["QuanHeToChuc"].SetDataSource(dt_CNVC_QuanHeToChuc);
                rpt.Database.Tables["tb_LSBiBat"].SetDataSource(dt_CNVC_LSBiBat);
                rpt.Database.Tables["QHGiaDinh_BanThan"].SetDataSource(dt_CNVC_QHGiaDinh_BanThan);
                rpt.Database.Tables["QHGiaDinh_VoHoacChong"].SetDataSource(dt_CNVC_QHGiaDinh_VoHoacChong);
                rpt.Database.Tables["DienBienLuong"].SetDataSource(dt_DienBienLuong);

                rpt.Export(eo);
                MessageBox.Show("Xuất báo cáo hoàn tất", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception)
            {
                MessageBox.Show("Xuất báo cáo không thành công, xin vui lòng thử lại sau", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                bw.ReportProgress(100);
            }
            
        }
        private void Import()
        {
            string strId = Request.QueryString["id"].ToString().Trim();
            rpDocDB.UpdatePrintFlag(strId);
            ReportDocument EoRpt = (ReportDocument)Session["REPORT"];

            ExportOptions crExportOptions = new ExportOptions();
            DiskFileDestinationOptions crDiskFileDestinationOptions = new DiskFileDestinationOptions();

            string strExportedFile = this.MapPath(".") + "\\ExportedReports\\ExceptionNotices";

            if (!System.IO.Directory.Exists(strExportedFile))
            {
                System.IO.Directory.CreateDirectory(strExportedFile);
            }

            strExportedFile += "\\" + strId + ".pdf";

            crDiskFileDestinationOptions.DiskFileName = strExportedFile;
            crExportOptions = EoRpt.ExportOptions;
            EoRpt.ExportOptions.DestinationOptions = crDiskFileDestinationOptions;
            EoRpt.ExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
            EoRpt.ExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;

            EoRpt.Export();
            EoRpt.Close();

            //读取报表导出的内容并传到客户端?继续加入以下代码
            Response.ClearContent();
            Response.ClearHeaders();
            Response.ContentType = "application/pdf";

            Response.WriteFile(strExportedFile);

            Response.Flush();
            Response.Close();
        }
Beispiel #57
0
 /// <summary>
 /// Provides the base for exporting the items of a <see cref="DataGrid"/> to an outside source.
 /// </summary>
 protected Exporter()
 {
     options = ExportOptions.Header;
 }
		private void GeneratePDF()
		{
			ReportDocument rpt = new ReportDocument();

			switch (cboReportType.SelectedItem.Text)
			{
                case "Posted PO":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedPO.rpt"));
                    break;
                case "Posted PO Returns":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedPOReturns.rpt"));
                    break;
                case "Posted Debit Memo":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedDebitMemo.rpt"));
                    break;
                case "By Vendor":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PurchaseAnalysis.rpt"));
                    break;
                default:
                    return;
					
			}

			ExportOptions exportop = new ExportOptions();
			DiskFileDestinationOptions dest = new DiskFileDestinationOptions();
			
			string strPath = Server.MapPath(@"\retailplus\temp\");

			string strFileName = cboReportType.SelectedItem.Text.Replace(" ", "").ToLower() + "_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".pdf";
			if (System.IO.File.Exists(strPath + strFileName))
				System.IO.File.Delete(strPath + strFileName);

			dest.DiskFileName = strPath + strFileName;

			exportop = rpt.ExportOptions;
	
			SetDataSource(rpt);

			exportop.DestinationOptions = dest;
			exportop.ExportDestinationType = ExportDestinationType.DiskFile;
			exportop.ExportFormatType = ExportFormatType.PortableDocFormat;
			rpt.Export();   rpt.Close();    rpt.Dispose();

			fraViewer.Attributes.Add("src",Constants.ROOT_DIRECTORY + "/temp/" + strFileName);
		}
		private void GenerateHTML()
		{
			ReportDocument rpt = new ReportDocument();

			switch (cboReportType.SelectedItem.Text)
			{
				case "Posted PO":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedPO.rpt"));
					break;
				case "Posted PO Returns":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedPOReturns.rpt"));
					break;
				case "Posted Debit Memo":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PostedDebitMemo.rpt"));
					break;
				case "By Vendor":
                    rpt.Load(Server.MapPath(Constants.ROOT_DIRECTORY + "/Reports/PurchaseAnalysis.rpt"));
					break;
				default:
					return;
					
			}

			HTMLFormatOptions htmlOpts = new HTMLFormatOptions();
 
			ExportOptions exportop = new ExportOptions();
			DiskFileDestinationOptions dest = new DiskFileDestinationOptions();
			
			string strPath = Server.MapPath(@"\retailplus\temp\html\");

			string strFileName = cboReportType.SelectedItem.Text.Replace(" ", "").ToLower() + "_" + Session["UserName"].ToString() + "_" + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".htm";
			if (System.IO.File.Exists(strPath + strFileName))
				System.IO.File.Delete(strPath + strFileName);

			htmlOpts.HTMLFileName = strFileName;
			htmlOpts.HTMLEnableSeparatedPages = true;;
			htmlOpts.HTMLHasPageNavigator = true;
			htmlOpts.HTMLBaseFolderName = strPath;
			rpt.ExportOptions.FormatOptions = htmlOpts;

			exportop = rpt.ExportOptions;

			exportop.ExportDestinationType = ExportDestinationType.DiskFile;
			exportop.ExportFormatType = ExportFormatType.HTML40;
			
			dest.DiskFileName = strFileName.ToString();
			exportop.DestinationOptions = dest;

			SetDataSource(rpt);

            Session["ReportDocument"] = rpt;

			rpt.Export();   rpt.Close();    rpt.Dispose();

			strFileName = "//" + Request.ServerVariables["SERVER_NAME"].ToString() + FindHTMLFile(strPath,strFileName);	
			
			fraViewer.Attributes.Add("src",strFileName);
		}
        public void VistaPrevia(string key)
        {
            try
            {
                ReportDocument objRpt = new ReportDocument();
                DataSet ds = (DataSet)this.GetDataReport(key);

                //string reportPath = Application.StartupPath + "\\Reporte\\co_ordenCompra_rpt.rpt";

                string reportPath = "C:\\Reportes\\CRTejTicket_rpt.rpt";
                objRpt.Load(reportPath);

                DiskFileDestinationOptions crDiskFileDestinationOption = new DiskFileDestinationOptions();
                PdfRtfWordFormatOptions crFormatTypeOption = new PdfRtfWordFormatOptions();
                ExportOptions crExportOptions = new ExportOptions();

                objRpt.SetDataSource(ds.Tables[0]);

                string strfolder = "C:\\Reporte\\";
                crDiskFileDestinationOption.DiskFileName = strfolder +  "Etiqueta.pdf";

                crExportOptions = objRpt.ExportOptions;
                crExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
                crExportOptions.ExportFormatType = ExportFormatType.PortableDocFormat;

                crExportOptions.ExportDestinationOptions = crDiskFileDestinationOption;
                crExportOptions.ExportFormatOptions = crFormatTypeOption;
                crystalReportViewer1.ReportSource = objRpt;

                    //PageMargins margins;

                    //margins = objRpt.PrintOptions.PageMargins;
                    //margins.bottomMargin = 250;
                    //margins.leftMargin = 250;
                    //margins.rightMargin = 250;
                    //margins.topMargin = 250;
                    //objRpt.PrintOptions.ApplyPageMargins(margins);

                //objRpt.Export();

            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }