/// <summary>
 /// Adds the given SqlException's message to the general error logger.
 /// </summary>
 /// <param name="except">The sql exception storing the message that gets passed to the logger</param>
 protected void AddExceptToError(SqlException except)
 {
     if (except.Number == -2 || except.Number == 0)
     {
         GeneralLogger.GetInstance().AddError(except.Message);
     }
 }

        private static string[] ParseSQLException(SqlException ex)
        {
            string errField, errMessage;

            switch (ex.Number)
            {
                case 2601:
                case 2627:
                    {
                        char[] splited = { '"', '“', '”' };
                        string[] msg = ex.Message.Split(splited);
                        if (msg.Length <= 2)
                        {
                            errField = null;
                            errMessage = ex.Message;
                        }
                        else
                        {
                            errField = msg[1];
                            errMessage = string.Format("Value of '{0}' exists, can not insert the same value.", errField);
                        }
                    }
                    break;
                default:
                    {
                        errField = null;
                        errMessage = ex.Message;
                    }
                    break;
            }

            return new string[2] { errField, errMessage };
        }

        /// <summary>
        /// Получить текст сообщения для исключения БД
        /// </summary>
        /// <param name="exception">Исключение БД</param>
        /// <returns>Текст сообщения</returns>
        private static string GetSqlErrorMessage(SqlException exception)
        {
            string result = Resources.SqlMessages.UnknownError;
            int errorCode = exception.Number;

            switch (errorCode)
            {
                case 2601:
                    // Duplicate key
                    result = Resources.SqlMessages.DuplicateRecord;
                    break;
                case 547:
                    // Reference/Foreign key constraint conflict
                    var match = Regex.Matches(exception.Message, @"The (\w+) .+")[0];
                    string operation = match.Groups[1].Value;
                    if (operation == "INSERT" || operation == "UPDATE")
                    {
                        result = Resources.SqlMessages.ConstraintConflict;
                    }
                    else if (operation == "DELETE")
                    {
                        result = Resources.SqlMessages.DeleteErrorConstraint;
                    }
                    break;
                case 8152:
                    // String or binary data would be truncated
                    result = Resources.SqlMessages.TooLongString;
                    break;
            }

            return result;
        }

        public static string CheckExp(SqlException ex)
        {
            switch (ex.Number)
            {
                case 2627:
                    return "Already Exist ...";
                case 233:
                    return "Sql Server Is Not Running ...";
                case 2:
                    return "Sql Server Is Not Running ...";
                case 515:
                    string ReturnMe = "You Must Fill" + Environment.NewLine;
                    int tempint = 0;
                    foreach (char Chr in ex.Message.ToCharArray())
                    {
                        //Get column name from error msg and its between ''
                        char Dot = '\'';

                        if (Chr == Dot)
                            tempint++;
                        if (tempint == 1)
                            ReturnMe += Chr;
                        else if (tempint == 2)
                            break;
                    }
                    return ReturnMe + "'";
                default:
                    return ex.Message;
            }
        }

        public static string CheckExp(SqlException ex)
        {
            switch (ex.Number)
            {
                case 2627:
                    return "موجود مسبقا";
                case 515:
                    string ReturnMe = "يجب مليء " + Environment.NewLine;
                    int tempint = 0;
                    foreach (char Chr in ex.Message.ToCharArray())
                    {
                        //Get column name from error msg and its between ''
                        char Dot = '\'';

                        if (Chr == Dot)
                            tempint++;
                        if (tempint == 1)
                            ReturnMe += Chr;
                        else if (tempint == 2)
                            break;
                    }
                    return ReturnMe + "'";
                case 241:
                    return String.Format("خطاء في نوع البيان {0}من فضلك فحص الارقام و التواريخ", Environment.NewLine);
                case 242:
                    return String.Format("خطاء في ادخال التاريخ {0}من فضلك تأكد ان صياغة التاريخ هي {0}سنه/شهر/يوم", Environment.NewLine);
                default:
                    return ex.Message;
            }
        }

    public static string CheckExp(SqlException ex)
    {
        switch (ex.Number)
        {
            case 2627:
                return "موجود مسبقاً ...";
            case 233:
                return "SQl Server غير متاح";
            case 2:
                return "SQl Server غير متاح";
            case 515:
                string ReturnMe = "يجب مليء" + Environment.NewLine;
                int tempint = 0;
                foreach (char Chr in ex.Message.ToCharArray())
                {
                    //Get column name from error msg and its between ''
                    char Dot = '\'';

                    if (Chr == Dot)
                        tempint++;
                    if (tempint == 1)
                        ReturnMe += Chr;
                    else if (tempint == 2)
                        break;
                }
                return ReturnMe + "'";
            default:
                return "خطاء في بيانات الادخال";
        }
    }

        /// <summary>
        ///   function to translate sql exceptions to readable messages. 
        ///   It also captures cases where sql server is not available and guards against
        ///   database connection details being leaked
        /// </summary>
        /// <param name = "exc"></param>
        /// <returns></returns>
        /// <remarks>
        /// </remarks>
        public static string TranslateSQLException(SqlException exc)
        {
            int i = 0;
            var errorMessages = new StringBuilder();
            for (i = 0; i <= exc.Errors.Count - 1; i++)
            {
                SqlError sqlError = exc.Errors[i];
                string filteredMessage = string.Empty;
                switch (sqlError.Number)
                {
                    case 17:
                        filteredMessage = "Sql server does not exist or access denied";
                        break;
                    case 4060:
                        filteredMessage = "Invalid Database";
                        break;
                    case 18456:
                        filteredMessage = "Sql login failed";
                        break;
                    case 1205:
                        filteredMessage = "Sql deadlock victim";
                        break;
                    default:
                        filteredMessage = exc.ToString();
                        break;
                }

                errorMessages.Append("<b>Index #:</b> " + i + "<br/>" + "<b>Source:</b> " + sqlError.Source + "<br/>" + "<b>Class:</b> " + sqlError.Class + "<br/>" + "<b>Number:</b> " +
                                     sqlError.Number + "<br/>" + "<b>Procedure:</b> " + sqlError.Procedure + "<br/>" + "<b>Message:</b> " + filteredMessage + "<br/>");
            }
            return errorMessages.ToString();
        }

 private DbException HandleForeignKey(string message, SqlException exception)
 {
     var result = new DbException(message, exception)
     {
         IsForeignKeyViolation = true
     };
     return result;
 }

 public static void LogSqlException(SqlException ex, ILog log)
 {
     log.ErrorFormat("Server: {0}, Procedure:{1} Number:{2} Message:{3}", ex.Server, ex.Procedure, ex.Number, ex.Message);
     foreach (SqlError item in ex.Errors)
     {
         log.ErrorFormat("State: {0}, Procedure: {1}, Number: {2}, LineNumber: {3}, Message:{4}", item.State, item.Procedure, item.Number, item.LineNumber, item.Message);
     }
 }

        static void ThrowQueueNotFoundException(Address destination, SqlException ex)
        {
            var msg = destination == null
                ? "Failed to send message. Target address is null."
                : string.Format("Failed to send message to address: [{0}]", destination);

            throw new QueueNotFoundException(destination, msg, ex);
        }

 public SqlExecutionException(string message, string server, string database, string sqlFile, string commands, SqlException sqlException) : base(message)
 {
     this._server = server;
     this._database = database;
     this._sqlFile = sqlFile;
     this._commands = commands;
     this._sqlException = sqlException;
 }

 private SqlExecutionException(SerializationInfo info, StreamingContext context)
    :base(info, context) {
    _server = info.GetString("_server");
    _database = info.GetString("_database");
    _sqlFile = info.GetString("_sqlFile");
    _commands = info.GetString("_commands");
    _sqlException = (SqlException)info.GetValue("_sqlException", typeof(SqlException));
 }

        /// <summary>
        ///     Converts the specified sqle.
        /// </summary>
        /// <param name="sqle">The sqle.</param>
        /// <param name="exInfo">The ex info.</param>
        /// <returns>Exception thrown by NHibernate</returns>
        private System.Exception Convert(SqlException sqle, AdoExceptionContextInfo exInfo)
        {
            System.Exception finalException;
            if (sqle != null)
            {
                switch (sqle.Number)
                {
                    case 17:
                    // SQL Server does not exist or access denied. 
                    case 4060:
                    // Invalid Database 
                    case 18456:
                        // Login Failed 
                        finalException = new DbLoginException(sqle.Message, sqle);
                        break;

                    case 1205:
                        // DeadLock Victim 
                        finalException =
                            new DbDeadLockException(sqle.Message, sqle);
                        break;

                    case 2627:
                    case 2601:
                        // Unique Index/Constriant Violation 
                        finalException =
                            new DbUniqueConstraintException(sqle.Message, sqle);
                        break;
                    case 547:
                        finalException =
                            new DbForeignKeyException(sqle.Message, sqle);
                        break;

                    case 208:
                        finalException =
                            new SQLGrammarException(
                                exInfo.Message, sqle.InnerException, exInfo.Sql);
                        break;

                    case 3960: // in case of snapshot isolation
                        finalException =
                            new StaleObjectStateException(exInfo.EntityName, exInfo.EntityId);
                        break;

                    default:
                        finalException =
                            SQLStateConverter.HandledNonSpecificException(exInfo.SqlException, exInfo.Message,
                                exInfo.Sql);
                        break;
                }
            }
            else
            {
                finalException = SQLStateConverter.HandledNonSpecificException(exInfo.SqlException, exInfo.Message,
                    exInfo.Sql);
            }
            return finalException;
        }

 public static bool checkUniqueViolationException(String mensaje, SqlException Ex)
 {
     if (Ex.Number == 2627)
     {
         MessageBox.Show(mensaje, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return true;
     }
     return false;
 }

 public static bool ReexecuteCommand(SqlException sqlException, ref SqlCommand command) {
     if (SqlExceptionsThatCauseRederivingSqlCommand.Values.Contains(sqlException.Number)) {
         command = CommandMethods.RederiveCommand(command);
         if (command != null) {
             return true;
         }
     }
     return false;
 }

        /// <summary>
        /// Transforms the specified SQL Server exception into the appropriate Nexon.Framework
        /// exception.
        /// </summary>
        /// <param name="exception">SQL Exception instance</param>
        /// <returns>
        /// Transformed Nexon.Framework exception.
        /// </returns>
        public static Exception TransformSqlException(SqlException exception)
        {
            // --- Check for primary key violation
            const string PK_ERROR_PATTERN = @"primary key constraint '(.+?)'.*in object '(.+?)'";
            var regex = new Regex(PK_ERROR_PATTERN, RegexOptions.IgnoreCase);
            var match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new PrimaryKeyViolationException(match.Groups[2].Captures[0].Value, exception);
            }

            // --- Check for unique key violation
            const string UK_ERROR_PATTERN1 = @"unique key constraint '(.+?)'.*in object '(.+?)'";
            regex = new Regex(UK_ERROR_PATTERN1, RegexOptions.IgnoreCase);
            match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new UniqueKeyViolationException(match.Groups[2].Captures[0].Value,
                                                      match.Groups[1].Captures[0].Value, exception);
            }

            const string UK_ERROR_PATTERN2 = @"Cannot insert duplicate key row in object '(.+?)' with unique index '(.+?)'.";
            regex = new Regex(UK_ERROR_PATTERN2, RegexOptions.IgnoreCase);
            match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new UniqueKeyViolationException(match.Groups[1].Captures[0].Value,
                                                      match.Groups[2].Captures[0].Value, exception);
            }

            // --- Check for foreign key violation
            const string FK1_ERROR_PATTERN = "foreign key constraint \"(.+?)\"";
            regex = new Regex(FK1_ERROR_PATTERN, RegexOptions.IgnoreCase);
            match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new ForeignKeyViolationException(match.Groups[1].Captures[0].Value, exception);
            }
            const string FK2_ERROR_PATTERN = "reference constraint \"(.+?)\"";
            regex = new Regex(FK2_ERROR_PATTERN, RegexOptions.IgnoreCase);
            match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new ForeignKeyViolationException(match.Groups[1].Captures[0].Value, exception);
            }

            // --- Check for NULL insertion
            const string NULL_ERROR_PATTERN = @"Cannot insert the value NULL into column '(.+?)'.*table '(.+?)'";
            regex = new Regex(NULL_ERROR_PATTERN, RegexOptions.IgnoreCase);
            match = regex.Match(exception.Message);
            if (match.Success)
            {
                return new NullValueNotAllowedException(match.Groups[2].Captures[0].Value,
                                                      match.Groups[1].Captures[0].Value, exception);
            }
            return exception;
        }

    public static string SqlException_Message(SqlException ex)
    {
        string STSsqlException = "";
            switch (ex.Number)
            {
                case 17:
                    {
                        STSsqlException = "Database Error";
                        break;
                    }
                case -2:
                    {
                        STSsqlException = "Connection timeout";
                        break;
                    }
                case 18456:
                case 1326:
                    {
                        STSsqlException = "Login Failed";
                        break;
                    }
                case 4060:
                    {
                        STSsqlException = "Database not found";
                        break;
                    }
                case 229:
                    {
                        STSsqlException = "Login Credentials Failed";
                        break;
                    }

                case 2601:
                case 2627:
                    {
                        STSsqlException = "Unique Key Voilation";
                        break;
                    }
                case 547:
                    {
                        STSsqlException = "General Error - Foreign Key Voilation";
                        break;
                    }
                case 8152:
                    {
                        STSsqlException = "General Error - DATA TRUNCATION";
                        break;
                    }
                default:
                    {
                        STSsqlException = ex.Message.ToString();
                        break;
                    }
            }
            return STSsqlException;
    }

        public static SqlException[] GenerateFakeSqlExceptions(params int[] errorCodes)
        {
            SqlException[] exceptions = new SqlException[errorCodes.Length];

            for (int i = 0; i < errorCodes.Length; i++)
            {
                exceptions[i] = GenerateFakeSqlException(errorCodes[i]);
            }

            return exceptions;
        }

 public static void ExceptionInfo(SqlException exc,ref Alert al)
 {
     switch (exc.Number)
     {
         case ERR_KEYCONFLICT:
             al = new Alert("danger", "Lỗi dữ liệu", "Khóa chính bị trùng!");
             break;
         default:
             al = new Alert("warning", "Lỗi SQL " + exc.Number, exc.Message);
             break;
     }
 }

 public void tratarSqlExceções(SqlException sqlex)
 {
     int erro = sqlex.ErrorCode;
     if (erro == -2146232060)
     {
         MessageBox.Show("Campo(s) Obrigatório(s) não preenchido(s).", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
     else
     {
         MessageBox.Show("Erro desconhecido.\nContate o administrador do sistema", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }