/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Different
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public void BackupDifferentFromDatabase(AppConfigIts appConfig, string directory)
{
//O processo de emissão de backups diferenciais não é muito diferente da emissão de backups completos.
//Para emitir um backup diferencial, defina a propriedade Incremental = true.
//Se você definir essa propriedade, o backup incremental / diferencial será realizado
//desde o último backup completo.
Backup bkpDbDifferential = createBackup(appConfig, directory);
string database = appConfig.Database;
string serverName = appConfig.ServerName;
bkpDbDifferential.BackupSetDescription = database.ToUpper() + " database - Differential Backup";
/* You can specify Incremental = false (default) to perform full backup
* or Incremental = true to perform differential backup since most recent
* full backup */
bkpDbDifferential.Incremental = true;
//Servidor onde devo disparar a ação
//por padrão é o (local)
Server server = new Server(serverName);
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDbDifferential.SqlBackup(server);
}
public bool AddInformationUpdate(Package pacote, UpdateInfo updateInfo, AppConfigIts app)
{
try
{
using (var ctx = new AdminContext(app.ConnectionString))
{
try
{
//busca o pacote
var current = ctx.UpdateInfoDao.Where(u => u.NumeroPacote == pacote.NumeroPacote &&
u.Status == TypeStatusUpdate.Erro)
.First();
current.Update(updateInfo);
return(ctx.UpdateInfoDao.Update(current));
}
catch (Exception)
{
return(ctx.UpdateInfoDao.Save(updateInfo));
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex, "Falha ao inserir log de aplicação de pacote", "Aplicação de Pacote");
return(false);
}
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public bool BackupFullFromDatabase(AppConfigIts appConfig, string directory = null)
{
Backup bkpDbFull = createBackup(appConfig, directory);
string serverName = appConfig.ServerName;
//Servidor onde devo disparar a ação
Server server = new Server(serverName);
try
{
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDbFull.SqlBackup(server);
return(true);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha durante o processo de backup!");
return(false);
}
}
public TypeStatusUpdate GetStatusPacote(Package pacote, AppConfigIts app)
{
try
{
using (var ctx = new AdminContext(app.ConnectionString))
{
try
{
//busca o pacote no banco
var pkgCurrent = ctx.UpdateInfoDao.Where(u => u.NumeroPacote == pacote.NumeroPacote)
.First();
return(pkgCurrent.Status);
}
catch
{
//whatever
return(TypeStatusUpdate.NaoAplicado);
}
}
}
catch (Exception)
{
//fodase, retorna nao aplicado e tenta de novo
return(TypeStatusUpdate.Erro);
}
}
public XFrmClientUpdate()
{
InitializeComponent();
init();
string startup = Application.StartupPath;
//altera o path para onde os recursos estão
_proceduresResource = startup.Replace(@"bin\Debug", @"SQLs\procedures");
//..\ITSolution\ITSolution.Admin\bin\Debug
//..\ITE\ITE.Forms\bin\Debug\
_resourceDir = startup.Replace(@"\ITSolution\ITSolution.Admin", @"ITE\ITE.Forms");
appConfig = AppConfigManager.Configuration.AppConfig;
if (appConfig.ServerName.Equals("(local)"))
{
cbDatabase.Properties.Items.AddRange(new ConnectionLocalSql().DataBases);
this.cbDatabase.SelectedItem = appConfig.Database;
}
else
{
this.cbDatabase.Properties.Items.Add(appConfig.Database);
this.cbDatabase.SelectedIndex = 0;
}
this.cbDatabase.SelectedItem = appConfig.Database;
this.txtServerName.Text = appConfig.ServerName;
}
private void indexarDados(AppConfigIts app)
{
txtServerName.Text = app.ServerName;
txtConnectionName.Text = app.ConnectionName;
txtUser.Text = app.User;
txtPassword.Text = app.Password;
if (app.User.IsNullOrEmpty())
{
cbAuthentication.SelectedIndex = 0;
}
else
{
cbAuthentication.SelectedIndex = 1;
}
if (!app.Database.IsNullOrEmpty())
{
cbDatabase.Properties.Items.Clear();
cbDatabase.Properties.Items.Add(app.Database);
cbDatabase.SelectedIndex = 0;
radioDatabase.Checked = true;
}
else
{
cbDatabase.SelectedIndex = -1;
}
}
private bool testeConnection(AppConfigIts appCfg)
{
if (cbAuthentication.SelectedIndex == 1 && appCfg.User.IsNullOrEmpty())
{
XMessageIts.Advertencia("Usuário não informado !");
return(false);
}
if (cbAuthentication.SelectedIndex == 1 && appCfg.Password.IsNullOrEmpty())
{
XMessageIts.Advertencia("Senha não informada !");
return(false);
}
if (ValidadorDTO.ValidateWarningAll(appCfg))
{
var con = createConnection();
//terminar
if (con.OpenConnection())
{
XMessageIts.Mensagem("Conexão bem sucedida !");
con.CloseConnection();
barBtnAppConfig.Enabled = true;
barBtnAddConnection.Enabled = true;
return(true);
}
}
barBtnAddConnection.Enabled = false;
barBtnAppConfig.Enabled = false;
return(false);
}
/// <summary>
/// Descriptografa o AppConfig informado.
/// Somente a senha é decifrada.
/// </summary>
/// <param name="appConfig"></param>
public void AppConfig(AppConfigIts appConfig)
{
//appConfig.ServerName = EncryptionUtil.Decoded(appConfig.ServerName);
//appConfig.Database = EncryptionUtil.Decoded(appConfig.Database);
//appConfig.User = EncryptionUtil.Decoded(appConfig.User);
try
{
//descodifica
string uncoded = ASCIIEncodingIts.Decoded(appConfig.Password);
//codifica
string coded = ASCIIEncodingIts.Coded(uncoded);
//se recebida esta igual a senha criptograda
if (appConfig.Password.Equals(coded))
{
//tava criptografada ok
appConfig.Password = uncoded;
}
//nao estava criptografada use a deixa a pw quieta
}
catch (Exception)
{
Console.BackgroundColor = ConsoleColor.Red;
Console.WriteLine("Descriptografia desnecessária");
Console.ForegroundColor = ConsoleColor.Black;
}
}
private void loadAppXml(string xmlFile)
{
this.barBtnAppConfig.Caption = "Alter Connection";
AppConfigManager.Configuration.Load(xmlFile);
this.cbConnections.Properties.Items.Clear();
var connections = AppConfigManager.Configuration.AppConfigList;
if (AppConfigManager.Configuration.IsReadOnly)
{
this.AppConfig = AppConfigManager.Configuration.AppConfig;
this.lblXmlConnections.Visible = true;
this.cbConnections.Visible = true;
this.cbConnections.Properties.Items.AddRange(connections);
this.cbConnections.Properties.ReadOnly = false;
this.cbConnections.SetSelectItem(this.AppConfig);
indexarDados(this.AppConfig);
}
else
{
this.cbConnections.Properties.ReadOnly = true;
XMessageIts.Mensagem("Não foram encontradas conexões no arquivo .xml");
}
}
/// <summary>
/// Realiza backup da transação de logs de uma base dados do SQL server.
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public void BackupTransactionLogFromDatabase(AppConfigIts appConfig, string directory)
{
//Backups de log de transações - Mais uma vez, o processo de emissão de backup de log transacional
//não é muito diferente da emissão de backups completos.
//Para emitir backups de log transacional, defina a propriedade Action = BackupActionType.Log
//em vez de BackupActionType.Database como no caso de um backup completo.
Backup bkpDbLog = createBackup(appConfig, directory);
string database = appConfig.Database;
string serverName = appConfig.ServerName;
/* Specify whether you want to back up database or files or log */
bkpDbLog.Action = BackupActionType.Log;
bkpDbLog.BackupSetDescription = database.ToUpper() + " database - Log Backup";
/* You can specify Incremental = false (default) to perform full backup
* or Incremental = true to perform differential backup since most recent
* full backup */
bkpDbLog.Incremental = true;
//Servidor onde devo disparar a ação
//por padrão é o (local)
Server server = new Server(serverName);
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDbLog.SqlBackup(server);
}
private void barBtnAddConnection_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
this.AppConfig = null;
indexarDados(new AppConfigIts());
cbConnections.Visible = false;
txtConnectionName.Focus();
barBtnAppConfig.Caption = "Create Connection";
lblXmlConnections.Visible = false;
}
public XFrmListViewDataBase(AppConfigIts app)
{
InitializeComponent();
this.ActiveControl = this.cbDatabase;
this.app = app;
this.IsSelectedDatabase = false;
}
private void cbConnections_SelectedIndexChanged(object sender, EventArgs e)
{
object app = cbConnections.SelectedItem;
if (app != null)
{
this.AppConfig = app as AppConfigIts;
indexarDados(this.AppConfig);
}
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public void BackupFullFromDatabaseAsync(AppConfigIts appConfig, string directory)
{
Backup bkpDbFull = createBackup(appConfig, directory);
string serverName = appConfig.ServerName;
//Servidor onde devo disparar a ação
//por padrão é o (local)
Server server = new Server(serverName);
bkpDbFull.SqlBackupAsync(server);
}
private void addConnection(AppConfigIts app)
{
if (!AppConfigManager.Configuration.Contains(app))
{
AppConfigManager.Configuration.Add(app);
this.Dispose();
}
else
{
XMessageIts.Advertencia("Já existe uma conexão nomeada \"" + app.ConnectionName + "\"", "Aviso");
}
}
private ConnectionFactoryIts createConnection()
{
string serverName = txtServerName.Text;
string database = cbDatabase.SelectedItem != null
? cbDatabase.SelectedItem.ToString() : "";
string user = txtUser.Text;
string pw = txtPwd.Text;
this._appConfig = new AppConfigIts(_appConfig.ConnectionName, serverName, user, pw, database);
return(new ConnectionFactoryIts(_appConfig.ConnectionString));
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public bool BackupFullCompressFromDatabase(AppConfigIts appConfig, string directory)
{
bool result = BackupFullFromDatabase(appConfig, directory);
if (File.Exists(this._pathBackup))
{
//se o arquivo foi compactado
if (ZipUtil.CompressFile(this._pathBackup))
{
File.Delete(this._pathBackup);
}
}
return(result);
}
public XFrmBackupSql(AppConfigIts app) : this()
{
this._appConfig = app;
string dirBackup = Path.Combine(Application.StartupPath, "Backups ITE\\");
this.folderBrowserDialog1.SelectedPath = dirBackup;
this.txtPathBackup.Text = dirBackup + _appConfig.Database + "_" + DataUtil.ToDateSql() + ".bak";
if (!Directory.Exists(dirBackup))
{
Directory.CreateDirectory(dirBackup);
}
this.lblDatabase.Visible = false;
this.cbDatabase.Visible = false;
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full utilizando instrução SQL
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public bool BackupNativoFullFromDatabase(AppConfigIts appConfig, string directory)
{
//seta o path de backup
createBackup(appConfig, directory);
try
{
var scriptSql = new StringBuilder();
scriptSql.Append("BACKUP DATABASE ");
scriptSql.Append(appConfig.Database);
scriptSql.Append(" TO DISK = ");
scriptSql.Append("'");
scriptSql.Append(_pathBackup);
scriptSql.Append("' ");
scriptSql.Append("WITH NO_COMPRESSION, NAME = ");
scriptSql.Append("'");
scriptSql.Append(appConfig.Database);
scriptSql.Append("-Full Database backup', FORMAT, INIT, NOREWIND, NOUNLOAD, STATS = 1");
try
{
var a = new ConnectionLocalSql(appConfig.ConnectionString).ExecuteQuery(scriptSql.ToString());
if (File.Exists(this._pathBackup))
{
//se o arquivo foi compactado
if (ZipUtil.CompressFile(this._pathBackup))
{
File.Delete(this._pathBackup);
}
}
}
catch (SqlException sqle)
{
XMessageIts.ExceptionMessageDetails(sqle, "Falha durante o processo de backup!");
return(false);
}
return(true);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha durante o processo de backup!");
return(false);
}
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public async void BackupFullCompressFromDatabaseAsync(AppConfigIts appConfig, string directory)
{
Backup bkpDbFull = createBackup(appConfig, directory);
string serverName = appConfig.ServerName;
//Servidor onde devo disparar a ação
Server server = new Server(serverName);
await Task.Run(() => bkpDbFull.SqlBackupAsync(server));
if (File.Exists(this._pathBackup))
{
if (ZipUtil.CompressFile(this._pathBackup))
{
File.Delete(this._pathBackup);
}
}
}
private void init()
{
//new WizardFocusButtonNext(this.wizardControl1).AddSelectedPageChanged();
this.wizardControl1.EnableSelectedPageChanged();
scintilla.ConfigureHighlightingSql();
_taskManager = new TaskUpdateManager();
_tokenSource = new CancellationTokenSource();
//utiliza os dados do arquivo existente
_appConfig = AppConfigManager.Configuration.AppConfig;
this.ActiveControl = txtUpdateFile;
txtUpdateFile.Focus();
progressBarControl1.Properties.Step = 1;
this.txtServerName.Text = _appConfig.ServerName;
progressBarControl1.PerformStep();
progressBarControl1.Properties.Step = 1;
progressBarControl1.Properties.PercentView = true;
if (_appConfig.ServerName.Equals("(local)"))
{
this.cbDatabase.Properties.Items.AddRange(new ConnectionLocalSql().DataBases);
this.cbDatabase.SelectedItem = _appConfig.Database;
}
else
{
this.cbDatabase.Properties.Items.Add(_appConfig.Database);
this.cbDatabase.SelectedIndex = 0;
}
if (!_appConfig.User.IsNullOrEmpty())
{
this.txtUser.Text = _appConfig.User;
this.chAutenticacao.Checked = true;
}
if (!_appConfig.Password.IsNullOrEmpty())
{
this.txtPwd.Text = _appConfig.Password;
}
}
public static void SetParamDataSource(SqlDataSource sqs, AppConfigIts appConf)
{
var param = new DevExpress.DataAccess.ConnectionParameters.MsSqlConnectionParameters()
{
ServerName = appConf.ServerName,
DatabaseName = appConf.Database,
UserName = appConf.User,
Password = appConf.Password
};
if (appConf.Password.IsNullOrEmpty())
{
param.AuthorizationType = DevExpress.DataAccess.ConnectionParameters.MsSqlAuthorizationType.Windows;
}
else
{
param.AuthorizationType = DevExpress.DataAccess.ConnectionParameters.MsSqlAuthorizationType.SqlServer;
}
sqs.ConnectionParameters = param;
}
/// <summary>
/// Recupera o DataSource da string de conexão atual
/// </summary>
/// <returns></returns>
public static MsSqlConnectionParameters GetParamDataSource()
{
AppConfigIts appConf = AppConfigManager.Configuration.AppConfig;
var param = new DevExpress.DataAccess.ConnectionParameters.MsSqlConnectionParameters()
{
ServerName = appConf.ServerName,
DatabaseName = appConf.Database,
UserName = appConf.User,
Password = appConf.Password
};
if (appConf.Password.IsNullOrEmpty())
{
param.AuthorizationType = DevExpress.DataAccess.ConnectionParameters.MsSqlAuthorizationType.Windows;
}
else
{
param.AuthorizationType = DevExpress.DataAccess.ConnectionParameters.MsSqlAuthorizationType.SqlServer;
}
return(param);
}
public static void AddConnectionStringRuntimenString(AppConfigIts app)
{
try
{
if (string.IsNullOrWhiteSpace(app.User))
{
app.User = "";
}
if (string.IsNullOrWhiteSpace(app.Password))
{
app.Password = "";
}
SqlConnectionStringBuilder scsb = new SqlConnectionStringBuilder
{
DataSource = app.ServerName,
InitialCatalog = app.Database,
UserID = app.User,
Password = app.Password,
IntegratedSecurity = string.IsNullOrEmpty(app.User.Trim())
};
// Criar Conexão
config.ConnectionStrings.ConnectionStrings.Add(
new ConnectionStringSettings
{
Name = app.ConnectionName,
ConnectionString = scsb.ConnectionString,
ProviderName = "System.Data.SqlClient"
});
// SaveLayout Conexão
config.Save(ConfigurationSaveMode.Modified);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Entrada já adicionada !");
}
}
public void LoadDashboard(DashboardImage _dashboardImage, DashboardViewer dashboardViewer1)
{
using (var ctx = new ReportContext())
{
string path = LoadToChache(_dashboardImage);
Dashboard ds = new Dashboard();
ds.LoadFromXml(path);
DataSourceCollection dsCollection = ds.DataSources;
var appConf = new AppConfigIts(ctx.NameOrConnectionString);
foreach (DashboardSqlDataSource dsSql in dsCollection)
{
ReportUtil.SetParamDataSource(dsSql, appConf);
}
dashboardViewer1.Dashboard = ds;
dashboardViewer1.ReloadData();
}
}
/// <summary>
/// BACKUP DATABASE WITH COMPRESSION is not supported on Express Edition (64-bit).
/// Backup com compressão - Esse backup reduz quase 75% do tamanho do backup original.*/
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public void BackupCompressFromDatabase(AppConfigIts appConfig, string directory)
{
Backup bkpDbFullWithCompression = createBackup(appConfig, directory);
string database = appConfig.Database;
string serverName = appConfig.ServerName;
/* You can use back up compression technique of SQL Server 2008,
* specify CompressionOption property to On for compressed backup */
bkpDbFullWithCompression.CompressionOption = BackupCompressionOptions.On;
bkpDbFullWithCompression.BackupSetName = database.ToUpper() + " database Backup - Compressed";
bkpDbFullWithCompression.BackupSetDescription = database.ToUpper() + " database - Full Backup with Compressin";
//Servidor onde devo disparar a ação
//por padrão é o (local)
Server server = new Server(serverName);
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDbFullWithCompression.SqlBackup(server);
}
private Backup createBackup(AppConfigIts appConfig, string directory)
{
string database = appConfig.Database;
if (string.IsNullOrWhiteSpace(database))
{
throw new ArgumentException("Nome do banco de dados não pode nulo e nem conter espaços");
}
//Com a propriedade Ação, você pode especificar o tipo de backup, como backup completo, arquivos ou log.
//Com a propriedade banco de dados especificar o nome do banco de dados que está sendo feito backup.
//O dispositivo é o tipo de mídia de backup, como disco ou fita, portanto, é necessário
//adicionar um dispositivo (um ou mais) à coleção Dispositivos da instância de backup.
//Com as propriedades BackupSetName e BackupSetDescription, você pode especificar o nome e a descrição
//para o conjunto de backup.
//A classe Backup também tem uma propriedade chamada ExpirationDate que indica quanto tempo os
//dados de backup são considerados válidos e expirar o backup após essa data.
//A instância de objeto de backup gera vários eventos durante a operação de backup, podemos gravar
//manipuladores de eventos para esses eventos e conectá - los com eventos.
//É isso que estou fazendo para monitorar o progresso.Estou conectando os métodos
//CompletionStatusInPercent e Backup_Completed(manipuladores de eventos) com eventos PercentComplete e Complete
//da instância do objeto de backup.Finalmente, estou chamando o método SqlBackup para iniciar a operação de backup,
//SMO fornece uma variante desse método chamado SqlBackupAsync
//se você deseja iniciar a operação de backup de forma assíncrona.
Backup bkpDbFull = new Backup();
// Specify whether you want to back up database or files or log
bkpDbFull.Action = BackupActionType.Database;
// Specify the name of the database to back up
bkpDbFull.Database = database;
string databaseName = database + "_" + DataUtil.ToDateSql() + ".bak";
if (directory == null)
{
//aponta direto pro aquivo .exe
//string exe = Application.ExecutablePath;
//path do backup sera na pasta do programa => DEBUG/database-date.bak
directory = Path.Combine(Application.StartupPath, databaseName);
//arquivo do bak
bkpDbFull.Devices.AddDevice(directory, DeviceType.File);
}
else
{
directory = Path.Combine(directory, databaseName);
bkpDbFull.Devices.AddDevice(directory, DeviceType.File);
}
this._pathBackup = directory;
bkpDbFull.BackupSetName = database.ToUpper() + " database Backup";
bkpDbFull.BackupSetDescription = database.ToUpper() + " database - Full Backup";
// You can specify the expiration date for your backup data
//after that date backup data would not be relevant
//bkpDBFull.ExpirationDate = DateTime.Today.AddDays(10);
/* You can specify Initialize = false (default) to create a new
* backup set which will be appended as last backup set on the media. You
* can specify Initialize = true to make the backup as first set on the
* medium and to overwrite any other existing backup sets if the all the
* backup sets have expired and specified backup set name matches with
* the name on the medium */
bkpDbFull.Initialize = true;//false concatena o backup
//Esses sao eventos para serem usados em modo Console.
// Wiring up events for progress monitoring
//bkpDBFull.PercentComplete += CompletionStatusInPercent;
//bkpDBFull.Complete += Backup_Completed;
return(bkpDbFull);
}
public XFrmAppConfig(AbstractUser user, AppConfigIts app, bool rebootoption = false) : this()
{
this._user = user;
this.rebootoption = rebootoption;
loadAppXml(AppConfigManager.Configuration.ConnectionConfigPath);
}
private void barBtnCancelar_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
this.AppConfig = null;
this.Dispose();
}
