/// <summary>
/// Adiciona uma nova licença ao Banco de Dados.
/// </summary>
/// <param name="user">Codigo do usuario que terá acesso a esse key.</param>
/// <param name="pluginCod">codigo do plugin que a licença fará referencia.</param>
/// <param name="serverIP">ip do servidor que essa licença será usada..</param>
/// <param name="key">string contendo a key desejada!</param>
/// <param name="global">true se a licença pode ser usada para todos os plugins.</param>
/// <returns>Retorna true se a operaçao foi um sucesso.</returns>
public async Task <bool> AdicionarAsync(uint user, uint pluginCod, string serverIP, string key, bool global)
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
try
{
await con.OpenAsync();
using (MySqlCommand add = new MySqlCommand("insert into LicencaList values (@a, @b, @c, @d, @e, @f, @g, @h)", con))
{
_ = add.Parameters.Add(new MySqlParameter("@a", user));
_ = add.Parameters.Add(new MySqlParameter("@b", global ? 0 : pluginCod));
_ = add.Parameters.Add(new MySqlParameter("@c", key));
_ = add.Parameters.Add(new MySqlParameter("@d", global));
_ = add.Parameters.Add(new MySqlParameter("@e", DateTime.Now.ToString("yyyy-MM-dd")));
_ = add.Parameters.Add(new MySqlParameter("@f", DateTime.Now.ToString("HH:mm:ss")));
_ = add.Parameters.Add(new MySqlParameter("@g", false));
_ = add.Parameters.Add(new MySqlParameter("@h", serverIP));
_ = await add.ExecuteNonQueryAsync();
return(true);
}
}
catch (MySqlException erro)
{
MetodosConstantes.MostrarExceptions(erro);
return(false);
}
}
}
private async Task <List <string> > PegarVazio()
{
try
{
using (var con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
await con.OpenAsync();
using (var get = new MySqlCommand("select LicencaKey from LicencaList", con))
{
using (var reader = (MySqlDataReader)await get.ExecuteReaderAsync())
{
var dados = new List <string>();
using (var data = new DataTable())
{
data.Load(reader);
foreach (DataRow row in data.Rows)
{
dados.Add(row["LicencaKey"].ToString());
}
}
return(dados);
}
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(null);
}
}
public async void BotaoAsync(string[] dados, string conexao, string tipoConexao, object nomeClass)
{
foreach (string v in dados)
{
if (tipoConexao.Equals("mysql") || tipoConexao.Equals("ftp"))
{
if (v.Equals(string.Empty))
{
continue;
}
}
if (string.IsNullOrEmpty(v))
{
MetodosConstantes.EnviarMenssagem("Voce precisa preencher todos os campos");
return;
}
}
if (tipoConexao == "mysql")
{
await((AtualizarDadosMySQL)nomeClass).AtualizarAsync(PegarInfos.NomeArquivoSQLite, dados, conexao);
}
else
{
await((AtualizarDadosFTP)nomeClass).AtualizarAsync(PegarInfos.NomeArquivoSQLite, dados, conexao);
}
MetodosConstantes.EnviarMenssagem("Dados Gravados com sucesso!");
}
/// <summary>
/// Leitura do arquivo XML que contém as informaçoes de configuraçao do software.
/// </summary>
/// <param name="nome">Nome do arquivo, por padrao está em uma propriedade em <see cref="PegarInfos.NomeArquivoXML"/></param>
/// <returns>Retorna a tarefa com uma lista contendo as informaçoes de dentro do arquivo XML.</returns>
public async Task <List <string> > LerXml(string nome)
{
List <string> infos = new List <string>();
try
{
XmlReader ler = XmlReader.Create(nome, new XmlReaderSettings()
{
Async = true
});
while (await ler.ReadAsync())
{
if (ler.NodeType == XmlNodeType.Text)
{
infos.Add(await ler.GetValueAsync());
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
}
return(infos);
}
/// <summary>
/// Atualiza os dados de conexao do ftp.
/// </summary>
/// <param name="nome">Nome do arquivo SQLite, por padrao é uma propriedade em <see cref="PegarInfos.NomeArquivoSQLite"/>.</param>
/// <param name="dados">Array contendo novos dados.</param>
/// <param name="tipo">Tipo de conexao (Local ou Externa) OBS: É binary</param>
/// <returns>Retorna a tarefa com um bool informando se a operaçao foi um sucesso.</returns>
public async Task <bool> AtualizarAsync(string nome, string[] dados, string tipo)
{
using (SQLiteConnection con = new SQLiteConnection($"data source = {nome}; Version = 3;"))
{
try
{
await con.OpenAsync();
using (SQLiteCommand add = new SQLiteCommand(CommandText, con))
{
_ = add.Parameters.Add(new SQLiteParameter("@a", dados[0]));
_ = add.Parameters.Add(new SQLiteParameter("@b", dados[1]));
_ = add.Parameters.Add(new SQLiteParameter("@c", dados[2]));
_ = add.Parameters.Add(new SQLiteParameter("@d", dados[3]));
_ = add.Parameters.Add(new SQLiteParameter("@e", tipo));
_ = await add.ExecuteNonQueryAsync();
return(true);
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
}
/// <summary>
/// Pegar a conexao do FTP ou MySQL de dentro do Arquivo SQLite.
/// </summary>
/// <param name="nome">Nome do arquivo SQLite, Por padrao é uma propriedade em <see cref="PegarInfos.NomeArquivoSQLite"/></param>
/// <param name="tipo">Tipo de conexao (Local ou Externo), por padrao é uma propriedade em <see cref="PegarInfos.ConfigFTP"/> ou <see cref="PegarInfos.ConfigMySQL"/>.</param>
/// <param name="tabela">Nome da tabela dentro do arquivo SQLite (FTP ou MySQL). OBS: nao é binary!</param>
/// <returns>Retorna uma Lista com a conexao do tipo requisitado!</returns>
public async Task <List <string> > PegarAsync(string nome, string tipo, string tabela)
{
using (SQLiteConnection con = new SQLiteConnection($"Data Source={nome};Version=3;"))
{
try
{
await con.OpenAsync();
using (SQLiteCommand pegar = new SQLiteCommand($"select * from {tabela} where tipo = @a", con))
{
_ = pegar.Parameters.Add(new SQLiteParameter("@a", tipo));
using (SQLiteDataReader ler = (SQLiteDataReader)await pegar.ExecuteReaderAsync())
{
List <string> d = new List <string>();
if (await ler.ReadAsync())
{
for (byte i = 0; i < ler.FieldCount; i++)
{
d.Add(ler.GetString(i));
}
}
return(d);
}
}
}
catch (SQLiteException e)
{
MetodosConstantes.MostrarExceptions(e);
return(null);
}
}
}
/// <summary>
/// Adiciona um novo plugin ao banco
/// </summary>
/// <param name="ID">Codigo do plugin</param>
/// <param name="dados">Lista contendo informaçoes a serem adicionadas (Nome, Autor, Versao, Tipo, Preço, Descriçao, Imagem(0, 1)) respectivamente.</param>
/// <returns></returns>
public async Task <bool> AdicionarDadosAsync(uint ID, List <string> dados)
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
try
{
await con.OpenAsync();
using (MySqlCommand add = new MySqlCommand("insert into PluginList values (@a, @b, @c, @d, @f, @g, @h, @i)", con))
{
_ = add.Parameters.Add(new MySqlParameter("@a", ID));
_ = add.Parameters.Add(new MySqlParameter("@b", dados[0]));
_ = add.Parameters.Add(new MySqlParameter("@c", dados[1]));
_ = add.Parameters.Add(new MySqlParameter("@d", dados[2]));
_ = add.Parameters.Add(new MySqlParameter("@f", dados[3]));
_ = add.Parameters.Add(new MySqlParameter("@g", dados[4]));
_ = add.Parameters.Add(new MySqlParameter("@h", dados[5]));
_ = add.Parameters.Add(new MySqlParameter("@i", dados[6]));
_ = await add.ExecuteNonQueryAsync();
return(true);
}
}
catch (MySqlException e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
}
/// <summary>
/// Atualiza informaçoes do plugin.
/// </summary>
/// <param name="pluginID">Identificador do plugin que deseja atualizar</param>
/// <param name="dados"><see cref="string[]"/> contendo informaçoes do plugin (nome, autor, versao, tipo, preço, descriçao e configImagem) respectivamente.</param>
/// <returns>Retorna a tarefa informando se foi concluido ou nao (true, false).</returns>
public async Task <bool> AtualizarAsync(string pluginID, List <string> dados)
{
try
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
await con.OpenAsync();
using (MySqlCommand att = new MySqlCommand(Atualizar, con))
{
_ = att.Parameters.Add(new MySqlParameter("@ID", pluginID));
_ = att.Parameters.Add(new MySqlParameter("@a", dados[0]));
_ = att.Parameters.Add(new MySqlParameter("@b", dados[1]));
_ = att.Parameters.Add(new MySqlParameter("@c", dados[2]));
_ = att.Parameters.Add(new MySqlParameter("@d", dados[3]));
_ = att.Parameters.Add(new MySqlParameter("@e", dados[4]));
_ = att.Parameters.Add(new MySqlParameter("@f", dados[5]));
_ = att.Parameters.Add(new MySqlParameter("@g", dados[6]));
_ = await att.ExecuteNonQueryAsync();
return(true);
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
/// <summary>
/// Remover plugin do banco de dados.
/// </summary>
/// <param name="pluginID">Codigo do plugin que dejesa apagar.</param>
/// <returns>Retorna a tarefa contendo um tupla com os retornos da consulta.</returns>
public async Task <(bool @bool, string nomePlugin, bool img)> ApagarAsync(uint pluginID)
{
try
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
await con.OpenAsync();
using (MySqlCommand rem = new MySqlCommand("select NomePlugin, ImagemPadraoPersonalizada from PluginList where ID = @a; delete from PluginList where ID = @a;", con))
{
_ = rem.Parameters.Add(new MySqlParameter("@a", pluginID));
using (MySqlDataReader dataReader = (MySqlDataReader)await rem.ExecuteReaderAsync())
{
string nome = null;
bool img = false;
if (await dataReader.ReadAsync())
{
nome = dataReader.GetString(0);
img = dataReader.GetBoolean(1);
}
return(true, nome, img);
}
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false, null, false);
}
}
/// <summary>
/// Procurar por um determinado item dentro do banco de dados
/// </summary>
/// <param name="itemProcurado">array contendo os valores dos itens a ser procurados</param>
/// <param name="tabela">Nome da tabela no banco na qual será feito a busca.</param>
/// <param name="coluna">Indexs para a busca.</param>
public async Task <bool> VerificarExisteAsync(string[] itemProcurado, string tabela, string[] coluna)
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
try
{
await con.OpenAsync();
using (MySqlCommand ver = new MySqlCommand($"select count(*) from {tabela} where {coluna[0]} = @a && {coluna[1]} = @b", con))
{
_ = ver.Parameters.Add(new MySqlParameter("@a", itemProcurado[0]));
_ = ver.Parameters.Add(new MySqlParameter("@b", itemProcurado[1]));
byte valid = byte.Parse((await ver.ExecuteScalarAsync()).ToString());
return(valid > 0);
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
}
private static async Task CriarLerXmlAsync()
{
if (await new CriandoArquivoXML().VerificarECriarAsync(PegarInfos.NomeArquivoXML))
{
//lendo dados do xml e guardando nas variaveis estaticas
await MetodosConstantes.LerXMLAsync();
}
}
private async void Acao_bts_Click(object sender, RoutedEventArgs e)
{
bool ret = ((Button)sender) == SuspenderLicenca_bt;
TrocarStyle(ret);
_ = await new LicencaInfo().SuspensoAsync(true, KeyLicencaProcurar_txt.Text, ret);
MetodosConstantes.EnviarMenssagem($"A licença ({KeyLicencaProcurar_txt.Text}) foi {(ret ? "suspensa" : "realocada")}.");
}
/// <summary>
/// Pega as informaçoes de todos plugins e guarda na propriedade <see cref="DataTable"/>
/// </summary>
/// <param name="dataGrid">se true, adiciona tabela na propriedade <see cref="DataTable"/>. senao, adiciona informaçoes de um determinado plugin na propriedade <see cref="TooltipInfo"/>.</param>
/// <param name="itemProcurarID">se dataGrid for false, deve informar o codigo do plugin para ser informado. senao, <see cref="Nullable"/></param>
/// <returns>Retorna o resultado da tarefa em bool.</returns>
public async Task <bool> InformacoesAsync(bool dataGrid, string itemProcurarID)
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
try
{
await con.OpenAsync();
using (MySqlCommand get = new MySqlCommand(CmdText2, con))
{
if (dataGrid)
{
using (MySqlDataAdapter mySqlData = new MySqlDataAdapter())
{
mySqlData.SelectCommand = get;
DataTable dataTable = new DataTable();
_ = await mySqlData.FillAsync(dataTable);
DataTable = dataTable;
NomeColunas();
using (MySqlCommand num = new MySqlCommand(CmdText3, con))
{
MetodosConstantes.EnviarMenssagem(@var.Parse((await num.ExecuteScalarAsync()).ToString()) + " Plugins encontrados!");
}
return(true);
}
}
else
{
TooltipInfo = new List <string>();
get.CommandText = $"{CmdText2} where ID = @ID";
_ = get.Parameters.Add(new MySqlParameter("@ID", itemProcurarID));
using (MySqlDataReader a = (MySqlDataReader)await get.ExecuteReaderAsync())
{
if (await a.ReadAsync())
{
for (byte i = 1; i <= 4; i++)
{
TooltipInfo.Add(a.GetString(i));
}
}
return(true);
}
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
}
private async Task AdicioarLicAsync(bool keyGlobal, uint pluginID, uint userID)
{
if (await MessageBoxResult(keyGlobal, pluginID, userID))
{
if (await new LicencaInfo().AdicionarAsync(userID, pluginID, ServidorIP_txt.Text, LicencaGerada_txt.Text, keyGlobal))
{
MetodosConstantes.EnviarMenssagem("Licença adicionada com sucesso!");
}
}
}
private async void AdicionarLicenca_bt_Click(object sender, RoutedEventArgs e)
{
try
{
await VerificarEAdicionarAsync();
}
catch (Exception erro)
{
MetodosConstantes.MostrarExceptions(erro);
}
}
public static async void EnviarMensagemDialogHostAsync(string msg)
{
try
{
_ = await DialogHost.Show(new DialogHostSimples { Mensagem_txt = { Text = msg } }, "RootDialog");
}
catch
{
MetodosConstantes.EnviarMenssagem("Ouve um problema na inicializaçao");
}
}
private async void MarcarClicadoAsync(string tipoEnvio, string tipoBanco, List <MenuItem> items, object sender)
{
foreach (MenuItem item in items)
{
item.IsChecked = item == (MenuItem)sender;
}
new AtualizandoDadosXML().AtualizarAsync(PegarInfos.NomeArquivoXML, tipoEnvio, tipoBanco);
await MetodosConstantes.LerXMLAsync();
MetodosConstantes.EnviarMenssagem($"{tipoEnvio} alterado para {tipoBanco}");
}
private async void ProcurarPlugin_bt_Click(object sender, RoutedEventArgs e)
{
if (PossuiLetras(CodigoPlugin_txt.Text))
{
MetodosConstantes.EnviarMenssagem("Voce deve informar apenas o ID do plugin.");
InformacoesPlugin_wp.Visibility = Visibility.Collapsed;
return;
}
if (!string.IsNullOrEmpty(CodigoPlugin_txt.Text))
{
PluginInfo pl = new PluginInfo();
if (await pl.InformacoesAsync(CodigoPlugin_txt.Text, false))
{
InformacoesPlugin_wp.Visibility = Visibility.Visible;
DataTable a = pl.DataTable;
if (Convert.ToBoolean(a.Rows[0][7]).Equals(true))
{
ImagemPlugin_img.Source = await new BaixarImagem().BaixarAsync(CodigoPlugin_txt.Text);
UsarImg_cb.IsChecked = true;
EscolherNovaImagem_cb.Visibility = Visibility.Visible;
EscolherNovaImagem_cb.IsChecked = false;
}
else
{
ImagemPlugin_img.Source = null;
UsarImg_cb.IsChecked = false;
EscolherNovaImagem_cb.Visibility = Visibility.Collapsed;
EscolherNovaImagem_cb.IsChecked = false;
}
NomeDoPlugin_txt.Text = a.Rows[0][1].ToString();
AutorDoPlugin_txt.Text = a.Rows[0][2].ToString();
VersaoDoPlugin_txt.Text = a.Rows[0][3].ToString();
if (a.Rows[0][4].ToString() == "Pago")
{
TipoDoPlugin_gb.SelectedIndex = 1;
PrecoDoPlugin_txt.Text = a.Rows[0][5].ToString();
}
else
{
TipoDoPlugin_gb.SelectedIndex = 0;
}
DescricaoDoPlugin_txt.Text = a.Rows[0][6].ToString();
}
else
{
MetodosConstantes.EnviarMenssagem("Plugin nao existe!");
InformacoesPlugin_wp.Visibility = Visibility.Collapsed;
}
}
}
//mover a tela
private void Grid_MouseDown(object sender, MouseButtonEventArgs e)
{
try
{
//se nao fizer essa verificaçao, irá ocorrer um erro caso aperte o botao direito do mouse
//verifico se o botao que foi clicado é o esquerdo, e se isto for verdadeiro, entra no if
if (e.LeftButton == MouseButtonState.Pressed)
{
//se clicar duas vezes em cima do grid, mudará para Maximizado
//MouseDoubleClick += TelaInicial_MouseDoubleClick;
//se a janela estiver maximizada, é preciso colocar no estado normal, para entao poder mover.
if (WindowState == WindowState.Maximized)
{
//setando o estado da jenela para o normal
WindowState = WindowState.Normal;
//setando a posiçao da janela em relaçao ao topo como 0
Top = 0;
//desativando o topMost para evitar bugs
Topmost = false;
}
//com esse metodo, é possivel arrastar a janela na qual está o objeto, no caso, eu coloquei esse para quando ele disparar o evento mouseDown(clicou em cima) no grid do topo (que contem os botoes de fechar, minimizar...etc).
DragMove();
}
else
{
//se a propriedade TopMost (sempre na frente) estiver ativa, a mesma é desativada
if (Topmost)
{
Topmost = false;
MetodosConstantes.EnviarMenssagem("Nao está mais fixado");
}
else
{
//senao, eh preciso verificar se o estado atual da janela é maximizado, ja que se eu tentar ficar uma janela sendo que ela esta maximizada nao tem sentido
if (WindowState != WindowState.Maximized)
{
Topmost = true;
MetodosConstantes.EnviarMenssagem("Agora está fixado");
}
else
{
MetodosConstantes.EnviarMenssagem("Voce nao pode fazer isto com a janela maximizada!");
}
}
}
}
//isso nao é necessario, pois ele so entrará no if, se ele apertar o botao esquerdo, e como ele so dispara a exception se eu clicar em outro botao...isso é irrelevante!
catch (InvalidOperationException erro)
{
MetodosConstantes.MostrarExceptions(erro);
}
}
private void Atualizar(string itemParaAlterar, string novoValor, XPathNavigator pathV)
{
try
{
foreach (XPathNavigator item in pathV.SelectDescendants("Config", string.Empty, false))
{
item.SelectSingleNode(itemParaAlterar).SetValue(novoValor);
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
}
}
private async Task <bool> CriarArquivo(string nome)
{
using (XmlWriter doc = XmlWriter.Create(nome, Configuracao()))
{
try
{
return(await InserirDadosArquivoAsync(doc));
}
catch (Exception erro)
{
MetodosConstantes.MostrarExceptions(erro);
return(false);
}
}
}
/// <summary>
/// Atualiza o valor de determinado nó dentro do arquivo.
/// </summary>
/// <param name="nome">Nome do arquivo XML, por padrao é uma propriedade em <see cref="PegarInfos.NomeArquivoXML"/>.</param>
/// <param name="itemParaAlterar">Nome do nó que deseja alterar o valor.</param>
/// <param name="novoValor">Novo valor que será atribuido ao nó.</param>
public async void AtualizarAsync(string nome, string itemParaAlterar, string novoValor)
{
if (!File.Exists(nome))
{
_ = await new CriandoArquivoXML().VerificarECriarAsync(nome);
}
try
{
XmlDocument doc = new XmlDocument();
CarregarEAtualizar(nome, itemParaAlterar, novoValor, doc);
}
catch (Exception erro)
{
MetodosConstantes.MostrarExceptions(erro);
}
}
/// <summary>
/// Pega informaçoes de um determinado plugin e guarda na propriedade <see cref="DataTable"/>.
/// </summary>
/// <param name="itemProcurar">Index (ID ou Nome do plugin) do plugin que deseja as informaçoes.</param>
/// <param name="messageReturn">true, se deseja informar informar a mensagem no canto da tela mostrando a quantidade de resultados encontrados.</param>
/// <returns>Retorna o resultado da tarefa em bool.</returns>
public async Task <bool> InformacoesAsync(string itemProcurar, bool messageReturn)
{
using (MySqlConnection con = new MySqlConnection(await PegarConexaoMySQL.ConexaoAsync()))
{
try
{
await con.OpenAsync();
using (MySqlCommand get = new MySqlCommand(CmdText, con))
{
_ = get.Parameters.Add(new MySqlParameter("@a", "%" + itemProcurar + "%"));
using (MySqlDataAdapter mySqlData = new MySqlDataAdapter())
{
mySqlData.SelectCommand = get;
DataTable dataTable = new DataTable();
_ = await mySqlData.FillAsync(dataTable);
DataTable = dataTable;
NomeColunas();
using (MySqlCommand num = new MySqlCommand(CmdText1, con))
{
_ = num.Parameters.Add(new MySqlParameter("@a", "%" + itemProcurar + "%"));
string qtd = (await num.ExecuteScalarAsync()).ToString();
if (qtd == "0")
{
return(false);
}
if (messageReturn)
{
MetodosConstantes.EnviarMenssagem(@var.Parse(qtd) + " Plugins encontrados!");
}
}
return(true);
}
}
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
}
public static async Task <bool> EscolhaDialogHostAsync(string msg)
{
try
{
DialogHostEscolha esc = new DialogHostEscolha {
Mensagem_txt = { Text = msg }
};
_ = await DialogHost.Show(esc, "RootDialog");
return(esc.clicouAceitar);
}
catch
{
MetodosConstantes.EnviarMenssagem("Erro ao escolher uma opçao");
return(false);
}
}
private async void GravarAsync(string nomeXml, string valor)
{
try
{
//adicionando novo valor a taxa de transferencia
new AtualizandoDadosXML().AtualizarAsync(PegarInfos.NomeArquivoXML, nomeXml, valor);
//atualizando variaveis
await MetodosConstantes.LerXMLAsync();
//mostrando que foi enviado
MetodosConstantes.EnviarMenssagem("Dados gravados com sucesso!");
}
catch (Exception erro)
{
MetodosConstantes.MostrarExceptions(erro);
}
}
private async void Card_MouseDown(object sender, MouseButtonEventArgs e)
{
//pegando a key da licenda dentro header do expander.
string lic = (((((Card)sender).Content as Expander).Header as StackPanel).Children[1] as TextBlock).Text;
//fazendo uma verificaçao antes de exluir a licença
if (await TelaInicial.EscolhaDialogHostAsync($"Realmente quer excluir essa licença?\n{lic}"))
{
//excluindo a licença do banco, e verificando o retorno da tarefa
if (await new LicencaInfo().ApagarAsync(lic))
{
//removendo o card da tela
ListaLicencas_sp.Children.Remove((Card)sender);
//enviando a mensagem de sucesso!.
MetodosConstantes.EnviarMenssagem($"{lic} foi removida!");
}
}
}
private async void MudarTema_Click(object sender, RoutedEventArgs e)
{
//verificando se "quem" disparou o evento foi o menuItem do Light ou do Dark e guardando resultado em uma var
bool result = (MenuItem)sender == Light_mi;
//guardando string referente a "quem" disparou o evento
string cor = result ? "Light" : "Dark";
//mudando o estado (Checked) de acordo com o resultado da comparaçao acima
Light_mi.IsChecked = result;
Dark_mi.IsChecked = !result;
//setando tema, lembrando que este metodo recebe TRUE como o dark, e como a comparaçao é com o light eu neguei o result
new PaletteHelper().SetLightDark(!result);
//atualizando
new AtualizandoDadosXML().AtualizarAsync(PegarInfos.NomeArquivoXML, "Tema", cor);
await MetodosConstantes.LerXMLAsync();
MetodosConstantes.EnviarMenssagem($"Tema do programa alterado para {cor}");
}
/// <summary>
/// Abre um explorer para procurar um plugin.
/// </summary>
/// <returns>Retorna uma tupla contento o path do plugin selecionadioe e o nome do proprio plugin.</returns>
public (string, string) ProcurarPlugin()
{
OpenFileDialog pluginProcurar = new OpenFileDialog
{
Title = "Procurar Plugin de Minerafiti",
Filter = "JAR Files (*.jar)|*.jar"
};
if (pluginProcurar.ShowDialog() == true)
{
if (new FileInfo(pluginProcurar.FileName).Length / 1024 > PegarInfos.TamanhoLimitePluginImg)
{
MetodosConstantes.EnviarMenssagem($"Seu plugin possui mais que o tamanho permitido ({Math.Round(PegarInfos.TamanhoLimitePluginImg / 1024.0, 2)}MiB)");
return(null, null);
}
return(pluginProcurar.FileName, Path.GetFileNameWithoutExtension(pluginProcurar.FileName));
}
return(null, null);
}
/// <summary>
/// Remove arquivo do servidor pelo protocolo FTP.
/// </summary>
/// <param name="tipo">tipo do arquivo (Plugin ou Images), exatamente desta forma com exceçao do PascalCase!</param>
/// <param name="ftpArquivo">Nome do arquivo a ser deletado incluindo a extensao.</param>
/// <param name="conexaoFTP">Credenciais para conexao com FTP (host, porta, login, senha) respectivamente.</param>
public async Task <bool> DeletarAsync(string tipo, string ftpArquivo, List <string> conexaoFTP)
{
try
{
FtpWebRequest delete = Iniando(tipo, ftpArquivo, conexaoFTP);
DadosDelete(conexaoFTP, delete);
//obtendo resposta da requisiçao de forma assincrona
FtpWebResponse ftpWebResponse = (FtpWebResponse)await delete.GetResponseAsync();
//liberando os recursos da requisiçao
ftpWebResponse.Close();
return(true);
}
catch (Exception e)
{
MetodosConstantes.MostrarExceptions(e);
return(false);
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
if (await TelaInicial.EscolhaDialogHostAsync("Voce tem certeza que deseja limpar todos os campos?"))
{
_caminhoImagem = null;
ImagemPlugin_img.Source = null;
ExcluirArquivo_bt.IsEnabled = false;
ProcurarArquivo_bt.IsEnabled = true;
CaminhoArquivo_txt.Clear();
NomeDoPlugin_txt.Clear();
VersaoDoPlugin_txt.Clear();
TipoDoPlugin_gb.SelectedIndex = -1;
PrecoDoPlugin_txt.Clear();
PrecoDoPlugin_txt.IsEnabled = false;
AutorDoPlugin_txt.Clear();
DescricaoDoPlugin_txt.Clear();
MetodosConstantes.EnviarMenssagem("Os campos foram limpos!");
}
}
