コード例 #1
0
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                if (value == null)
                {
                    return(null);
                }

                var ТипЗначения = value.GetType();
                if (ТипЗначения == typeof(byte))
                {
                    var ЗнаяениеКак_byte = (byte)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_byte));
                }

                if (ТипЗначения == typeof(byte?))
                {
                    var ЗнаяениеКак_byte = (byte?)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_byte.Value));
                }

                if (ТипЗначения == typeof(sbyte))
                {
                    var ЗнаяениеКак_sbyte = (sbyte)value;

                    if (ЗнаяениеКак_sbyte >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_sbyte));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(sbyte?))
                {
                    var ЗнаяениеКак_sbyte = (sbyte?)value;

                    if (ЗнаяениеКак_sbyte >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_sbyte.Value));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(short))
                {
                    var ЗнаяениеКак_short = (short)value;
                    if (ЗнаяениеКак_short >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_short));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(short?))
                {
                    var ЗнаяениеКак_short = (short?)value;
                    if (ЗнаяениеКак_short >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_short.Value));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(ushort))
                {
                    var ЗнаяениеКак_ushort = (ushort)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_ushort));
                }

                if (ТипЗначения == typeof(ushort?))
                {
                    var ЗнаяениеКак_ushort = (ushort?)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_ushort.Value));
                }

                if (ТипЗначения == typeof(int))
                {
                    var ЗнаяениеКак_int = (int)value;
                    if (ЗнаяениеКак_int >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_int));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(int?))
                {
                    var ЗнаяениеКак_int = (int?)value;
                    if (ЗнаяениеКак_int >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_int.Value));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(uint))
                {
                    var ЗнаяениеКак_uint = (uint)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_uint));
                }

                if (ТипЗначения == typeof(uint?))
                {
                    var ЗнаяениеКак_uint = (uint?)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_uint.Value));
                }

                if (ТипЗначения == typeof(long))
                {
                    var ЗнаяениеКак_long = (long)value;
                    if (ЗнаяениеКак_long >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_long));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(long?))
                {
                    var ЗнаяениеКак_long = (long?)value;
                    if (ЗнаяениеКак_long >= 0)
                    {
                        return(Файл.азмерКакСтрока(ЗнаяениеКак_long.Value));
                    }
                    return(null);
                }

                if (ТипЗначения == typeof(ulong))
                {
                    var ЗнаяениеКак_ulong = (ulong)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_ulong));
                }

                if (ТипЗначения == typeof(ulong?))
                {
                    var ЗнаяениеКак_ulong = (ulong?)value;
                    return(Файл.азмерКакСтрока(ЗнаяениеКак_ulong.Value));
                }
            }

            return(base.ConvertTo(context, culture, value, destinationType));
        }
        public async Task <MemoryStream> GetXMLDocument(int companyId, int sigantoryId, int correction)
        {
            var factShares = await shareService.GetFactByProjectCompanyId(companyId, DateTime.Now);

            var company = await projectCompanyService.GetById(companyId);

            var signature = await signatureService.GetById(sigantoryId);

            //Файл
            Файл file = new Файл();

            //Аттрибуты Файла
            file.ВерсПрог = "123";
            file.ИдФайл   = "321";
            file.ВерсФорм = ФайлВерсФорм.Item501;

            //Документ
            ФайлДокумент fileDocument = new ФайлДокумент();

            //Аттрибуты документа
            fileDocument.ДатаДок = DateTime.Today.ToString();
            fileDocument.КодНО   = "Код налогового органа";
            fileDocument.НомКорр = correction.ToString();
            fileDocument.КНД     = ФайлДокументКНД.Item1120411;


            //Подписант
            ФайлДокументПодписант fileDocumentSigantory = new ФайлДокументПодписант();

            //Аттрибуты подписанта
            fileDocumentSigantory.Email = signature.Email;
            fileDocumentSigantory.ИННФЛ = signature.Inn;
            fileDocumentSigantory.Тлф   = signature.PhoneNumber;
            //Признак лица, подписавшего документ - ??
            fileDocumentSigantory.ПрПодп = ФайлДокументПодписантПрПодп.Item1;


            //ФИО
            ФИОТип fioType = new ФИОТип();

            fioType.Имя      = signature.FirstName;
            fioType.Отчество = signature.MiddleName;
            fioType.Фамилия  = signature.LastName;

            //Сведения о представителе налогоплательщика
            ФайлДокументПодписантСвПред fileDocumentRepresentative = new ФайлДокументПодписантСвПред();

            fileDocumentRepresentative.НаимДок = signature.ConfirmationDocument?.Name;


            fileDocumentSigantory.ФИО    = fioType;
            fileDocumentSigantory.СвПред = fileDocumentRepresentative;
            //Подписант


            //Сведения о заявителе
            ФайлДокументСвНП fileDocumentApplicant = new ФайлДокументСвНП();

            //Налогоплательщик (код) - ??
            fileDocumentApplicant.ПрНП = ФайлДокументСвНППрНП.Item1;

            //Заявитель - физическое лицо
            if (company.State == State.Individual)
            {
                ФайлДокументСвНПНПФЛ fl = new ФайлДокументСвНПНПФЛ();
                fl.ИННФЛ = company.IndividualCompany?.INN.ToString();

                //Фио физ лица
                ФИОТип fioFl = new ФИОТип();
                fioFl.Имя      = company.IndividualCompany?.Name;
                fioFl.Отчество = company.IndividualCompany?.MiddleName;
                fioFl.Фамилия  = company.IndividualCompany?.Surname;

                //Сведения о физическом лице
                ФайлДокументСвНПНПФЛСведФЛ svedFl = new ФайлДокументСвНПНПФЛСведФЛ();

                //Аттрибуты Сведения о физическом лице
                svedFl.ДатаРожд  = company.IndividualCompany?.BirthDate.ToString("dd.MM.yyyy");
                svedFl.МестоРожд = company.IndividualCompany?.BirthPlace;
                if (company.IndividualCompany.GenderCode != null)
                {
                    svedFl.Пол = (ФайлДокументСвНПНПФЛСведФЛПол)Enum.Parse(typeof(ФайлДокументСвНПНПФЛСведФЛПол), company.IndividualCompany?.GenderCode?.Code);
                }
                if (company.IndividualCompany.CitizenshipCode != null)
                {
                    svedFl.ПрГражд = (ФайлДокументСвНПНПФЛСведФЛПрГражд)Enum.Parse(typeof(ФайлДокументСвНПНПФЛСведФЛПрГражд), company.IndividualCompany?.CitizenshipCode?.Code);
                }
                svedFl.ОКСМ = company.IndividualCompany?.ForeignCountryCode?.Code;


                //Сведения о документе, удостоверяющем личность
                УдЛичнФЛТип flDoc = new УдЛичнФЛТип();
                flDoc.ДатаДок   = company.IndividualCompany?.ConfirmedPersonalityDocInfo?.IssueDate.ToString("dd.MM.yyyy");
                flDoc.ВыдДок    = company.IndividualCompany?.ConfirmedPersonalityDocInfo?.IssuePlace;
                flDoc.КодВидДок = company.IndividualCompany?.ConfirmedPersonalityDocInfo?.DocumentCode?.Code;
                flDoc.СерНомДок = company.IndividualCompany?.ConfirmedPersonalityDocInfo?.SeriesAndNumber;


                svedFl.УдЛичн = flDoc;

                fl.СведФЛ = svedFl;
                fl.ФИО    = fioFl;

                fileDocumentApplicant.Item = fl;
            }
            else
            {
            }



            fileDocument.СвНП      = fileDocumentApplicant;
            fileDocument.Подписант = fileDocumentSigantory;
            file.Документ          = fileDocument;

            var serializer = new XmlSerializer(typeof(Файл));



            MemoryStream memStream = new MemoryStream();

            serializer.Serialize(memStream, file);
            memStream.Position = 0;

            return(memStream);
        }
