kreta/Kreta.Core/KretaConvert.cs

using System;
using System.Collections.Generic;
using Kreta.Resources;

namespace Kreta.Core
{
    public static class KretaConvert
    {
        /// <summary>
        /// SDA db kompatibilis booleannal tér vissza
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Boolean</returns>
        public static string ToSDABoolean(int? data)
        {
            if (data.HasValue)
            {
                if (data.Value == 0)
                {
                    return "F";
                }

                if (data.Value == 1)
                {
                    return "T";
                }

                throw new Exception(ErrorResource.ErvenytelenInteger);
            }

            return null;
        }

        /// <summary>
        /// SDA db kompatibilis booleannal tér vissza
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Boolean</returns>
        public static string ToSDABoolean(bool? data)
        {
            if (data.HasValue)
            {
                return data.Value ? "T" : "F";
            }

            return null;
        }

        /// <summary>
        /// Nullokat is kezelõ boolean Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Boolean</returns>
        public static bool ToBoolean(object data)
        {
            return ToBoolean(data, false);
        }

        /// <summary>
        /// Nullokat is kezelõ boolean Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <param name="NullValue">null adatra true-t vagy false-t adjon vissza</param>
        /// <returns>Boolean</returns>
        public static bool ToBoolean(object data, bool NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? NullValue
                   : Convert.ToBoolean(data);
            }
            catch
            {
                return NullValue;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ boolean Convert Nullra.
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <param name="NullValue">null adatra true-t vagy false-t adjon vissza</param>
        /// <returns>Boolean</returns>
        public static bool? ToNullableBoolean(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? (bool?)null
                   : Convert.ToBoolean(data);
            }
            catch
            {
                return (bool?)null;
            }
        }

        /// <summary>
        /// T es F stringbol csinal boolt
        /// </summary>
        /// <param name="data">bemeno adat</param>
        /// <returns>bool</returns>
        public static bool ToBooleanFromTF(object data)
        {
            return ToBooleanFromTF(data, false);
        }

        /// <summary>
        /// T es F stringbol csinal boolt
        /// </summary>
        /// <param name="data">bemeno adat</param>
        /// <param name="NullValue">true vagy false legyen a nullbol</param>
        /// <returns>bool</returns>
        public static bool ToBooleanFromTF(object data, bool NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? NullValue
                   : Convert.ToBoolean(data.ToString() == "T");
            }
            catch
            {
                return NullValue;
            }
        }

        /// <summary>
        /// T es F stringbol csinal boolt
        /// </summary>
        /// <param name="data">bemeno adat</param>
        /// <param name="NullValue">true vagy false legyen a nullbol</param>
        /// <returns>bool</returns>
        public static bool ToBooleanFromIN(object data, bool NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? NullValue
                   : Convert.ToBoolean(data.ToString() == "I");
            }
            catch
            {
                return NullValue;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ int Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Int32</returns>
        public static Int32 ToInt32(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? 0
                   : Convert.ToInt32(data);
            }
            catch
            {
                return 0;
            }
        }

