public async Task <IActionResult> Shrink(ModelBackupSchedule _databaseSchedule)
        {
            try
            {
                string result = await DatabaseServiceHelper.GenerateScriptShrink(_databaseSchedule);

                if (String.IsNullOrEmpty(result))
                {
                    return(BadRequest("Falha na criação do script Shrink"));
                }
                string command = $"docker exec -i {_databaseSchedule.Databases.ConteinerName} /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P {_databaseSchedule.CustomerProduct.LoginPassword} -i /var/opt/mssql/{_databaseSchedule.Directory}/Shrink{_databaseSchedule.Databases.DatabaseName}.sql";

                string message = await DatabaseServiceHelper.Execute(command);

                if (message.Contains("Sqlcmd: Error:") || message.Contains("Incorrect syntax") || message.Contains("Unknown Option") ||
                    message.Contains("Erro") || message.Contains("Invalid filename"))
                {
                    return(BadRequest(message + "\n" + $"DBCC SHRINKFILE ({_databaseSchedule.Databases.DatabaseName}, 0, TRUNCATEONLY);"));
                }
                else
                {
                    return(Ok(message));
                }
            }
            catch (Exception err)
            {
                return(BadRequest(err.Message));
            }
        }
        public async Task <IActionResult> ChangeRecoveryModel(ModelBackupSchedule _databaseSchedule)
        {
            // 1 = FULL
            // 3 = SIMPLE
            try
            {
                string resp = null;
                switch (_databaseSchedule.RecoveryTypeModel)
                {
                case 1:
                {
                    string valid = await DatabaseServiceHelper.ReturnRecoveryModelType(_databaseSchedule);

                    if (valid.Equals("1"))
                    {
                        //não faça nada pois já esta como FULL!!!
                    }
                    else
                    {
                        resp = await DatabaseServiceHelper.ChangeRecoveryModelType(_databaseSchedule, "1");
                    }
                    break;
                }

                case 3:
                {
                    string valid = await DatabaseServiceHelper.ReturnRecoveryModelType(_databaseSchedule);

                    if (valid.Equals("3"))
                    {
                        //não faça nada pois já esta como SIMPLE!!!
                    }
                    else
                    {
                        resp = await DatabaseServiceHelper.ChangeRecoveryModelType(_databaseSchedule, "3");
                    }
                    break;
                }

                default:
                {
                    return(BadRequest($"Opção inválida:{_databaseSchedule.RecoveryTypeModel.ToString()}. 1 para FULL ou 3 para SIMPLE."));
                }
                }

                if (!String.IsNullOrEmpty(resp))
                {
                    return(BadRequest(resp));
                }

                return(Ok());
            }
            catch (Exception err)
            {
                return(BadRequest(err.Message));
            }
        }
        public async Task <IActionResult> BackupExec(ModelBackupSchedule _databaseSchedule)
        {
            try
            {
                string message      = null;
                string scriptBackup = null;
                if (_databaseSchedule.Type == ServicesCeltaWare.Model.Enum.BackuypType.MysqlFull)
                {
                    scriptBackup = $"docker exec {_databaseSchedule.Databases.ConteinerName} /usr/bin/mysqldump -u root --password={_databaseSchedule.Databases.DatabaseUserSa.Password}  celtabspdvconcentrador > {_databaseSchedule.Databases.Directory}/{_databaseSchedule.Directory}/{_databaseSchedule.Databases.ConteinerName}Backup.sql";
                }
                else
                {
                    scriptBackup = await DatabaseServiceHelper.GenerateScriptBackup(_databaseSchedule);

                    if (scriptBackup.Contains("back"))
                    {
                        scriptBackup = await DatabaseServiceHelper.GenerateScriptBackup(_databaseSchedule);
                    }
                }

                message = await DatabaseServiceHelper.Execute(scriptBackup);

                if (message.Contains("Sqlcmd: Error:") || message.Contains("Incorrect syntax") || message.Contains("Unknown Option") ||
                    message.Contains("Erro") || message.Contains("Invalid filename") || message.Contains("error") || message.Contains("error: 1045") &&
                    !message.Contains("BACKUP DATABASE successfully"))
                {
                    return(BadRequest(message));
                }
                else
                {
                    return(Ok(message));
                }
            }
            catch (Exception err)
            {
                return(BadRequest(err.Message));
            }
        }
        public async Task <IActionResult> ValidateBackupExec(ModelBackupSchedule _databaseSchedule)
        {
            try
            {
                if (_databaseSchedule.Type == ServicesCeltaWare.Model.Enum.BackuypType.MysqlFull)
                {
                    return(Ok());
                }
                string scriptValidate = null;
                scriptValidate = await DatabaseServiceHelper.GenerateScriptValidate(_databaseSchedule, ServicesCeltaWare.Model.Enum.ValidateType.LabelOnly);

                string message = await DatabaseServiceHelper.Execute(scriptValidate);

                if (message.Contains("Sqlcmd: Error:") || message.Contains("Incorrect syntax") || message.Contains("Unknown Option") ||
                    message.Contains("Erro") || message.Contains("Invalid filename") ||
                    message.Contains("is terminating abnormally"))
                {
                    return(BadRequest(message + scriptValidate));
                }

                scriptValidate = await DatabaseServiceHelper.GenerateScriptValidate(_databaseSchedule, ServicesCeltaWare.Model.Enum.ValidateType.VerifyOnly);

                message += await DatabaseServiceHelper.Execute(scriptValidate);

                if (message.Contains("Sqlcmd: Error:") || message.Contains("Incorrect syntax") || message.Contains("Unknown Option") || message.Contains("Erro") ||
                    message.Contains("is terminating abnormally") /* && !message.Contains("BACKUP DATABASE successfully")*/)
                {
                    return(BadRequest(message + scriptValidate));
                }

                return(Ok(message));
            }
            catch (Exception err)
            {
                return(BadRequest(err.Message));
            }
        }