예제 #1
0
            /// <summary>
            /// Retornar informação do usuário
            /// </summary>
            /// <param name="columnName">Coluna do valor desejado</param>
            /// <returns></returns>
            public static string AdquireInfo(string columnName)
            {
                try
                {
                    // Verifica se a informação requisitada é o valor da carteira do usuário
                    if (columnName == "USERWALLET")
                    {
                        /*
                         *  // Criar protocolo de dados
                         *  var dados = new NameValueCollection
                         *  {
                         *      ["u"] = Username, // Nome do usuário
                         *      ["sid"] = SessionID, // Código de sessão IwPlay
                         *      ["command"] = "GET" // Comando para ADQUIRIR dados
                         *  };
                         *
                         *  // Encaminhar e receber respostas
                         *  var resp = _PostClient.POST("/users/users.wallet", dados);
                         *  string upl_resp = Encoding.UTF8.GetString(resp);
                         *
                         *  // Retornar valor recebido
                         *  return upl_resp;
                         */
                        // Criar dados para envio

                        // Criar protocolo de dados
                        var dados = new Dictionary <string, string>
                        {
                            ["u"]       = Username,              // Nome do usuário
                            ["sid"]     = SessionID,             // Código de sessão IwPlay
                            ["command"] = Hashing.Encrypt("GET") // Comando para ADQUIRIR dados
                        };

                        return(Hashing.Decrypt(_PostClient.RESTPOST("/users/users.wallet", dados)));
                    }
                    else
                    {
                        /*
                         * // Criar protocolo de dados
                         * var dados = new NameValueCollection
                         * {
                         *  ["u"] = Username, // Nome do usuário
                         *  ["c"] = columnName, // Coluna requisitada
                         *  ["sid"] = SessionID // Código da sessão IwPlay
                         * };
                         * // Encaminhar e receber respostas
                         * var upl = _PostClient.POST("/users/users.check", dados);
                         * return Encoding.UTF8.GetString(upl);
                         */

                        // Criar protocolo de dados
                        var dados = new Dictionary <string, string>
                        {
                            ["u"]   = Username,                   // Nome do usuário
                            ["sid"] = SessionID,                  // Código de sessão IwPlay
                            ["c"]   = Hashing.Encrypt(columnName) // Coluna requisitada
                        };

                        string ret = _PostClient.RESTPOST("/users/users.check", dados);

                        return(Hashing.Decrypt(ret));
                    }
                }
                catch (Exception ex)
                {
                    // Log file
                    LogClient.Log(ex.Message + "\n" + ex.StackTrace + "\n" + ex.InnerException);

                    // Retornar nulo, coluna incorreta e/ou inexistente
                    return("iw_false");
                }
                finally
                {
                    // Coletar garbage
                    GC.Collect();
                }
            }
