Beispiel #1
0
        public static string MontoEscrito(this decimal monto, monedaMontoEscrito moneda, idiomaMontoEscrito idioma)
        {
            string regreso = "";

            if (moneda == monedaMontoEscrito.Rec)
            {
                return("Moneda No Definida Correctamente");
            }

            switch (idioma)
            {
            case idiomaMontoEscrito.Español:

                regreso = monto.MontoEscritoEspanol(moneda);
                break;

            case idiomaMontoEscrito.Ingles:
                regreso = monto.MontoEscritoIngles(moneda);
                break;

            default:
                regreso = "Idioma No Definido";
                break;
            }

            return(regreso.ToUpper().Trim().Replace("  ", " "));
        }
Beispiel #2
0
        private static string MontoEscritoIngles(this decimal monto, monedaMontoEscrito moneda)
        {
            string regreso = "";
            string ls_cadena;
            string ls_aux = "";

            int li_terna = 0;
            int li_unidad;
            int li_decena;
            int li_centena;

            bool lb_todoCeros;
            bool lb_soloLaUnidad;

            string[] ls_unidades = { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
            string[] ls_decenas  = { "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
            string[] ls_decenas1 = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };

            // Recogemos la parte entera y la fracción.

            decimal ldc_entero  = Math.Truncate(monto);
            int     li_fraccion = monto.ParteDecimal(2);

            while (ldc_entero > 0)
            {
                // Indicamos la terna actual.
                li_terna++;

                // Se recorre el número por ternas.

                ls_cadena  = "";
                li_unidad  = (int)Math.Truncate((ldc_entero % 10));
                ldc_entero = Math.Truncate(ldc_entero / 10);
                li_decena  = (int)(ldc_entero % 10);
                ldc_entero = Math.Truncate(ldc_entero / 10);
                li_centena = (int)(ldc_entero % 10);
                ldc_entero = Math.Truncate(ldc_entero / 10);

                // Se analizan las unidades.
                if (li_unidad != 0)
                {
                    ls_cadena = ls_unidades[li_unidad - 1] + " ";
                }

                switch (li_decena)
                {
                case 1:

                    switch (li_unidad)
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    case 6:
                    case 7:
                    case 8:
                    case 9:

                        ls_cadena = ls_decenas1[li_unidad] + " ";
                        break;
                    }

                    break;

                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:

                    ls_cadena = ls_decenas[li_decena - 1] + " " + ls_cadena;
                    break;
                } // Final del switch (li_decena)

                // Se analizan las centenas.

                switch (li_centena)
                {
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:

                    ls_cadena = ls_unidades[li_centena - 1] + " hundred " + ls_cadena;
                    break;
                }

                // Analizamos la terna.



                lb_todoCeros    = ((li_unidad + li_decena + li_centena) == 0);
                lb_soloLaUnidad = ((li_unidad == 1) && ((li_decena + li_centena) == 0));

                switch (li_terna)
                {
                case 2:
                    if (!lb_todoCeros)
                    {
                        if (lb_soloLaUnidad)
                        {
                            ls_cadena = "thousand ";
                        }
                        else
                        {
                            ls_cadena += "thousand ";
                        }
                    }

                    break;

                case 3:
                    if (!lb_todoCeros)
                    {
                        if (lb_soloLaUnidad)
                        {
                            ls_cadena += "million ";
                        }
                        else
                        {
                            ls_cadena += "millions ";
                        }
                    }
                    break;

                case 4:
                    if (lb_soloLaUnidad)
                    {
                        ls_cadena = "thousand millions ";
                    }
                    else
                    {
                        ls_cadena += "thousand millions ";
                    }
                    break;

                default:
                    if (li_terna != 1)
                    {
                        ldc_entero = 0;
                        ls_cadena  = "";
                    }
                    break;
                }

                // Se monta el sultado de la terna actual con el de las anteriores.
                regreso = ls_cadena + regreso;
            } // Final del while (ldc_entero > 0)

            // Utilizamos la recursividad para montar el literal de los decimales.

            if (li_fraccion != 0)
            {
                ls_aux = ((decimal)li_fraccion).MontoEscritoIngles(monedaMontoEscrito.Rec);    //("-RECURSIVIDAD-");

                if (li_fraccion == 1)
                {
                    ls_aux = "one cent";
                }
                else
                {
                    ls_aux += " cents";
                }
            }

            // Montamos la salida final según corresponda.


            if (li_terna == 0)
            {
                // Solo tiene parte decimal.
                regreso = ls_aux;
            }
            else
            {
                // Hay que añadir el modificar 'de' si es multiplo
                // de 1000000.
                //If mod(truncate(adec_monto, 0), 1000000)= 0 Then ls_regreso+= 'DE '

                if ((Math.Truncate(monto)) % 1000000 == 0)
                {
                    regreso += "DE ";
                }

                // Añadimos la moneda a la parte entera.

                switch (moneda)
                {
                case monedaMontoEscrito.Rec:

                    break;

                case monedaMontoEscrito.Euros:

                    if (Math.Truncate(monto) == 1)
                    {
                        regreso = "ONE EURO";
                    }
                    else
                    {
                        regreso += "EUROS";
                    }
                    break;


                case monedaMontoEscrito.Pesos:

                    if (Math.Truncate(monto) == 1)
                    {
                        regreso = "ONE PESO";
                    }
                    else
                    {
                        regreso += "PESOS";
                    }
                    break;

                case monedaMontoEscrito.USD:


                    if (Math.Truncate(monto) == 1)
                    {
                        regreso = "ONE DOLLAR";
                    }
                    else
                    {
                        regreso += "DOLLARS";
                    }
                    break;


                case monedaMontoEscrito.Bs:

                    if (Math.Truncate(monto) == 1)
                    {
                        regreso = "ONE BOLIVAR";
                    }
                    else
                    {
                        regreso += "BOLÍVARES";
                    }
                    break;

                default:
                    if (Math.Truncate(monto) == 1)
                    {
                        regreso = "ONE BOLIVAR";
                    }
                    else
                    {
                        regreso += "BOLÍVARES";
                    }
                    break;
                } // final del switch (moneda.ToUpper().Trim())

                // Hay que añadir la parte decimal si la tiene.
                if (ls_aux != "")
                {
                    regreso = regreso.Trim() + " and " + ls_aux;
                }
            }

            return(regreso);
        }
