Разработка компонента чтения данных карточки

public abstract class BaseDataReaders : IDocumentDataReader
{

    public void Initialize(ObjectContext objectContext) (1)
    {
        ObjectContext = objectContext;

        UserSession = ObjectContext.GetService<UserSession>();

        documentService = ObjectContext.GetService<IDocumentService>();
    }

    public string GetDigest(Guid cardId) (2)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        return document.Description;
    }

    public string GetFileDigest(Guid cardId, Guid fileId) (3)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        DocumentFile documentFile = document.Files.FirstOrDefault(item => item.FileVersionRowId == fileId);
        if (documentFile == null)
        {
            throw Error.InvalidOperation(Resources.FileNotExists, fileId, cardId);
        }

        return GetUniversalDocumentDescription(documentFile.FileVersionRowId, MessageFileType.File) ?? documentFile.FileName;
    }

    public string GetFileContent(Guid cardId, Guid fileId) (4)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        DocumentFile documentFile = document.Files.FirstOrDefault(item => item.FileVersionRowId == fileId);
        if (documentFile == null)
        {
            throw Error.InvalidOperation(Resources.FileNotExists, fileId, cardId);
        }

        if (!UserSession.FileManager.FileExists(documentFile.FileVersionRowId))
        {
            return null;
        }

        FileData fileData = UserSession.FileManager.GetFile(documentFile.FileVersionRowId);
        using (Stream stream = fileData.OpenReadStream())
        {
            using (TextReader textReader = new StreamReader(stream))
            {
                return textReader.ReadToEnd();
            }
        }
    }

    public string GetPrintFormContent(Guid cardId) (5)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        return GetUniversalDocumentPrintContent(document);
    }

    public string GetReplyFileDigest(Guid cardId, Guid fileId, MessageFileType fileType) (6)
    {
        return GetUniversalDocumentDescription(fileId, fileType);
    }

    public string GetReplyFileComment(Guid cardId, Guid fileId, MessageFileType fileType)
    {
        if (!UserSession.FileManager.FileExists(fileId))
        {
            return null;
        }

        try
        {
            FileData fileData = UserSession.FileManager.GetFile(fileId);
            using (Stream stream = fileData.OpenReadStream())
            {
                switch (fileType)
                {
                    case MessageFileType.InvoiceCorrectionRequest:
                    case MessageFileType.SignatureRejection:
                        return InvoiceCorrectionNotice.GetComment(stream);
                }
            }
        }
        catch
        {
        }

        return null;
    }

    public ItemCollection<DocumentRecipientData> GetAllRecipients(Guid cardId) (7)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        ItemCollection<DocumentRecipientData> recipients = new ItemCollection<DocumentRecipientData>();

        var contractSection = document.GetSection(CardDocument.Contract.ID);
        if (contractSection.Count == 0)
        {
            return recipients;
        }

        BaseCardSectionRow contractRow = (BaseCardSectionRow)contractSection[0];
        Guid companyId = contractRow.GetGuid(CardDocument.Contract.PartnerCompany);
        if (companyId == Guid.Empty)
        {
            return recipients;
        }

        PartnersCompany company = ObjectContext.GetObject<PartnersCompany>(companyId);
        if (company != null)
        {
            recipients.Add(new DocumentRecipientData(ObjectContext.GetObjectRef(company).Id, company.Name));
        }

        return recipients;
    }

    public ItemCollection<DocumentSignature> GetActualSignatures(Guid cardId) (8)
    {
        return null;
    }

    public ItemCollection<DocumentFileData> GetAllFiles(Guid cardId) (9)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        return new ItemCollection<DocumentFileData>(document.Files.Where(CheckFile)
            .Select(item => new DocumentFileData(item.FileVersionRowId, item.FileName, item.FileType == DocumentFileType.Main)));
    }

    public ItemCollection<DocumentFileData> GetLastSignedFiles(Guid cardId) (10)
    {
        return GetSignedFiles(cardId, Guid.Empty);
    }

    public ItemCollection<DocumentFileData> GetSignedFiles(Guid cardId, Guid signatureGroupId) (11)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        if (document.MainInfo.SignatureList == null || !document.MainInfo.SignatureList.Signatures.Any())
        {
            return null;
        }

        BaseCardSignature lastSignature = signatureGroupId != Guid.Empty
            ? document.MainInfo.SignatureList.Signatures.FirstOrDefault(item => ObjectContext.GetObjectRef(item).Id == signatureGroupId)
            : document.MainInfo.SignatureList.Signatures.OrderByDescending(item => item.TimeStamp).FirstOrDefault();

        if (lastSignature == null)
        {
            return null;
        }

        ItemCollection<DocumentFileData> result = new ItemCollection<DocumentFileData>();

        foreach (DocumentFile documentFile in document.Files.Where(CheckFile))
        {
            if (UserSession.CardManager.GetCardState(documentFile.FileId) != ObjectState.Existing)
            {
                continue;
            }

            VersionedFileCard verFileCard = (VersionedFileCard)UserSession.CardManager.GetCard(documentFile.FileId);

            BaseCardSignaturePart filePart = lastSignature.Parts (12)
                .FirstOrDefault(item => item.FileVersion == verFileCard.CurrentVersion.VersionId &&
                                                ((documentFile.FileType == DocumentFileType.Main &&
                                                    documentService.IsDocumentSignaturePartMainFile(item)) ||
                                                    (documentFile.FileType == DocumentFileType.Additional &&
                                                    documentService.IsDocumentSignaturePartAttachments(item))));
            if (filePart == null)
            {
                continue;
            }

            result.Add(new DocumentFileData(documentFile.FileVersionRowId, documentFile.FileName,
                documentFile.FileType == DocumentFileType.Main, filePart.Signature));
        }

        return result;
    }

    public MessageData PrepareMessageData(Guid cardId, string documentType, string documentVersion) (13)
    {
        Document document = GetDocument(cardId);

        if (document.MainInfo.SignatureList == null || !document.MainInfo.SignatureList.Signatures.Any())
        {
            throw Error.InvalidOperation(Resources.DocumentSignaturesNotExists, cardId);
        }

        MessageData messageData = new MessageData(cardId, documentType, documentVersion, document.MainInfo.Name);

        DateTime? regDate = document.MainInfo[CardDocument.MainInfo.RegDate] as DateTime?;
        messageData.DocumentDate = regDate ?? document.CreateDate;
        messageData.DocumentComment = document.MainInfo[CardDocument.MainInfo.Content] as string;

        Guid numberId = document.MainInfo.GetGuid(CardDocument.MainInfo.RegNumber);
        if (numberId != Guid.Empty)
        {
            BaseCardNumber number = document.Numbers.FirstOrDefault(item => ObjectContext.GetObjectRef(item).Id == numberId);
            if (number != null)
            {
                messageData.DocumentNumber = number.Number;
            }
        }

        return messageData;
    }

    public MessageFile PrepareFileData(Guid cardId, Guid fileId, Guid signatureId, bool isMain, string tempFolder) (14)
    {
        return null;
    }

    // Реализация метода проверки подписи
    public SignatureValidation ValidateSignature(Guid cardId, Guid fileId, Guid signatureId) (15)
    {
        if (cardId == Guid.Empty)
        {
            throw Error.ArgumentNull("cardId");
        }

        if (fileId == Guid.Empty)
        {
            throw Error.ArgumentNull("fileId");
        }

        if (signatureId == Guid.Empty)
        {
            throw Error.ArgumentNull("signatureId");
        }

        if (!UserSession.FileManager.FileExists(fileId))
        {
            return null;
        }

        byte[] signatureData = null;
        try
        {
            signatureData = UserSession.AccessManager.GetCryptObject(signatureId);
        }
        catch
        {
        }
        if (signatureData == null)
        {
            return null;
        }

        string signerName = null;
        X509Certificate2 certificate = null;
        bool isValid = false;
        bool isCertificateValid = false;
        string validationError = null;

        try
        {
            FileData fileData = UserSession.FileManager.GetFile(fileId);
            using (Stream stream = fileData.OpenReadStream())
            {
                using (BinaryReader reader = new BinaryReader(stream))
                {
                    ContentInfo contentInfo = new ContentInfo(reader.ReadBytes((int)reader.BaseStream.Length));
                    SignedCms signedCms = new SignedCms(contentInfo, true);
                    signedCms.Decode(signatureData);

                    if (signedCms.SignerInfos.Count == 0 || signedCms.Certificates.Count == 0)
                    {
                        return null;
                    }

                    certificate = signedCms.Certificates[0];
                    signerName = CertificateHelper.GetCertificateSignerName(certificate);

                    signedCms.CheckSignature(false);
                    isValid = true;

                    signedCms.CheckSignature(new X509Certificate2Collection(certificate), true);
                    isCertificateValid = true;
                }
            }
        }
        catch (Exception ex)
        {
            validationError = ex.Message;
        }

        return new SignatureValidation(isValid, isCertificateValid, certificate, signerName, validationError);
    }

    public string GetInvoiceReplyData(Guid cardId) (16)
    {
        Document document = GetDocument(cardId);
        if (document == null)
        {
            throw Error.InvalidOperation(Resources.DocumentNotExists, cardId);
        }

        return GetInvoiceReplyData(document);
    }

    protected virtual bool CheckFile(DocumentFile documentFile) (17)
    {
        return false;
    }

    protected virtual string GetUniversalDocumentDescription(Guid fileId, MessageFileType fileType) (18)
    {
        return null;
    }

    protected virtual string GetUniversalDocumentPrintContent(Document document) (19)
    {
        return null;
    }

    protected virtual string GetInvoiceReplyData(Document document) (20)
    {
        return null;
    }
}