public override void Salvar(ValueObject.BaseVO baseVO)
 {
     Query = "insert into SJ_CIDADE values(sq_cidade.nextval, :descricao, :id_estado)";
     AdicionarParametroSQL(":descricao", baseVO.Campo("descricao").Valor);
     AdicionarParametroSQL(":id_estado", baseVO.Campo("id_estado").Valor);
     base.Salvar(baseVO);
 }

 public void IsNullOrEmpty_bool_evaluates_false()
 {
     var systemUnderTest = new ValueObject(true);
     Assert.IsFalse(systemUnderTest.IsNullOrEmpty, "IsNullOrEmpty should evaluate to false when ValueObject wraps a bool.");
     systemUnderTest = new ValueObject(false);
     Assert.IsFalse(systemUnderTest.IsNullOrEmpty, "IsNullOrEmpty should evaluate to false when ValueObject wraps a bool.");
 }

 public override List<string> ObterLista(ValueObject.BaseVO baseVO)
 {
     FieldToDataReader = "Perfis";
     Query = "select p.descricao \"" + FieldToDataReader + "\" from sj_usuario_grupo_perfil ugp join sj_perfil p "
           + "on (p.id_perfil = ugp.id_perfil) where ugp.id_usuario = " + baseVO.Campo("id_usuario").Valor.ToString();
     return base.ObterLista();
 }

 public override void Salvar(ValueObject.BaseVO baseVO)
 {
     Query = "insert into SJ_COMPETICAO_ANO values (sq_competicao_ano.nextval, :id_ano, :id_competicao)";
     AdicionarParametroSQL(":id_ano", baseVO.Campo("id_ano").Valor);
     AdicionarParametroSQL(":id_competicao", baseVO.Campo("id_competicao").Valor);
     base.Salvar();
 }

 public override void Salvar(ValueObject.BaseVO baseVO)
 {
     Query = "insert into SJ_PALPITE values (sq_palpite.nextval, :id_usuario_grupo_perfil, :id_time_jogo, :gol)";
     AdicionarParametroSQL(":id_usuario_grupo_perfil", baseVO.Campo("id_usuario_grupo_perfil").Valor);
     AdicionarParametroSQL(":id_time_jogo", baseVO.Campo("id_time_jogo").Valor);
     AdicionarParametroSQL(":gol", baseVO.Campo("gol").Valor);
     base.Salvar();
 }

 public override BaseVO ObterDadosVOPorCampo(String campo, ValueObject.BaseVO baseVO, Boolean buscaExata = true)
 {
     NomeTabelaCliente = baseVO.NomeTabela;
     Query = buscaExata ? "SELECT * FROM SJ_USUARIO WHERE " + campo + " = :valor" :
                          "SELECT * FROM SJ_USUARIO WHERE " + campo + " like %" + baseVO.Campo("login").Valor;
     if (buscaExata) { AdicionarParametroSQL(":valor", baseVO.Campo("login").Valor.ToString()); }
     return base.ObterPorFiltro();
 }

 public override void Salvar(ValueObject.BaseVO baseVO)
 {
     Query = "insert into SJ_USUARIO_GRUPO_PERFIL values (sq_usuario_grupo_perfil.nextval, :id_usuario, :id_grupo, :id_perfil, :pontos)";
     AdicionarParametroSQL(":id_usuario", baseVO.Campo("id_usuario").Valor);
     AdicionarParametroSQL(":id_grupo", baseVO.Campo("id_grupo").Valor);
     AdicionarParametroSQL(":id_perfil", baseVO.Campo("id_perfil").Valor);
     AdicionarParametroSQL(":pontos", 0);
     base.Salvar(baseVO);
 }

 public override void Salvar(ValueObject.BaseVO baseVO)
 {
     Query = "insert into SJ_COMPETICAO_ANO_TIME values (sq_competicao_ano_time.nextval, "
                                                      + ":id_time, "
                                                      + ":id_competicao_ano, "
                                                      + ":pontos)";
     AdicionarParametroSQL(":id_time", baseVO.Campo("id_time").Valor);
     AdicionarParametroSQL(":id_competicao_ano", baseVO.Campo("id_competicao_ano").Valor);
     AdicionarParametroSQL(":pontos", baseVO.Campo("pontos").Valor);
     base.Salvar(baseVO);
 }

        public void IsolatedTemplateService_CannotParseSimpleTemplate_WithDynamicModel()
        {
            using (var service = new IsolatedTemplateService())
            {
                const string template = "<h1>Animal Type: @Model.Type</h1>";

                Assert.Throws<ArgumentException>(() =>
                {
                    dynamic model = new ValueObject(new Dictionary<string, object> { { "Type", "Cat" } });
                    service.Parse(template, model, null, null);
                });
            }
        }

        internal RegDiff(RegistryComparison Source, RegistryComparison.Side Side)
            : this()
        {
            var origin = Source.Output;

            foreach (var data in origin)
            {
                int tmpIndex = data.Key.IndexOf("::");
                string path = data.Key.Substring(0, tmpIndex);
                string name = data.Key.Substring(tmpIndex + 2);

                if (!data.Value.Same)
                    if (Side == RegistryComparison.Side.A &&
                        !(data.Value.TypeA == RegistryValueType.None && data.Value.ValueA == null))
                        Data[path][name] = new ValueObject(data.Value.TypeA, data.Value.ValueA);
                    else if (!(data.Value.TypeB == RegistryValueType.None && data.Value.ValueB == null)) // Side == B
                        Data[path][name] = new ValueObject(data.Value.TypeB, data.Value.ValueB);
            }
        }

        public override void Salvar(ValueObject.BaseVO baseVO)
        {
            if (baseVO.Campo("id_competicao_ano_rodada").Valor.ToString().Trim() != String.Empty)
            {
                Query = "update SJ_COMPETICAO_ANO_RODADA set realizada = :realizada where id_competicao_ano_rodada = :id_competicao_ano_rodada";
                AdicionarParametroSQL(":id_competicao_ano_rodada", baseVO.Campo("id_competicao_ano_rodada").Valor);
                AdicionarParametroSQL(":realizada", baseVO.Campo("realizada").Valor);
            }
            else
            {
                Query = "insert into SJ_COMPETICAO_ANO_RODADA values (sq_competicao_ano_rodada.nextval, "
                                                                   + ":id_competicao_ano, "
                                                                   + ":id_rodada,"
                                                                   + ":realizada)";

                AdicionarParametroSQL(":id_competicao_ano", baseVO.Campo("id_competicao_ano").Valor);
                AdicionarParametroSQL(":id_rodada", baseVO.Campo("id_rodada").Valor);
                AdicionarParametroSQL(":realizada", baseVO.Campo("realizada").Valor);
            }
            base.Salvar(baseVO);
        }

    public void GUIStartServer(ValueObject serverObj)
    {
        Debug.Log("Made it to Unity");

        /*
        foreach(var item in serverObj.Values)
        {
            Debug.Log((string)item);
        }
        */

        try {
            int maxPlayers = 8;
            int.TryParse((string)serverObj["max_players"], out maxPlayers);

            this.netMan.StartServer(
                (string)serverObj["server_name"],
                (string)serverObj["lan"] == "true" ? true : false,
                (string)serverObj["server_pw"],
                maxPlayers,
                (string)serverObj["server_description"],
                (string)serverObj["server_map"],
                (string)serverObj["server_gametype"]
            );

            // Set the game time limit
            if(this.gameManager != null)
            {
                float timeLimit = -1; // Infinite
                float.TryParse((string)serverObj.GetValueOrDefault("time_limit", new Value("-1")), out timeLimit);
                this.gameManager.GameTimeLimit = timeLimit;
            }

        } catch(InvalidValueCastException e) {
            Debug.LogWarning("Cast exception while trying to start a server: " + e);
        }
    }

 public List<string> ObterDadosPorCampo(string campo, ValueObject.BaseVO baseVO, bool buscaExata = true)
 {
     throw new NotImplementedException();
 }

 public void Incluir(ValueObject.BaseVO baseVO)
 {
     throw new NotImplementedException();
 }

 public bool ExisteRegistro(string campo_pesquisa, ValueObject.BaseVO baseVO)
 {
     throw new NotImplementedException();
 }

 public ValueObject.BaseVO ObterPorFiltro(ValueObject.BaseVO baseVO)
 {
     throw new NotImplementedException();
 }

 public List<ValueObject.BaseVO> ObterListaVO(ValueObject.BaseVO baseVO)
 {
     throw new NotImplementedException();
 }

 public bool ExisteRegistro(string campo, string campo_pesquisa, ValueObject.BaseVO baseVO)
 {
     return new AnoDAO().ExisteRegistro(campo, campo_pesquisa, baseVO);
 }

 public List<string> ObterListaJoin(ValueObject.BaseVO baseVO)
 {
     throw new NotImplementedException();
 }

 public override List<ValueObject.BaseVO> ObterListaVO(ValueObject.BaseVO baseVO)
 {
     if (baseVO == null)
         Query = "select * from SJ_COMPETICAO_ANO_RODADA order by id_rodada ASC";
     return base.ObterListaVO();
 }