Beispiel #3
0
        private static string MontoEscritoEspanol(this decimal monto, monedaMontoEscrito moneda)
        {
            string[] ls_unidades = { "UN", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE", "OCHO", "NUEVE" };
            string[] ls_decenas  = { "", "", "TREINTA", "CUARENTA", "CINCUENTA", "SESENTA", "SETENTA", "OCHENTA", "NOVENTA" };
            string[] ls_centenas = { "", "DOSCIENTOS", "TRESCIENTOS", "CUATROCIENTOS", "QUINIENTOS", "SEISCIENTOS", "SETECIENTOS", "OCHOCIENTOS", "NOVECIENTOS" };
            string[] ls_decenas1 = { "DIEZ", "ONCE", "DOCE", "TRECE", "CATORCE", "QUINCE", "DIECISEÍS" };
            string[] ls_decenas2 = { "VEINTE", "VEINTIÚN", "VEINTIDÓS", "VEINTITRÉS", "", "", "VEINTISÉIS" };

            /////////////////////////////////////////////////////////////////////////////////////////////////////
            //                                      Obtiene la parte entera y la fracción.										//
            /////////////////////////////////////////////////////////////////////////////////////////////////////

            decimal ldc_entero  = Math.Truncate(monto);
            int     li_fraccion = monto.ParteDecimal(2);

            int li_terna   = 0;
            int li_unidad  = 0;
            int li_decena  = 0;
            int li_centena = 0;

            string ls_cadena;
            string ls_regreso = "";
            string ls_aux     = "";

            bool lb_todoCeros, lb_soloLaUnidad;

            while (ldc_entero > 0)
            {
                // Indicamos la terna actual.
                li_terna++;

                // Se recorre el número por ternas.
                ls_cadena  = "";
                li_unidad  = (int)(ldc_entero % 10);
                ldc_entero = Math.Truncate(ldc_entero / 10);
                li_decena  = (int)(ldc_entero % 10);
                ldc_entero = Math.Truncate(ldc_entero / 10);
                li_centena = (int)(ldc_entero % 10);
                ldc_entero = Math.Truncate(ldc_entero / 10);

                //// Se analizan las unidades.
                if (li_unidad != 0)
                {
                    ls_cadena = ls_unidades[li_unidad - 1] + " ";
                }

                // Se analizan las decenas.

                switch (li_decena)
                {
                case 1:

                    switch (li_unidad)
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    case 6:
                        ls_cadena = ls_decenas1[li_unidad] + " ";
                        break;

                    default:
                        ls_cadena = "DIECI" + ls_cadena;
                        break;
                    }
                    break;

                case 2:

                    switch (li_unidad)
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 6:

                        ls_cadena = ls_decenas2[li_unidad] + " ";
                        break;

                    default:
                        ls_cadena = "VEINTI" + ls_cadena;
                        break;
                    }
                    break;

                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:

                    if (li_unidad == 0)
                    {
                        ls_cadena = ls_decenas[li_decena - 1] + " " + ls_cadena;
                    }
                    else
                    {
                        ls_cadena = ls_decenas[li_decena - 1] + " Y " + ls_cadena;
                    }

                    break;
                }

                // Se analizan las centenas.
                switch (li_centena)
                {
                case 1:

                    if (li_unidad == 0 && li_decena == 0)
                    {
                        ls_cadena = "CIEN ";
                    }
                    else
                    {
                        ls_cadena = "CIENTO " + ls_cadena;
                    }
                    break;

                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:

                    ls_cadena = ls_centenas[li_centena - 1] + " " + ls_cadena;
                    break;
                }

                // Analizamos la terna.

                lb_todoCeros    = ((li_unidad + li_decena + li_centena) == 0);
                lb_soloLaUnidad = ((li_unidad == 1) && ((li_decena + li_centena) == 0));

                switch (li_terna)
                {
                case 2:

                    if (!lb_todoCeros)
                    {
                        if (lb_soloLaUnidad)
                        {
                            ls_cadena = "MIL ";
                        }
                        else
                        {
                            ls_cadena += "MIL ";
                        }
                    }
                    break;

                case 3:

                    if (!lb_todoCeros)
                    {
                        if (lb_soloLaUnidad)
                        {
                            ls_cadena += "MILLÓN ";
                        }
                        else
                        {
                            ls_cadena += "MILLONES ";
                        }
                    }
                    break;

                case 4:

                    if (lb_soloLaUnidad)
                    {
                        ls_cadena = "MIL MILLONES ";
                    }
                    else
                    {
                        ls_cadena += "MIL MILLONES ";
                    }
                    break;

                default:

                    if (li_terna != 1)
                    {
                        ldc_entero = 0;
                        ls_cadena  = "";
                    }
                    break;
                }

                // Se monta el sultado de la terna actual con el de las anteriores.
                ls_regreso = ls_cadena + ls_regreso;
            } // Final de While

            // Utilizamos la recursividad para montar el literal de los decimales.

            if (li_fraccion != 0)
            {
                // Como se retorno como parte entera llega con EURO/EUROS y hay que quitarlo.

                //	choose case upper(trim(as_moneda))
                //		case "EUROS"
                //              ls_aux = trim(left(ls_aux, len(ls_aux) - 5))
                //		case else
                //              ls_aux = trim(left(ls_aux, len(ls_aux) - LEN(as_moneda)))
                //	end choose

                ls_aux = ((decimal)li_fraccion).MontoEscritoEspanol(monedaMontoEscrito.Rec);    // ("-RECURSIVIDAD-");

                if (li_fraccion == 1)
                {
                    ls_aux = "UN CÉNTIMO";
                }
                else
                {
                    ls_aux += " CÉNTIMOS";
                }
            }

            // Montamos la salida final según corresponda.
            if (li_terna == 0)
            {
                // Solo tiene parte decimal.
                ls_regreso = ls_aux;
            }
            else
            {
                // Hay que añadir el modificar "de" si es multiplo
                // de 1000000.

                if (((Math.Truncate(monto)) % 1000000) == 0)
                {
                    // Añadimos la moneda a la parte entera.
                    ls_regreso += "DE ";
                }


                switch (moneda)
                {
                case monedaMontoEscrito.Rec:

                    break;

                case monedaMontoEscrito.Euros:


                    if (Math.Truncate(monto) == 1)
                    {
                        ls_regreso = "UN EURO";
                    }
                    else
                    {
                        ls_regreso += "EUROS";
                    }

                    break;

                case monedaMontoEscrito.Pesos:


                    if (Math.Truncate(monto) == 1)
                    {
                        ls_regreso = "UN PESO";
                    }
                    else
                    {
                        ls_regreso += "PESOS";
                    }
                    break;

                case monedaMontoEscrito.USD:

                    if (Math.Truncate(monto) == 1)
                    {
                        ls_regreso = "UN DOLAR";
                    }
                    else
                    {
                        ls_regreso += "DÓLARES";
                    }

                    break;

                case monedaMontoEscrito.Bs:

                    if (Math.Truncate(monto) == 1)
                    {
                        ls_regreso = "UN BOLIVAR";
                    }
                    else
                    {
                        ls_regreso += "BOLÍVARES";
                    }
                    break;


                default:

                    if (Math.Truncate(monto) == 1)
                    {
                        ls_regreso = "UN BOLIVAR";
                    }
                    else
                    {
                        ls_regreso += "BOLÍVARES";
                    }
                    break;
                } // final switch (moneda)

                if (ls_aux != "")
                {
                    ls_regreso = ls_regreso.Trim() + " CON " + ls_aux;
                }
            }


            return(ls_regreso);
        }