public async Task <byte[]> RemoverAssinaturasDigitais(InputFile inputFile)
        {
            inputFile.IsValid();

            byte[] arquivoSemAssinatura;
            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                arquivoSemAssinatura = await RemoverAssinaturasDigitais(inputFile.FileUrl);
            }
            else
            {
                arquivoSemAssinatura = RemoverAssinaturasDigitais(inputFile.FileBytes);
            }

            return(arquivoSemAssinatura);
        }
        //public void SignatureValidationV2(byte[] arquivoBytes)
        //{
        //    using PdfReader pdfReader = new PdfReader(new MemoryStream(arquivoBytes));
        //    using PdfDocument pdfDocument = new PdfDocument(pdfReader);
        //    SignatureUtil signatureUtil = new SignatureUtil(pdfDocument);
        //    foreach (var signatureName in signatureUtil.GetSignatureNames())
        //    {
        //        var aaaa = signatureUtil.SignatureCoversWholeDocument(signatureName);
        //        PdfPKCS7 signatureData = signatureUtil.ReadSignatureData(signatureName);
        //        var bbbb = signatureData.VerifySignatureIntegrityAndAuthenticity();
        //    }
        //}

        #endregion

        public async Task <byte[]> AdicionarAssinaturaDigital(InputFile inputFile, string signatureFieldName)
        {
            inputFile.IsValid();

            byte[] dococumentoAssinado;
            if (inputFile.FileUrl != null)
            {
                dococumentoAssinado = await AdicionarAssinaturaDigital(inputFile.FileUrl, signatureFieldName);
            }
            else
            {
                dococumentoAssinado = AdicionarAssinaturaDigital(inputFile.FileBytes, signatureFieldName);
            }

            return(dococumentoAssinado);
        }
        public async Task <byte[]> SubstituirExpressaoRegularPorTexto(InputFile inputFile, IEnumerable <string> expressoesRegulares, string texto)
        {
            inputFile.IsValid();

            byte[] response;
            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                response = await SubstituirExpressaoRegularPorTexto(inputFile.FileUrl, expressoesRegulares, texto);
            }
            else
            {
                response = SubstituirExpressaoRegularPorTexto(inputFile.FileBytes, expressoesRegulares, texto);
            }

            return(response);
        }
        public async Task <byte[]> RemoverCarimboLateral(InputFile inputFile, float largura, float limiteMaximo)
        {
            inputFile.IsValid();

            byte[] response;
            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                response = await RemoverCarimboLateral(inputFile.FileUrl, largura, limiteMaximo);
            }
            else
            {
                response = RemoverCarimboLateral(inputFile.FileBytes, largura, limiteMaximo);
            }

            return(response);
        }
        public async Task <PdfInfo> PdfInfo(InputFile inputFile)
        {
            inputFile.IsValid();

            PdfInfo result = null;

            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                result = await PdfInfo(inputFile.FileUrl);
            }
            else
            {
                result = PdfInfo(inputFile.FileBytes);
            }

            return(result);
        }
        public async Task <bool> ValidateDigitalSignatures(InputFile inputFile)
        {
            inputFile.IsValid();

            bool isValid = false;

            if (inputFile.FileBytes != null)
            {
                isValid = await ValidateDigitalSignatures(inputFile.FileBytes);
            }
            else
            {
                isValid = await ValidateDigitalSignatures(inputFile.FileUrl);
            }

            return(isValid);
        }
        public async Task <bool> HasDigitalSignature(InputFile inputFile)
        {
            inputFile.IsValid();

            bool isValid;

            if (inputFile.FileBytes != null)
            {
                isValid = HasDigitalSignature(inputFile.FileBytes);
            }
            else
            {
                isValid = await HasDigitalSignature(inputFile.FileUrl);
            }

            return(isValid);
        }
        public async Task <bool> HasDigitalSignature(InputFile inputFile)
        {
            inputFile.IsValid();

            bool result;

            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                result = await HasDigitalSignature(inputFile.FileUrl);
            }
            else
            {
                result = HasDigitalSignature(inputFile.FileBytes);
            }

            return(result);
        }
        public async Task <ICollection <string> > ObterSignatureFieldName(InputFile inputFile)
        {
            inputFile.IsValid();

            ICollection <string> dococumentoAssinado;

            if (inputFile.FileUrl != null)
            {
                dococumentoAssinado = await ObterSignatureFieldName(inputFile.FileUrl);
            }
            else
            {
                dococumentoAssinado = ObterSignatureFieldName(inputFile.FileBytes);
            }

            return(dococumentoAssinado);
        }
        public async Task <bool> ValidarHashDocumento(InputFile inputFile, string hash)
        {
            inputFile.IsValid();

            bool documentoAutentico;

            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                documentoAutentico = await ValidarHashDocumento(inputFile.FileUrl, hash);
            }
            else
            {
                documentoAutentico = ValidarHashDocumento(inputFile.FileBytes, hash);
            }

            return(documentoAutentico);
        }
        public async Task <byte[]> CarimboLateral(InputFile inputFile, string texto, float tamanhoFonte,
                                                  Margem margem, string cor, int?paginaInicial, int?totalPaginas
                                                  )
        {
            inputFile.IsValid();

            byte[] response;
            if (!string.IsNullOrWhiteSpace(inputFile.FileUrl))
            {
                response = await CarimboLateral(inputFile.FileUrl, texto, tamanhoFonte, margem, cor, paginaInicial, totalPaginas);
            }
            else
            {
                response = CarimboLateral(inputFile.FileBytes, texto, tamanhoFonte, margem, cor, paginaInicial, totalPaginas);
            }

            return(response);
        }
        public async Task <IEnumerable <CertificadoDigitalDto> > SignatureValidation(InputFile inputFile, bool ignoreExpired = false)
        {
            inputFile.IsValid();

            IEnumerable <CertificadoDigital> listaCertificados = new List <CertificadoDigital>();

            if (inputFile.FileBytes != null)
            {
                listaCertificados = await SignatureValidation(inputFile.FileBytes, ignoreExpired);
            }
            else
            {
                listaCertificados = await SignatureValidation(inputFile.FileUrl, ignoreExpired);
            }

            var result = Mapper.Map <IEnumerable <CertificadoDigitalDto> >(listaCertificados);

            return(result);
        }