예제 #2
0
            /// <summary>
            /// Tentar logar o usuário utilizando os parâmetros fornecidos
            /// </summary>
            /// <param name="username">Nome de usuário</param>
            /// <param name="password">Senha de usuário</param>
            /// <returns></returns>
            public static RetCodes LoginUser(string username, string password)
            {
                try
                {
                    // Criar aleatoriedade de palavras
                    Random       random = new Random();
                    const string chars  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

                    // Criar session ID
                    UserInfo.SessionID = new string(Enumerable.Repeat(chars, 15)
                                                    .Select(s => s[random.Next(s.Length)]).ToArray());

                    /*
                     * // Criar dados para serem enviados
                     * var dados = new NameValueCollection
                     * {
                     *  ["u"] = username, // Nome do usuário
                     *  ["p"] = password, // Senha do usuário
                     *  ["sid"] = UserInfo.SessionID, // Sessão criada para a utilização da IwPlay
                     *  ["i"] = UserInfo.Userdata // Dados de localização do usuário
                     * };
                     *
                     * // Encaminhar dados e retornar resposta
                     * var upl = _PostClient.POST("/users/users.verify", dados);
                     * string ret = Encoding.UTF8.GetString(upl);
                     */

                    // Criar dados para envio
                    var data = new Dictionary <string, string>
                    {
                        ["u"]   = username,                  // Nome do usuário
                        ["p"]   = Hashing.Encrypt(password), // Senha do usuário
                        ["sid"] = UserInfo.SessionID,        // Sessão criada para a utilização da IwPlay
                        ["i"]   = UserInfo.Userdata          // Dados de localização do usuário
                    };

                    // Adquirir retorno
                    string ret = Hashing.Decrypt(_PostClient.RESTPOST("/users/users.verify", data));

                    // Separar códigos de retorno
                    switch (ret)
                    {
                    // Geralmente outro erro!
                    default:
                        // Criar log de retorno
                        LogClient.Log("*RET.ERROR*\n\n" + ret);
                        return(RetCodes.ERROR);

                    case "BANNED":
                        // Usuário banido!
                        return(RetCodes.BANNED);

                    case "NO SUCH USER":
                        // Usuário não encontrado!
                        return(RetCodes.NSU);

                    case "VALIDATION":
                        // Usuário não validou o e-mail de criação!
                        return(RetCodes.VALIDATION);

                    case "INCORRECT PASSWORD":
                        // Senha incorreta!
                        return(RetCodes.PASSWORD);

                    // Login correto!
                    case "OK":
                        // Inserir nome de usuário
                        UserInfo.Username = username;
                        // Inserir e-mail do usuário
                        UserInfo.Usermail = UserInfo.AdquireInfo("USERMAIL");
                        return(RetCodes.SUCCESS);
                    }
                }
                catch (Exception ex)
                {
                    // Log file
                    LogClient.Log(ex.Message);

                    // Retornar false, login incorreto
                    return(RetCodes.ERROR);
                }
                finally
                {
                    // Coletar garbage
                    GC.Collect();
                }
            }
예제 #3
0
            /// <summary>
            /// Tentar criar um novo usuário utilizando os parâmetros fornecidos
            /// </summary>
            /// <param name="username">Nome do usuário</param>
            /// <param name="password">Senha do usuário</param>
            /// <param name="email">E-mail do usuário</param>
            /// <returns></returns>
            public static RetCodes CreateUser(string username, string password, string email)
            {
                try
                {
                    /*
                     * // Criar dados para envio
                     * var dados = new NameValueCollection
                     * {
                     *  ["u"] = username,
                     *  ["p"] = password,
                     *  ["e"] = email
                     * };
                     * // Enviar dados
                     * var upl = _PostClient.POST("/users/users.create", dados);
                     *
                     * // Criar string de retorno
                     * string ret = Encoding.UTF8.GetString(upl);
                     */

                    // Criar dados para envio
                    var data = new Dictionary <string, string>
                    {
                        ["u"] = username,
                        ["p"] = Hashing.Encrypt(password),
                        ["e"] = email
                    };

                    // Enviar dados
                    string ret = Hashing.Decrypt(_PostClient.RESTPOST("/users/users.create", data));

                    // Separar códigos de retorno
                    switch (ret)
                    {
                    default:
                        // Criar log
                        LogClient.Log(ret);
                        // Erro de servidor não catalogado
                        return(RetCodes.ERROR);

                    case "NO MAIL":
                        // Erro ao enviar e-mail
                        return(RetCodes.ERROR_SENDMAIL);

                    case "NOK_USER":
                        // Erro ao criar usuário
                        return(RetCodes.ERROR_CREATEQUERY);

                    case "ALREADY MAIL":
                        // Já existe um e-mail, parça!
                        return(RetCodes.ALREADY_MAIL);

                    case "ALREADY USER":
                        // Já existe um usuário, parça!
                        return(RetCodes.ALREADY_USER);

                    // Login correto!
                    case "OK":
                        return(RetCodes.SUCCESS);
                    }
                }
                catch (Exception ex)
                {
                    // Log file
                    LogClient.Log(ex.Message);

                    // Erro de servidor não catalogado
                    return(RetCodes.ERROR);
                }
                finally
                {
                    // Coletar garbage
                    GC.Collect();
                }
            }
