How to validate a digitable line of billing tickets in the format 00000.00000 00000.000000 00000.000000 0 00000000000000? [closed]

Question

How to validate a digitable line of billing tickets in the format 00000.00000 00000.000000 00000.000000 0 00000000000000? [closed]

Navigation

#1 by (6 votes)

2

Good afternoon, friends,

would anyone have a procedure similar to this and what could you post here?

It will be of great use to me and to future readers of this post.

I await feedback.

Here was my last attempt to translate this Delphi code, but it's wrong.

private static bool Ok = true;

    public static string RemoveFirst(this string source, string remove)
            {
                int index = source.IndexOf(remove);
                return (index < 0)
                    ? source
                    : source.Remove(index, remove.Length);
            }

            /// <summary>
            /// Valida o dígito verificador da linha
            /// </summary>
            /// <param name="chaveAcesso"></param>
            /// <returns></returns>

    public static string RetornaDigitoVerificadorCteModulo11(string chaveAcesso)
            {

                int peso = 2;
                int soma = 0;

                try
                {
                    chaveAcesso.ToCharArray()
                        .Reverse()
                        .ToList()
                        .ForEach(f =>
                        {
                            soma += (Convert.ToInt32(f.ToString()) * peso);
                            peso = (peso == 9) ? 2 : peso + 1;
                        });

                    return (11 - (soma % 11)) <= 1 ? "0" : (11 - (soma % 11)).ToString();
                }
                catch
                {
                    return "ERRO: A chave de acesso deve conter apenas números.";
                }
            }

            /// <summary>
            /// Valida de forma generalizada o DV da linha digitável
            /// </summary>
            /// <param name="linhaDigtavel"></param>
            /// <returns></returns>

            private static bool ValidacaoGeralDV(string linhaDigtavel)
            {
                string Dv;
                string DvVerificado;

                Dv = linhaDigtavel;

                RemoveFirst(Dv, " ");
                RemoveFirst(Dv, " ");
                RemoveFirst(Dv, " ");

                Dv = Dv.Substring(0, Dv.Length);
                DvVerificado = RetornaDigitoVerificadorCteModulo11(linhaDigtavel);

                return (DvVerificado == Dv) ? true : false;

            }

            /// <summary>
            /// Validação geral da linha digitável
            /// </summary>
            /// <param name="linha"></param>
            /// <returns></returns>

            private static void ValidacaoGeralLinha(string linha)
            {

                char[] caracteresLinha = linha.ToCharArray();


                bool correto =  (caracteresLinha[6] == '.') && 
                                (caracteresLinha[12] == ' ') &&
                                (caracteresLinha[18] == '.') &&
                                (caracteresLinha[25] == ' ') &&
                                (caracteresLinha[31] == '.') &&
                                (caracteresLinha[38] == ' ') &&
                                (caracteresLinha[40] == ' ');

                if (correto)
                {
                    for (int i = 1; i <= 54; i++)
                    {
                        if ( (i != 6) &&
                           (i != 12) &&
                           (i != 18) &&
                           (i != 25) &&
                           (i != 31) &&
                           (i != 38) &&
                           (i != 40) )
                        {
                            if (!linha.Contains(i.ToString()))
                            {

                                Ok = false;
                                break;
                            }


                        }

                    }

                }

            }

            /// <summary>
            /// Retorna a linha digitável já validada no formato: 00000.00000 00000.000000 00000.000000 0 00000000000000
            /// </summary>
            /// <param name="dado"></param>
            /// <returns></returns>

            private static string RetornaLinhaValidada(string dado)
            {
                string resultado = "";

                for (int i = 1; i <= dado.Length; i++)
                {

                    resultado = dado.Substring(0, dado.Length);


                    ValidacaoGeralLinha(resultado);

                    if (Ok)
                    {
                        if (ValidacaoGeralDV(resultado))

                            break;

                    }

                }

                return "";
            }

            static void Main(string[] args)
            {

                Console.WriteLine(RetornaLinhaValidada("10490.05539 03698.700006 00091.449587 5 55490000028531"));
                Console.ReadKey();

            }

c# boleto

asked by anonymous 26.04.2016 / 18:14

1 answer

In an MVC project, where should I leave the enums? Locate in Delphi

score 6 · Accepted Answer

If you want to validate only the format, here is a solution with Regular Expression:

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Program
{
    public static void Main()
    {       
        Console.WriteLine(ValidarLinhaDigitavel("00000.00000 00000.000000 00000.000000 0 00000000000000"));
    }

    public static bool ValidarLinhaDigitavel(string input)
    {
        return Regex.IsMatch(input, @"\d{5}\.\d{5} \d{5}\.\d{6} \d{5}\.\d{6} \d \d{14}");
    }
}