コード例 #3
0
        public Файл ВыводОтчета(string НазваниеОтчета, string ИсходныйКод, string ИсходныйФорматОтчета, ФорматОтчета ФорматОтчета, ШаблонОтчета.Ориентация Ориентация, DataSet ds, Хранилище Хранилище, string user, string domain)
        {
            var file = null as Файл;

            try
            {
                if (ds == null)
                {
                    new Exception("Не определен DataSet");
                }

                var extension = string.Empty;
                var mime      = MimeType.НеОпределен;
                switch (ИсходныйФорматОтчета)
                {
                case "Xps":
                    extension = "xps";
                    mime      = MimeType.Xps;
                    break;

                case "Excel":
                    extension = "xls";
                    mime      = MimeType.Excel;
                    break;

                case "Word":
                    extension = "doc";
                    mime      = MimeType.Word;
                    break;

                case "Text Plain":
                    extension = "txt";
                    mime      = MimeType.Text;
                    break;

                case "Excel-PDF":
                case "Word-PDF":
                    extension = "pdf";
                    break;

                default:
                    throw new Exception("Не верно указан 'Исходный формат отчета'");
                }
                file = new Файл()
                {
                    Name = string.Format("{0}_{1:yyyymmdd_HHmmss}.{2}", FileNameValid(НазваниеОтчета), DateTime.Now, extension), MimeType = mime
                };
                var task = new System.Threading.Tasks.Task(() =>
                {
                    try
                    {
                        using (var msXml = new MemoryStream())
                        {
                            var processor   = new Saxon.Api.Processor();
                            var compiler    = processor.NewXsltCompiler();
                            var transformer = compiler.Compile(new StringReader(ИсходныйКод)).Load();
                            var dest        = new Saxon.Api.TextWriterDestination(XmlTextWriter.Create(msXml));

                            transformer.InitialContextNode = processor.NewDocumentBuilder().Build(new XmlDataDocument(ds));
                            transformer.Run(dest);

                            switch (ИсходныйФорматОтчета)
                            {
                            case "Xps":
                                {
                                    file.MimeType = MimeType.Xps;
                                    switch (ФорматОтчета)
                                    {
                                        #region Отчет Xaml (по-умолчанию)
                                    case ФорматОтчета.Xaml:
                                    case ФорматОтчета.ПоУмолчанию:
                                        {
                                            file.Stream = msXml.ToArray();
                                        }
                                        break;
                                        #endregion

                                        #region Отчет Xps
                                    case ФорматОтчета.Xps:
                                    default:
                                        {
                                            var documentUri = Path.GetTempFileName();
                                            try
                                            {
                                                msXml.Position = 0;
                                                var sourceDoc  = XamlReader.Load(msXml) as IDocumentPaginatorSource;

                                                var doc = new XpsDocument(documentUri, FileAccess.Write, CompressionOption.Normal);
                                                var xsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
                                                var pgn = sourceDoc.DocumentPaginator;
                                                // 1cm = 38px
                                                switch (Ориентация)
                                                {
                                                case ШаблонОтчета.Ориентация.Альбом:
                                                    {
                                                        pgn.PageSize = new System.Windows.Size(29.7 * (96 / 2.54), 21 * (96 / 2.54));
                                                    }
                                                    break;

                                                case ШаблонОтчета.Ориентация.Книга:
                                                default:
                                                    {
                                                        pgn.PageSize = new System.Windows.Size(21 * (96 / 2.54), 29.7 * (96 / 2.54));
                                                    }
                                                    break;
                                                }
                                                //необходимо фиксированно указать размер колонки документа иначе при
                                                //построении часть данных будет срезано
                                                if (sourceDoc is FlowDocument)
                                                {
                                                    ((FlowDocument)sourceDoc).ColumnWidth = pgn.PageSize.Width;
                                                }
                                                xsm.SaveAsXaml(pgn);

                                                doc.Close();
                                                file.Stream = System.IO.File.ReadAllBytes(documentUri);
                                            }
                                            finally
                                            {
                                                if (System.IO.File.Exists(documentUri))
                                                {
                                                    System.IO.File.Delete(documentUri);
                                                }
                                            }
                                        }
                                        break;
                                        #endregion
                                    }
                                }
                                break;

                            case "TextPlain":
                                {
                                    file.MimeType = MimeType.Text;
                                    file.Stream   = msXml.ToArray();
                                }
                                break;

                            case "Word-PDF":
                                {
                                    #region generate
                                    object paramSourceDocPath = Path.GetTempFileName();
                                    object paramMissing       = System.Type.Missing;

                                    System.IO.File.WriteAllBytes((string)paramSourceDocPath, msXml.ToArray());
                                    if (!System.IO.File.Exists((string)paramSourceDocPath))
                                    {
                                        throw new Exception(string.Format("Исходный файл для генерации отчета не найден '{0}'", paramSourceDocPath));
                                    }

                                    var wordApplication     = null as Microsoft.Office.Interop.Word.Application;
                                    var wordDocument        = null as Document;
                                    var paramExportFilePath = GetTempFilePathWithExtension(".pdf");
                                    try
                                    {
                                        wordApplication = new Microsoft.Office.Interop.Word.Application()
                                        {
                                            DisplayAlerts = WdAlertLevel.wdAlertsNone
                                        };

                                        var paramExportFormat       = WdExportFormat.wdExportFormatPDF;
                                        var paramOpenAfterExport    = false;
                                        var paramExportOptimizeFor  = WdExportOptimizeFor.wdExportOptimizeForPrint;
                                        var paramExportRange        = WdExportRange.wdExportAllDocument;
                                        var paramStartPage          = 0;
                                        var paramEndPage            = 0;
                                        var paramExportItem         = WdExportItem.wdExportDocumentContent;
                                        var paramIncludeDocProps    = true;
                                        var paramKeepIRM            = true;
                                        var paramCreateBookmarks    = WdExportCreateBookmarks.wdExportCreateWordBookmarks;
                                        var paramDocStructureTags   = true;
                                        var paramBitmapMissingFonts = true;
                                        var paramUseISO19005_1      = false;

                                        // Open the source document.
                                        wordDocument = wordApplication.Documents.Open(
                                            ref paramSourceDocPath, ref paramMissing, ref paramMissing,
                                            ref paramMissing, ref paramMissing, ref paramMissing,
                                            ref paramMissing, ref paramMissing, ref paramMissing,
                                            ref paramMissing, ref paramMissing, ref paramMissing,
                                            ref paramMissing, ref paramMissing, ref paramMissing,
                                            ref paramMissing);

                                        // Export it in the specified format.
                                        if (wordDocument != null)
                                        {
                                            wordDocument.ExportAsFixedFormat(paramExportFilePath,
                                                                             paramExportFormat, paramOpenAfterExport,
                                                                             paramExportOptimizeFor, paramExportRange, paramStartPage,
                                                                             paramEndPage, paramExportItem, paramIncludeDocProps,
                                                                             paramKeepIRM, paramCreateBookmarks, paramDocStructureTags,
                                                                             paramBitmapMissingFonts, paramUseISO19005_1,
                                                                             ref paramMissing);
                                        }

                                        if (!System.IO.File.Exists(paramExportFilePath))
                                        {
                                            throw new Exception(string.Format("Word-PDF: Файл отчета не найден '{0}'", paramExportFilePath));
                                        }

                                        if (Enum.IsDefined(typeof(MimeType), ИсходныйФорматОтчета))
                                        {
                                            file.MimeType = (MimeType)Enum.Parse(typeof(MimeType), ИсходныйФорматОтчета);
                                        }

                                        file.Stream = System.IO.File.ReadAllBytes(paramExportFilePath);
                                    }
                                    finally
                                    {
                                        // Close and release the Document object.
                                        if (wordDocument != null)
                                        {
                                            wordDocument.Close(false, ref paramMissing, ref paramMissing);
                                            wordDocument = null;
                                        }

                                        // Quit Word and release the ApplicationClass object.
                                        if (wordApplication != null)
                                        {
                                            wordApplication.Quit(false, ref paramMissing, ref paramMissing);
                                            wordApplication = null;

                                            GC.Collect();
                                            GC.WaitForPendingFinalizers();
                                            GC.Collect();
                                        }

                                        if (System.IO.File.Exists((string)paramSourceDocPath))
                                        {
                                            System.IO.File.Delete((string)paramSourceDocPath);
                                        }
                                        if (System.IO.File.Exists(paramExportFilePath))
                                        {
                                            System.IO.File.Delete(paramExportFilePath);
                                        }

                                        //var sb = new StringBuilder();
                                        //sb.AppendLine((string)paramSourceDocPath);
                                        //sb.AppendLine(paramExportFilePath);
                                        //ConfigurationClient.WindowsLog(sb.ToString(), "", domain);
                                    }
                                    #endregion
                                }
                                break;

                            case "Excel-PDF":
                                {
                                    #region generate
                                    object paramSourceDocPath = Path.GetTempFileName();
                                    object paramMissing       = System.Type.Missing;

                                    System.IO.File.WriteAllBytes((string)paramSourceDocPath, msXml.ToArray());
                                    if (!System.IO.File.Exists((string)paramSourceDocPath))
                                    {
                                        throw new Exception(string.Format("Исходный файл для генерации отчета не найден '{0}'", paramSourceDocPath));
                                    }

                                    var excelApplication = new Microsoft.Office.Interop.Excel.Application()
                                    {
                                        DisplayAlerts = false
                                    };
                                    var excelDocument = null as Workbook;

                                    var paramExportFilePath   = GetTempFilePathWithExtension(".pdf");
                                    var paramExportFormat     = XlFixedFormatType.xlTypePDF;
                                    var paramExportQuality    = XlFixedFormatQuality.xlQualityStandard;
                                    var paramOpenAfterPublish = false;
                                    var paramIncludeDocProps  = true;
                                    var paramIgnorePrintAreas = true;
                                    var paramFromPage         = System.Type.Missing;
                                    var paramToPage           = System.Type.Missing;

                                    try
                                    {
                                        // Open the source document.
                                        excelDocument = excelApplication.Workbooks.Open(
                                            (string)paramSourceDocPath, paramMissing, paramMissing,
                                            paramMissing, paramMissing, paramMissing,
                                            paramMissing, paramMissing, paramMissing,
                                            paramMissing, paramMissing, paramMissing,
                                            paramMissing, paramMissing, paramMissing);

                                        // Export it in the specified format.
                                        if (excelDocument != null)
                                        {
                                            excelDocument.ExportAsFixedFormat(paramExportFormat,
                                                                              paramExportFilePath, paramExportQuality,
                                                                              paramIncludeDocProps, paramIgnorePrintAreas, paramFromPage,
                                                                              paramToPage, paramOpenAfterPublish,
                                                                              paramMissing);
                                        }

                                        if (!System.IO.File.Exists(paramExportFilePath))
                                        {
                                            throw new Exception(string.Format("Файл отчета не найден '{0}'", paramExportFilePath));
                                        }

                                        if (Enum.IsDefined(typeof(MimeType), ИсходныйФорматОтчета))
                                        {
                                            file.MimeType = (MimeType)Enum.Parse(typeof(MimeType), ИсходныйФорматОтчета);
                                        }

                                        file.Stream = System.IO.File.ReadAllBytes(paramExportFilePath);
                                    }
                                    finally
                                    {
                                        // Close and release the Document object.
                                        if (excelDocument != null)
                                        {
                                            excelDocument.Close(false, paramMissing, paramMissing);
                                            excelDocument = null;
                                        }

                                        // Quit Word and release the ApplicationClass object.
                                        if (excelApplication != null)
                                        {
                                            excelApplication.Quit();
                                            excelApplication = null;
                                        }

                                        if (System.IO.File.Exists((string)paramSourceDocPath))
                                        {
                                            System.IO.File.Delete((string)paramSourceDocPath);
                                        }
                                        if (System.IO.File.Exists(paramExportFilePath))
                                        {
                                            System.IO.File.Delete(paramExportFilePath);
                                        }

                                        GC.Collect();
                                        GC.WaitForPendingFinalizers();
                                        GC.Collect();
                                        GC.WaitForPendingFinalizers();
                                    }
                                    #endregion
                                }
                                break;

                            default:
                                {
                                    if (Enum.IsDefined(typeof(MimeType), ИсходныйФорматОтчета))
                                    {
                                        file.MimeType = (MimeType)Enum.Parse(typeof(MimeType), ИсходныйФорматОтчета);
                                    }

                                    file.Stream = msXml.ToArray();
                                }
                                break;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        ConfigurationClient.WindowsLog(ex.ToString(), user, domain, "ВыводОтчета");
                    }
                });
                task.Start();
                task.Wait();
            }
            catch (Exception ex)
            {
                ConfigurationClient.WindowsLog(ex.ToString(), user, domain, "ВыводОтчета");
            }
            return(file);
        }