예제 #4
0
        /// <summary>
        /// Criar arquivo de configuração do jogo
        /// </summary>
        /// <param name="GameTitle">Nome do Jogo</param>
        /// <param name="GameDeveloper">Desenvolvedor do Jogo</param>
        /// <param name="GameId">ID do Jogo</param>
        public static bool InsertNewGame(GameInformation Game)
        {
            // Verificar se já existe um arquivo de configurações do jogo
            if (File.Exists(Path.Combine(Directories.TempGameFilesSetup(Game.ID), "tmpFile.IwGX")))
            {
                // Exibe mensagem de confirmação
                IwP_CustomMessage IPCM = new IwP_CustomMessage()
                {
                    _Title        = "CFG OVERWRITE",
                    _Description  = "An game config already exists!\nDo you want to overwrite it?",
                    ButtonMessage = "OVERWRITE",
                    CallFor       = null
                };

                // Verifica se o usuário clicou em Overwrite
                if (IPCM.ShowDialog() != DialogResult.OK)
                {
                    return(false);
                }
            }

            // Exibir pasta de arquivo
            FolderBrowserDialog FolderBrowser = new FolderBrowserDialog();

            FolderBrowser.Description         = "Select your game files folder";
            FolderBrowser.ShowNewFolderButton = false;

            // Caso o usuário selecione a pasta, criar os arquivos
            if (FolderBrowser.ShowDialog() == DialogResult.OK)
            {
                // Lista para handler de arquivos
                List <string> Files = new List <string>();

                // Criar e zipar arquivos
                ZipFile.CreateFromDirectory(FolderBrowser.SelectedPath, Path.Combine(Directories.TempGameFilesSetup(Game.ID), "tmpFile.IwGX"), CompressionLevel.NoCompression, false,
                                            Encoding.UTF8);

                // Abrir arquivo para leitura
                ZipArchive zippedFile = ZipFile.OpenRead(Path.Combine(Directories.TempGameFilesSetup(Game.ID), "tmpFile.IwGX"));

                // Percorrer arquivos dentro do ZIP
                foreach (var z in zippedFile.Entries)
                {
                    // Adicionar nome do arquivo à lista
                    Files.Add(z.FullName);
                }

                // Sair da instância aberta do ZIP
                zippedFile.Dispose();

                // Converter lista em JSON
                string FJS = JsonSerializer.Serialize(Files);

                // Criar detalhes do jogo
                var Details = new Dictionary <string, string>
                {
                    ["AppTitle"]     = Game.Name,
                    ["AppDeveloper"] = Game.Developer,
                    ["AppId"]        = Game.ID,
                    ["AppImage"]     = Game.Image,
                    ["Files"]        = FJS
                };

                // Converter em JSON
                string DetailsJS = JsonSerializer.Serialize(Details);

                // Tentar inserir o jogo na base de dados
                try
                {
                    // Criar dados de postagem

                    // Postar no servidor

                    // Verificar retorno
                    if (Hashing.Decrypt(new PostClient().RESTPOST("/games/games.branch", new Dictionary <string, string>
                    {
                        ["sid"] = IwP_Main_Database.UserInfo.SessionID,
                        ["gamecode"] = Game.ID,
                        ["username"] = IwP_Main_Database.UserInfo.Username,
                        ["company"] = Game.Developer,
                        ["setup"] = DetailsJS,
                        ["query"] = Hashing.Encrypt("INSERT")
                    })) == "INS_OK")
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
                catch (Exception ex)
                {
                    // Log file
                    LogClient.Log(ex.Message);

                    // Retornar falso por padrão
                    return(false);
                }
                finally
                {
                    // Verificar se pasta temporária do jogo existe
                    if (Directory.Exists(Directories.TempGameFilesSetup(Game.ID)))
                    {
                        Directory.Delete(Directories.TempGameFilesSetup(Game.ID), true);
                    }
                }
            }

            // Retornar falso por padrão
            return(false);
        }