        public static int? ToNullableInt32(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? (int?)null
                   : Convert.ToInt32(data);
            }
            catch
            {
                return (int?)null;
            }
        }

        public static Int64 ToInt64(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? 0L
                   : Convert.ToInt64(data);
            }
            catch
            {
                return 0L;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ int Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Int32</returns>
        public static decimal ToDecimal(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? 0
                   : Convert.ToDecimal(data);
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ int Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Int32</returns>
        public static Int32 ToInt32(object data, int NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? NullValue
                   : Convert.ToInt32(data);
            }
            catch
            {
                return NullValue;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ double Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Int32</returns>
        public static Double ToDouble(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? 0D
                   : Convert.ToDouble(data);
            }
            catch
            {
                return 0D;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ double Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Int32</returns>
        public static Double ToDouble(object data, double NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? NullValue
                   : Convert.ToDouble(data);
            }
            catch
            {
                return NullValue;
            }
        }

        public static double? ToNullableDouble(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                   ? (double?)null
                   : Convert.ToDouble(data);
            }
            catch
            {
                return (double?)null;
            }
        }

        /// <summary>
        /// Nullokat is kezelõ byte tömb Convert
        /// </summary>
        /// <param name="data">Bemenõ adat</param>
        /// <returns>Byte []</returns>
        public static byte[] ToByteArray(object data)
        {
            return data == DBNull.Value || data == null ? null : (byte[])data;
        }

        public static string ToString(object data)
        {
            return ToString(data, "");
        }

        public static string ToString(object data, string defaultvalue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value))
                   ? defaultvalue
                   : data.ToString();
            }
            catch
            {
                return defaultvalue;
            }
        }

        public static DateTime? ToDateTime(object data)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                    ? (DateTime?)null
                    : Convert.ToDateTime(data);
            }
            catch
            {
                return (DateTime?)null;
            }
        }

        public static DateTime? ToDateTime(object data, DateTime? NullValue)
        {
            try
            {
                return ((data == null) || (data == DBNull.Value) || string.IsNullOrWhiteSpace(data.ToString()))
                    ? NullValue
                    : Convert.ToDateTime(data);
            }
            catch
            {
                return NullValue;
            }
        }

        public static Guid Int2Guid(int value)
        {
            byte[] bytes = new byte[16];
            BitConverter.GetBytes(value).CopyTo(bytes, 0);
            return new Guid(bytes);
        }

        public static int Guid2Int(Guid value)
        {
            byte[] b = value.ToByteArray();
            int bint = BitConverter.ToInt32(b, 0);
            return bint;
        }

        public static Guid? StringToNullableGuid(object data)
        {
            var value = ToString(data);

            if (string.IsNullOrWhiteSpace(value))
            {
                return null;
            }

            return new Guid(value);
        }

        /// <summary>
        /// Kiszed minden olyan elemet ami gondot okozhat a beviteli mezõknél
        /// LoadWithFilternél használandó
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string PreventSQLInjection(string dirtytext)
        {
            List<string> disallowedtags = new List<string>()
            {
                "'", " or ", " OR ", " and ", " AND ",
                "=", "<", ">", "<>", " not ", " NOT "
            };
            //elviekben mivel az elsõ szóköznél elvágom így nem maradhat benne and, or vagy not
            string cleartext = dirtytext;

            if (cleartext.Contains(" "))
            {
                cleartext = cleartext.Substring(0, cleartext.IndexOf(" ") + 1).Trim();
            }

            foreach (string tag in disallowedtags)
            {
                cleartext = cleartext.Replace(tag, "");
            }

            return cleartext;
        }

        public static string PreventXSSAttack(string dirtytext)
        {
            if (dirtytext == null)
            {
                return null;
            }

            List<string> disallowedtags = new List<string>()
            {
                "iframe", "object", "embed", "script"
            };

            string cleantext = dirtytext;

            foreach (string tag in disallowedtags)
            {
                string current_tag = tag.ToLower();
                int hossz = 0;

                int eleje = cleantext.ToLower().IndexOf(string.Format("<{0}", current_tag));
                if (eleje == -1)
                {
                    eleje = cleantext.ToLower().IndexOf(string.Format("&lt;{0}", current_tag));
                }

                int vege = -1;
                while (eleje > -1)
                {
                    hossz = current_tag.Length + 1;
                    vege = cleantext.ToLower().IndexOf(string.Format("/{0}", current_tag), eleje);
                    if (vege == -1)
                    {
                        vege = cleantext.ToLower().IndexOf("/>", eleje);
                        hossz = 2;
                    }
                    if (cleantext.ToLower().IndexOf("&gt;", vege) - (vege + current_tag.Length + 1) == 0)
                    {
                        hossz += 4;
                    }
                    cleantext = cleantext.Remove(eleje, vege - eleje + hossz);
                    eleje = cleantext.ToLower().IndexOf(string.Format("<{0}", current_tag));
                    if (eleje == -1)
                    {
                        eleje = cleantext.ToLower().IndexOf(string.Format("&lt;{0}", current_tag));
                    }
                }
            }

            return cleantext;
        }

        public static Guid? ToNullableGuid(object data)
        {
            try
            {
                return data == null || data == DBNull.Value || string.IsNullOrWhiteSpace(data.ToString())
                   ? (Guid?)null
                   : Guid.Parse(ToString(data));
            }
            catch
            {
                return null;
            }
        }

        public static Guid ToGuid(object data)
        {
            try
            {
                return data == null || data == DBNull.Value || string.IsNullOrWhiteSpace(data.ToString())
                   ? default
                   : Guid.Parse(ToString(data));
            }
            catch
            {
                return default;
            }
        }
    }
}