/// <summary>
/// Metodo para crear un grupo.
/// </summary>
/// <param name="grupo">Informacion sobre el grupo a ser insertado</param>
/// <param name="usuario">ID del usuario al cual pertenecera el grupo(Antes llamado categoria)</param>
/// <returns></returns>
public static int CrearGrupo(Grupo grupo, string usuario)
{
string query = "INSERT INTO grupo (Nombre,Color,UsuarioID) VALUES (@nombre,@color,@usuario); SELECT CAST(scope_identity() AS int);";
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["connectionStringBD"].ConnectionString))
{
sqlConnection.Open();
using (SqlTransaction sqlTransaction = sqlConnection.BeginTransaction())
{
try
{
using (SqlCommand sqlCommand = new SqlCommand(query, sqlConnection))
{
sqlCommand.Transaction = sqlTransaction;
sqlCommand.Parameters.AddWithValue("@nombre", grupo.Nombre);
sqlCommand.Parameters.AddWithValue("@color", grupo.Color);
sqlCommand.Parameters.AddWithValue("@usuario", usuario);
int valor = (int)sqlCommand.ExecuteScalar();
sqlTransaction.Commit();
return valor;
}
}
catch (Exception)
{
sqlTransaction.Rollback();
throw;
}
}
}
return -1;
}
public bool updateGrupo(Grupo grupo)
{
try
{
Utilitarios.Conexion.openConnection();
command = new SqlCommand("proc_Grupos_Update", Utilitarios.Conexion.returnConnection());
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.AddWithValue("@gru_codigo", grupo.Codigo);
command.Parameters.AddWithValue("@gru_cupos", grupo.Cupos);
command.Parameters.AddWithValue("@gru_nombre", grupo.Nombre);
command.Parameters.AddWithValue("@curso_codigo", grupo.CursoCodigo);
command.Parameters.AddWithValue("@per_codigo", grupo.PeriodoCodigo);
command.Parameters.AddWithValue("@persona_usuario", grupo.Usuario);
command.Parameters.AddWithValue("@gru_subGrupos", grupo.SubGrupos);
if (command.ExecuteNonQuery() > 0)
{
Utilitarios.Conexion.closeConnection();
return true;
}
else
{
Utilitarios.Conexion.closeConnection();
return false;
}
}
catch (SqlException e) { MessageBox.Show("Error de Base de datos :" + e.Message); return false; }
}
/*
* Igual que la función anterior, pero pasándole un objeto grupo directamente
* Lo añade a la lista de grupos activos de la clase Manager
* Añade los intros/mensajes asociados al grupo a los diálogos correspondientes
*
* Los parámetros que se le pasan son la ruta del archivo
* el ID del interactuable del diálogo actual, el ID del dialogo actual, el tipo de diálogo actual y la posición del dialogo actual
*/
public static void LoadGrupo(Grupo grupo, int IDInteractuable, int IDDialogoActual, int tipoDialogo, ref int posDialogo)
{
//Se encarga de cargar los intros/mensajes iniciales para añadirlos a los diálogos correspondientes
Lanzador.LoadLanzador(Manager.rutaLanzadores + grupo.IDGrupo.ToString() + ".xml", IDInteractuable,IDDialogoActual, tipoDialogo, ref posDialogo);
Manager.instance.AddToGruposActivos(grupo);
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
/// <summary>
/// Metodo para actualizar una categoria
/// </summary>
/// <param name="grupo">Grupo con id y nueva informacion con la cual se actualizara</param>
/// <param name="usuario">Usuario al cual pertenece el grupo</param>
/// <returns></returns>
public static bool ActualizarGrupo(Grupo grupo, string usuario)
{
string query = "UPDATE Grupo SET " +
"Nombre = @nombre, " +
"Color = @color " +
"WHERE GrupoID = @grupoID AND UsuarioID = @usuario";
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["connectionStringBD"].ConnectionString))
{
sqlConnection.Open();
using (SqlTransaction sqlTransaction = sqlConnection.BeginTransaction())
{
try
{
using (SqlCommand sqlCommand = new SqlCommand(query, sqlConnection))
{
sqlCommand.Transaction = sqlTransaction;
sqlCommand.Parameters.AddWithValue("@nombre", grupo.Nombre);
sqlCommand.Parameters.AddWithValue("@color", grupo.Color);
sqlCommand.Parameters.AddWithValue("@grupoID", grupo.GrupoID);
sqlCommand.Parameters.AddWithValue("@usuario", usuario);
sqlCommand.ExecuteNonQuery();
sqlTransaction.Commit();
return true;
}
}
catch (Exception)
{
sqlTransaction.Rollback();
throw;
}
}
}
return false;
}
public IList<Grupo> ListaPorNomePorDescricaoInatividade(Grupo grupo)
{
var busca = session.QueryOver<Grupo>();
if (String.IsNullOrEmpty(grupo.Nome) == false)
{
busca.WhereRestrictionOn(g => g.Nome).IsLike(grupo.Nome, MatchMode.Anywhere);
}
if (String.IsNullOrEmpty(grupo.Descricao) == false)
{
busca.WhereRestrictionOn(g => g.Descricao).IsLike(grupo.Nome, MatchMode.Anywhere);
}
if (grupo.EstaAtivo())
{
busca.Where(g => g.Inativo == false);
}
else
{
busca.Where(g => g.Inativo == true);
}
return busca.OrderBy(g => g.Nome).Asc.List();
}
public void ConsigoCriarUmGrupoComUmaDescricao()
{
const string descricao = "Uma Descrição";
var grupo = new Grupo(descricao);
Assert.AreEqual(descricao, grupo.Descricao);
}
private void ExecutarCarregamentoInicial()
{
// Criação dos grupos:
Grupo master = new Grupo();
master.Descricao = "MASTER";
Grupo.Create(master);
Grupo administrador = new Grupo();
administrador.Descricao = "ADMINISTRADOR";
Grupo.Create(administrador);
Grupo usuarioComum = new Grupo();
usuarioComum.Descricao = "USUÁRIO COMUM";
Grupo.Create(usuarioComum);
// Criação dos usuários:
Usuario usu = new Usuario();
usu.Grupo = master;
usu.Cpf = "98487329349";
usu.Nome = "Danilo do Amaral Meireles";
usu.Email = "*****@*****.**";
usu.Senha = "senha_danilo";
Usuario.Create(usu);
usu = new Usuario();
usu.Grupo = administrador;
usu.Cpf = "18039474116";
usu.Nome = "Francisco Raimundo da Silva";
usu.Email = "*****@*****.**";
usu.Senha = "senha_francisco";
Usuario.Create(usu);
usu = new Usuario();
usu.Grupo = administrador;
usu.Cpf = "32516449127";
usu.Nome = "Joaquim Pedro Gomes";
usu.Email = "*****@*****.**";
usu.Senha = "senha_joaquim";
Usuario.Create(usu);
usu = new Usuario();
usu.Grupo = usuarioComum;
usu.Cpf = "98717840660";
usu.Nome = "Joana Maria Pereira";
usu.Email = "*****@*****.**";
usu.Senha = "senha_joana";
Usuario.Create(usu);
usu = new Usuario();
usu.Grupo = usuarioComum;
usu.Cpf = "55201373070";
usu.Nome = "José Emanuel dos Santos";
usu.Email = "*****@*****.**";
usu.Senha = "senha_jose";
Usuario.Create(usu);
}
public void saveGrupo(GrupoModel grupo)
{
var grupoBd = new Grupo();
grupoBd.nombreGrupo = grupo.nombre;
grupoBd.descripcionGrupo = grupo.descripcion;
_contexto.Grupos.InsertOnSubmit(grupoBd);
_contexto.SubmitChanges();
}
public Perfil AdicionarPerfil(string nome, Grupo grupo, List<Modulo> modulosPermitidos)
{
var perfil = new Perfil(grupo) { Nome = nome };
foreach (var moduloPermitido in modulosPermitidos)
{
perfil.PermitirModulo(moduloPermitido);
}
_perfilRepositorio.Adicionar(perfil);
return perfil;
}
public void Atualiza(Grupo grupo)
{
try
{
session.Update(grupo);
session.Flush();
}
catch (GenericADOException ex)
{
throw new RegistroNaoPodeSerCadastradoException(ex);
}
}
public void Insere(Grupo grupo)
{
try
{
session.Save(grupo);
session.Flush();
}
catch(GenericADOException ex)
{
throw new RegistroNaoPodeSerCadastradoException(ex);
}
}
public ActionResult Create(Grupo grupo)
{
if (ModelState.IsValid)
{
db.Grupo.Add(grupo);
db.SaveChanges();
return RedirectToAction("Index");
}
ViewBag.ColegioId = new SelectList(db.Colegio, "ColegioId", "NombreColegio", grupo.ColegioId);
return View(grupo);
}
// PUT: api/Grupo/5
/// <summary>
/// Atualiza um grupo.
/// </summary>
/// <param name="id">O Id do grupo.</param>
/// <param name="grupo">Uma instância da classe Grupo.</param>
/// <returns>HttpResponseMessage</returns>
public HttpResponseMessage Put(int id, Grupo grupo)
{
if (string.IsNullOrEmpty(grupo.Descricao))
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Informe o nome do grupo.");
if (id != grupo.Id)
return Request.CreateResponse(HttpStatusCode.BadRequest);
Grupo.Save(grupo);
return Request.CreateResponse(HttpStatusCode.OK);
}
// POST: api/Grupo
/// <summary>
/// Inclui um novo grupo.
/// </summary>
/// <param name="grupo">Uma instância da classe Grupo.</param>
/// <returns>HttpResponseMessage</returns>
public HttpResponseMessage Post(Grupo grupo)
{
if (string.IsNullOrEmpty(grupo.Descricao))
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Informe o nome do grupo.");
if (Grupo.Existe(grupo.Descricao))
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Já existe um grupo com o nome informado.");
Grupo.Save(grupo);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, grupo);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = grupo.Id }));
return response;
}
public Grupo ObtenerGrupo(String pCodGru)
{
var model = new Grupo();
var bd = BaseDeDatos.GetInstance();
var dr = bd.GetOne(pCodGru, "tabgru", "id, nomgru, estgru");
if (!(dr["id"] is DBNull))
model.CodGru = dr["id"].ToString();
if (!(dr["nomgru"] is DBNull))
model.NomGru = dr["nomgru"].ToString();
if (!(dr["estgru"] is DBNull))
model.EstGru = dr["estgru"].ToString();
return model;
}
public void CreateGrupo(int TrabajoId, String AlumnoLiderId)
{
ePortafolioDBDataContext ePortafolioDAO = new ePortafolioDBDataContext();
var Grupo = new Grupo();
BETrabajo Trabajo = RepositoryFactory.GetTrabajoRepository().GetTrabajoNoFK(TrabajoId);
BESeccion Seccion = RepositoryFactory.GetSeccionRepository().GetSeccionCursoAlumno(AlumnoLiderId,Trabajo.Curso.CursoId,Trabajo.Periodo.PeriodoId);
Grupo.TrabajoId = TrabajoId;
Grupo.Nota = "NE";
Grupo.AlumnosGrupos.Add(new AlumnosGrupo { AlumnoId = AlumnoLiderId, EsLider = true });
Grupo.SeccionId = Seccion != null ? Seccion.SeccionId : "GEN";
ePortafolioDAO.Grupos.InsertOnSubmit(Grupo);
ePortafolioDAO.SubmitChanges();
}
public void ValidandoAcessoaUmaPaginaAnonima()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Ambiente.Titulo = "Páginas Anônimas (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
this.Ambiente.CodigoInterno = EnumAcesso.CodigoInterno_Ambiente.Anonimo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Validação de Página (Homologação)";
objFuncionalidade.Grupo = objGrupo;
objFuncionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(objFuncionalidade, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
int paginaID = Valor.Dois; // Página DEFAULT (Fins de teste)
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = objFuncionalidade.ID;
this.Mapeamento.UrlMapID = paginaID; // Página DEFAULT (Fins de teste)
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isAnonymousPage = AnonymousPageFacade.IsTrue(paginaID);
Assert.IsTrue(isAnonymousPage, "Não foi possível localizar a associação com o cenário ANONIMO.");
}
/*
public static List<Resumen> getResumen(edificio edificio, DateTime periodo)
{
try
{
admEntities db = Datos.getDB();
return db.Database.SqlQuery<Resumen>
(
@"select gg.nombre 'Grupo', tg.descripcion 'Descripcion', sum(importe) 'Importe' from factura f
join tipo_gasto tg
on f.id_tipogasto = tg.idtipo_gasto
join grupo_gastos gg
on tg.grupo_gastos = gg.idgrupo_gastos
where year(f.fecha) = " + periodo.Year + @" and f.dir_edificio = '" + edificio.direccion + @"'
group by gg.nombre, f.id_tipogasto"
)
.ToList();
}
catch (Exception e)
{
Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
throw e;
}
}
*/
public static List<Grupo> getResumen(edificio edificio, DateTime fechaDesde, DateTime fechaHasta)
{
try
{
admEntities db = Datos.getDB();
string query = @"select gg.nombre Grupo, tg.descripcion Descripcion, sum(f.importe) Importe from factura f
join tipo_gasto tg
on f.id_tipogasto = tg.idtipo_gasto
join grupo_gastos gg
on tg.grupo_gastos = gg.idgrupo_gastos
where
f.fecha BETWEEN '" + getFechaForGetResumen(fechaDesde, false) + @"' AND '" + getFechaForGetResumen(fechaHasta, true) + @"'
and f.dir_edificio = '" + edificio.direccion + @"'
group by tg.idtipo_gasto";
var resumen = db.Database.SqlQuery<Resumen>(query).OrderBy(x => x.Grupo).ToList();
List<Grupo> grupos = new List<Grupo>();
Grupo grupo = new Grupo();
foreach (var r in resumen)
{
Gastos gasto = new Gastos();
gasto.Descripcion = r.Descripcion;
gasto.Importe = r.Importe;
var g = grupos.Where(x => x.Nombre == r.Grupo).SingleOrDefault();
if (g == null)
{
grupo = new Grupo();
grupo.Nombre = r.Grupo;
grupo.Gastos = new List<Gastos>();
grupo.Gastos.Add(gasto);
grupos.Add(grupo);
}
else
grupos.Where(x => x.Nombre == r.Grupo).SingleOrDefault().Gastos.Add(gasto);
}
return grupos;
}
catch (Exception e)
{
Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
throw e;
}
}
public ActionResult Atualiza(Grupo grupo)
{
this.validator.Validates(grupo);
this.validator.OnValidationErrorRedirectTo<GruposController>(g => g.Edita(grupo.Id));
try
{
this.grupos.Atualiza(grupo);
TempData["mensagem"] = new Message().Of(MessageType.SUCCESS).Containing("Grupo atualizado com sucesso");
return this.RedirectToAction(c => c.Index(null));
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
TempData["mensagem"] = new Message().Of(MessageType.ERROR).Containing("Grupo não pode ser atualizado verifique se já existe outro grupo com este nome");
return this.RedirectToAction(c => c.Edita(grupo.Id));
}
}
public void LocalizarCorretamentePorIdQuandoTudoEstiverOk()
{
//Arrange
var repositorio = new Mock<RepositorioGrupos>();
var mapper = new Mock<FabricaGrupoDto>();
var id = Guid.NewGuid();
var grupoEsperado = new Grupo(id, "Grupo");
var grupoRetornadoMapper = new GrupoDto { Id = grupoEsperado.Id, Nome = grupoEsperado.Nome };
repositorio.Setup(x => x.BuscarPorId(It.IsAny<Guid>(), It.IsAny<Guid>())).Returns(grupoEsperado);
mapper.Setup(x => x.Criar(It.IsAny<Grupo>())).Returns(grupoRetornadoMapper);
//Action
var grupoRetornado = new LocalizadorGrupo(repositorio.Object, mapper.Object, new Mock<FabricaSumarioSituacaoDto>().Object).Localizar(Guid.NewGuid(), id.ToString());
//Asserts
grupoRetornado.Id.Should().Be(grupoEsperado.Id);
grupoRetornado.Nome.Should().BeEquivalentTo(grupoEsperado.Nome);
}
public string ActualizarGrupo(Grupo grupo)
{
HttpCookie Cookie = HttpContext.Current.Request.Cookies.Get("Usuario");
if (Cookie != null && AutentificacionBD.VerificarToken(Cookie.Values.Get("Token")))
{
string cliente = new Codificador().Desencriptar(Cookie.Values.Get("Cliente"));
cliente = cliente.Replace("\0", string.Empty);
if (GrupoBD.ActualizarGrupo(grupo,cliente))
{
return "ok";
}
else
{
return "errorBD";
}
}
else
{
return "error404";
}
}
public bool deleteGrupo(Grupo grupo)
{
try
{
Utilitarios.Conexion.openConnection();
command = new SqlCommand("proc_Grupos_Delete", Utilitarios.Conexion.returnConnection());
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.AddWithValue("@gru_codigo", grupo.Codigo);
if (command.ExecuteNonQuery() > 0)
{
Utilitarios.Conexion.closeConnection();
return true;
}
else
{
Utilitarios.Conexion.closeConnection();
return false;
}
}
catch (SqlException e) { MessageBox.Show("Error de Base de datos :" + e.Message); return false; }
}
public void LocalizarCorretamenteTodosQuandoTudoEstiverOk()
{
//Arrange
var repositorio = new Mock<RepositorioGrupos>();
var mapper = new Mock<FabricaGrupoDto>();
var id = Guid.NewGuid();
var grupoRetornadoDoBanco = new Grupo(id, "Grupo");
var gruposRetornadosDoBanco = new List<Grupo> { grupoRetornadoDoBanco };
var grupoRetornadoMapper = new GrupoDto { Id = grupoRetornadoDoBanco.Id, Nome = grupoRetornadoDoBanco.Nome };
var gruposRetornadosMapper = new List<GrupoDto> { grupoRetornadoMapper };
repositorio.Setup(x => x.Buscar(Guid.NewGuid(), null)).Returns(gruposRetornadosDoBanco);
mapper.Setup(x => x.Criar(It.IsAny<IEnumerable<Grupo>>())).Returns(gruposRetornadosMapper);
//Action
var gruposRetornados = new LocalizadorGrupo(repositorio.Object, mapper.Object, new Mock<FabricaSumarioSituacaoDto>().Object).Localizar(Guid.NewGuid());
//Asserts
gruposRetornados.Where(x => x.Id == grupoRetornadoDoBanco.Id).Should().NotBeNullOrEmpty();
}
static void Main(string[] args)
{
Perro perroUno = new Perro("Moro", "Pitbull");
Perro perroDos = new Perro("Julio", "Cruza", 13, false);
Perro perroTres = new Perro("Ramón", "Salchicha", 2, true);
Gato gatoUno = new Gato("José", "Angora");
Gato gatoDos = new Gato("Hernán", "Cruza");
Gato gatoTres = new Gato("Fer", "Siamés");
Grupo grupoUno = new Grupo("Río", EtipoManada.Mixta);
grupoUno += perroUno;
grupoUno += perroDos;
grupoUno += perroUno;
grupoUno += perroTres;
grupoUno += gatoUno;
grupoUno += gatoDos;
grupoUno += gatoTres;
Console.WriteLine(grupoUno);
grupoUno -= perroTres;
grupoUno -= gatoTres;
grupoUno -= gatoTres;
Console.WriteLine(grupoUno);
if (perroUno.Equals("perroUno"))
{
Console.WriteLine("Son la misma mascota");
}
else
{
Console.WriteLine("No son la misma mascota");
}
Console.ReadLine();
}
static void MainGrupo()
{
Grupo g = new Grupo("Pruebas");
g.Add(new Usuario("a@b", "a"));
g.Add(new Usuario("b@c", "b"));
Usuario usuario = g.FindByEmail("b@c");
Console.WriteLine(usuario.GetTexto());
g.Usuarios[1].Email = "YEPAAAAAAAA";
Console.WriteLine(g[0].Email);
if (g["a@b"] != null)
{
Console.WriteLine("El password es {0}", g["a@b"].Password);
g["a@b"] = new Usuario("a@b", "NUEVA PASSWORD");
Console.WriteLine(g["a@b"].GetTexto());
}
else
{
Console.WriteLine("No se ha encontrado el email a@b");
}
foreach (Usuario u in g.Usuarios)
{
Console.WriteLine(u.GetTexto());
}
g.Remove(new Usuario("b@c", "b"));
Console.WriteLine(
g.FindByEmail("b@c") == null ? "No encontrado" : "Encontrado");
Console.WriteLine(usuario == new Usuario("b@c", "b"));
}
public ActionResult Create(Grupo model, string[] agentes)
{
try
{
if (ModelState.IsValid)
{
model.AsignarId();
model.Estado = Rp3.AgendaComercial.Models.Constantes.Estado.Activo;
model.EstadoTabla = Rp3.AgendaComercial.Models.Constantes.Estado.Tabla;
model.UsrIng = this.UserLogonName;
model.FecIng = this.GetCurrentDateTime();
if (!model.TieneUbicacion)
{
model.LatitudPuntoPartida = null;
model.LongitudPuntoPartida = null;
}
DataBase.Grupos.Insert(model);
DataBase.Save();
DataBase.Agentes.GrupoAgenteUpdate(model.IdGrupo, agentes, this.UserLogonName);
this.AddDefaultSuccessMessage();
return(RedirectToAction("Index"));
}
}
catch
{
this.AddDefaultErrorMessage();
}
InicializarEdit();
InicializarDetail(model.IdGrupo);
return(View(model));
}
/// <summary>
/// Listar todos los grupos de cajas registrados.
/// </summary>
/// <returns>Lista de grupos de cajas registrados en el sistema</returns>
public BindingList <Grupo> listarGrupos()
{
BindingList <Grupo> grupos = new BindingList <Grupo>();
SqlCommand comando = _manejador.obtenerProcedimiento("SelectGrupos");
SqlDataReader datareader = null;
try
{
datareader = _manejador.ejecutarConsultaDatos(comando);
while (datareader.Read())
{
byte id = (byte)datareader["pk_ID"];
string nombre = (string)datareader["Nombre"];
string descripcion = (string)datareader["Descripcion"];
byte numero_cajas = (byte)datareader["Numero_Cajas"];
byte caja_actual = (byte)datareader["Caja_Actual"];
short total_manifiestos = (short)datareader["Total_manifiestos"];
bool caja_unica = (bool)datareader["Caja_Unica"];
AreasManifiestos area = (AreasManifiestos)datareader["Area"];
bool semaforo = (bool)datareader["Semaforo"];
Grupo grupo = new Grupo(id, nombre, descripcion, numero_cajas, caja_actual, total_manifiestos, caja_unica, area, semaforo);
grupos.Add(grupo);
}
comando.Connection.Close();
}
catch (Exception)
{
comando.Connection.Close();
throw new Excepcion("ErrorDatosConexion");
}
return(grupos);
}
/// <summary>
/// Obtain an "Grupo" by his ID
/// </summary>
/// <param name="pIdGrupo">ID to search by</param>
public Grupo Obtener(int pIdGrupo)
{
string query = "SELECT * FROM \"Grupo\" WHERE \"idGrupo\" = '" + pIdGrupo + "'";
Grupo grupo = null;
try
{
using NpgsqlCommand comando = this._conexion.CreateCommand();
comando.CommandText = query;
using (NpgsqlDataAdapter adaptador = new NpgsqlDataAdapter(comando))
{
DataTable tabla = new DataTable();
adaptador.Fill(tabla);
foreach (DataRow fila in tabla.Rows)
{
int _id = Convert.ToInt32(fila["idGrupo"]);
string _nombre = Convert.ToString(fila["nombre"]);
bool _estado = Convert.ToBoolean(fila["estado"]);
int _idArea = Convert.ToInt32(fila["idArea"]);
int _idUsuario = Convert.ToInt32(fila["idUsuario"]);
grupo = new Grupo(_id, _nombre, _estado, _idArea, _idUsuario);
}
tabla.Dispose();
}
return(grupo);
}
catch (PostgresException e)
{
throw new DAOException("Error al intentar obtener el grupo de la base de datos: " + e.Message);
}
catch (NpgsqlException e)
{
throw new DAOException("Error al intentar obtener el grupo de la base de datos: " + e.Message);
}
}
public ActionResult <Grupo> PostGrupo(Grupo grupo)
{
string hora = grupo.Hora_distribuicao;
//verifica se a hora é valida
if (hora != "" && hora != null)
{
if (hora.Split(":").Length != 2)
{
return(BadRequest());
}
else if (hora.Split(":")[0].Length == 0 || hora.Split(":")[1].Length == 0)
{
return(BadRequest());
}
else if (!int.TryParse(hora.Split(":")[0], out int n) || !int.TryParse(hora.Split(":")[1], out int m))
{
return(BadRequest());
}
else if (Int16.Parse(hora.Split(":")[0]) < 0 || Int16.Parse(hora.Split(":")[0]) > 23 || Int16.Parse(hora.Split(":")[1]) < 0 || Int16.Parse(hora.Split(":")[1]) > 59)
{
return(BadRequest());
}
}
using IDbConnection connection = _dapperConnections.getLicencasConnection();
try
{
connection.Query("INSERT INTO Grupos(Nome, Hora_distribuicao) VALUES(@Nome, @Hora_distribuicao)",
new { grupo.Nome, Hora_Distribuicao = grupo.Hora_distribuicao });
return(Ok("ok"));
}
catch (Exception)
{
return(Conflict("Conflito de valores. Insert do grupo falhou."));
}
}
protected override void Seed(ApplicationDbContext context)
{
// Seed
if (!(context.Users.Any(u => u.UserName == "*****@*****.**")))
{
var userStore =
new UserStore <Usuario, Grupo, Guid, UsuarioLogin, UsuarioGrupo, UsuarioIdentificacao>(context);
var userManager = new UserManager <Usuario, Guid>(userStore);
var usuario = new Usuario
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
UserName = "******",
EmailConfirmed = true
};
userManager.Create(usuario, "Admin@123456");
var roleStore = new RoleStore <Grupo, Guid, UsuarioGrupo>(context);
var roleManager = new RoleManager <Grupo, Guid>(roleStore);
var role = roleManager.FindByName("Admin");
if (role == null)
{
role = new Grupo {
Name = "Admin", Id = Guid.NewGuid()
};
roleManager.Create(role);
}
// Add user admin to Role Admin if not already added
var rolesForUser = userManager.GetRoles(usuario.Id);
if (!rolesForUser.Contains(role.Name))
{
userManager.AddToRole(usuario.Id, role.Name);
}
}
}
protected override void Seed(CodingCraftHOMod1Ex4Identity.Exemplos.Models.ApplicationDbContext context)
{
var userManager = new GerenciadorUsuarios(new ArmazenamentoUsuarios(context));
var roleManager = new GerenciadorGrupos(new ArmazenamentoGrupos(context));
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = roleManager.FindByName(roleName);
if (role == null)
{
role = new Grupo {
Id = Guid.NewGuid(), Name = roleName
};
var roleresult = roleManager.Create(role);
}
var user = userManager.FindByName(name);
if (user == null)
{
user = new Usuario {
Id = Guid.NewGuid(), UserName = name, Email = name
};
var result = userManager.Create(user, password);
result = userManager.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = userManager.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var result = userManager.AddToRole(user.Id, role.Name);
}
}
private void gestionDeCuentasToolStripMenuItem_Click(object sender, EventArgs e)
{
using (GestionCuentas gestion_cuentas = new GestionCuentas())
{
if (gestion_cuentas.ShowDialog() == DialogResult.OK)
{
List <CuentaConf> cuentas_para_cargar = gestion_cuentas.get_Cuentas_Cargadas();
CuentaConf configuracion_cuenta = cuentas_para_cargar.First();
DarkTreeNode nodo_lider = get_Nuevo_Nodo(configuracion_cuenta.nombre_cuenta);
if (cuentas_para_cargar.Count > 1)
{
/** Crea al lider **/
Cuenta cuenta_lider = new Cuenta(configuracion_cuenta);
Grupo grupo = new Grupo(cuenta_lider);
cuentas_cargadas.Add(configuracion_cuenta.nombre_cuenta, agregar_Nueva_Tab_Pagina(new UI_Principal(grupo.lider)));
cuentas_para_cargar.Remove(configuracion_cuenta);
/** Crea los miembros **/
foreach (CuentaConf cuenta_conf in cuentas_para_cargar)
{
Cuenta cuenta = new Cuenta(cuenta_conf);
grupo.agregar_Miembro(cuenta);
cuentas_cargadas.Add(cuenta_conf.nombre_cuenta, agregar_Nueva_Tab_Pagina(new UI_Principal(cuenta)));
nodo_lider.Nodes.Add(get_Nuevo_Nodo(cuenta_conf.nombre_cuenta));
}
}
else
{
cuentas_cargadas.Add(configuracion_cuenta.nombre_cuenta, agregar_Nueva_Tab_Pagina(new UI_Principal(new Cuenta(configuracion_cuenta))));
}
darkTreeView1.Nodes.Add(nodo_lider);
darkTreeView1.Focus();
darkTreeView1.SelectNode(nodo_lider);
}
}
}
public ComunicadoEleicaoBaseServiceTest()
{
empresa = new Empresa("Soluções TI", "30271795000133")
{
Id = 1
};
estabelecimento = new Estabelecimento("Uberlândia", "Av. Teste, 777, Bairro Santa Mônica", empresa.Id)
{
Empresa = empresa
};
var conta = new Conta {
Id = 1
};
conta.AdicionarEtapaPadrao(new EtapaPadraoConta("Convocação", "Convocação", 1, conta.Id, 1, ECodigoEtapaObrigatoria.Convocacao));
conta.AdicionarEtapaPadrao(new EtapaPadraoConta("Inscrição", "Inscrição", 2, conta.Id, 2, ECodigoEtapaObrigatoria.Inscricao));
conta.AdicionarEtapaPadrao(new EtapaPadraoConta("Votação", "Votação", 3, conta.Id, 1, ECodigoEtapaObrigatoria.Votacao));
usuarioCriacao = new Usuario("*****@*****.**", "Gestor", "Técnico do SESMT")
{
Conta = conta
};
grupo = new Grupo("C-TESTE");
grupo.Dimensionamentos.Add(new LinhaDimensionamento(5, 0, 1, 1));
grupo.LimiteDimensionamento = new LimiteDimensionamento(5, 1, 1, 1);
eleicao = new Eleicao(new DateTime(2020, 1, 1), 2, new DateTime(2020, 2, 28), usuarioCriacao, estabelecimento, grupo);
eleicao.GerarCronograma();
var templateEmailBuilder = new StringBuilder();
templateEmailBuilder.Append("@ANO, @GESTAO, @DATA_COMPLETA, @EMPRESA_CNPJ, ");
templateEmailBuilder.Append("@PERIODO_INSCRICAO, @PERIODO_VOTACAO, ");
templateEmailBuilder.Append("@TECNICO_SESMT, @TECNICO_CARGO, @FIM_INSCRICAO, ");
templateEmailBuilder.Append("@CANDIDATOS, @LINK");
comunicadoEleicao = new ComunicadoEleicaoBaseServiceMock(eleicao,
new TemplateEmail(ETipoTemplateEmail.EditalConvocacao, "Assunto Teste")
{
Template = templateEmailBuilder.ToString()
});
}
//Create [email protected] with password=Admin@123456 in the Admin role public static void InitializeIdentityForEF(ApplicationDbContext db) { var userManager = HttpContext.Current.GetOwinContext().GetUserManager <GerenciadorUsuarios>(); var roleManager = HttpContext.Current.GetOwinContext().Get <GerenciadorGrupos>(); const string name = "*****@*****.**"; const string password = "******"; const string roleName = "Admin"; //Create Role Admin if it does not exist var role = roleManager.FindByName(roleName); if (role == null) { role = new Grupo { Name = roleName }; var roleresult = roleManager.Create(role); } var dt = DateTime.Parse("1991-01-01"); var user = userManager.FindByName(name); if (user == null) { user = new Usuario { UserName = name, Email = name, DataNascimento = dt }; var result = userManager.Create(user, password); result = userManager.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = userManager.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var result = userManager.AddToRole(user.Id, role.Name); } }
public void AgregarIntegrante(Entidad _grupo, Entidad _usuario)
{
try
{
grupo = (Grupo)_grupo;
usuario = (Usuario)_usuario;
base.Conectar(); //Inicia una sesion con la base de datos
base.Comando = base.SqlConexion.CreateCommand(); //Crea el comando
base.Comando.CommandText = "AgregarIntegrante";
base.Comando.CommandType = CommandType.StoredProcedure;
parametro = new NpgsqlParameter();
parametro.NpgsqlDbType = NpgsqlDbType.Integer; //Ingresa parametros de entrada
parametro.Value = grupo.Id;
base.Comando.Parameters.Add(parametro);
parametro = new NpgsqlParameter();
parametro.NpgsqlDbType = NpgsqlDbType.Integer; //Ingresa parametros de entrada
parametro.Value = usuario.Id;
base.Comando.Parameters.Add(parametro);
base.Comando.ExecuteNonQuery(); //Ejecuta el comando
base.Desconectar(); //Culmina la sesion con la base de datos
}
catch (NpgsqlException e)
{
throw new BaseDeDatosExcepcion(e, "Error de logica de BD en "
+ this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + ". " + e.Message);
}
catch (NullReferenceException e)
{
throw new ReferenciaNulaExcepcion(e, "Parametros de entrada nulos en "
+ this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + ". " + e.Message);
}
}
// Métodos misceláneos
public List <Catedra> crearListaCatedrasGrupo(Grupo g)
{
List <Catedra> listaCatedras = new List <Catedra>();
// Intentamos llevar a cabo la operación.
// Si algo sale mal, se le notificará al usuario.
try
{
List <Materia> listaMaterias = daoMaterias.seleccionarMateriasPorGrupo(g);
foreach (Materia m in listaMaterias)
{
Catedra c =
DAOCatedras.
crearCatedra(
-1,
100,
m.idMateria,
g.idGrupo,
null,
m,
g);
listaCatedras.Add(c);
}
}
catch (MySqlException e)
{
ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
}
catch (Exception e)
{
ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
}
// Devolvemos resultados
return(listaCatedras);
}
public List <Usuario> ObtenerCualquierPaginaUsuariosFiltradoPorString(int TamanioPagina, int NumeroPagina, string str)
{
UsuarioDAO DataUsuario = new UsuarioDAO();
List <Usuario> Usuarios = DataUsuario.ObtenerCualquierPaginaUsuariosFiltradoPorString(TamanioPagina, NumeroPagina, str);
List <Usuario> ListaUsuarios = new List <Usuario>();
foreach (Usuario objUsuario in Usuarios)
{
Usuario usuario = new Usuario();
usuario = objUsuario;
//obtenemos el nombre de usuario creador
Usuario UsuarioCreador = new Usuario();
UsuarioCreador.USUA_Interno = objUsuario.AUDI_UsuarioCrea;
UsuarioCreador = DataUsuario.ObtenerUsuarioPorID(UsuarioCreador);
usuario.UsuarioCreador = UsuarioCreador.USUA_Usuario;
//Obtenemos el nombre del grupo
if (objUsuario.GRUP_Interno != null)
{
GrupoDAO DataGrupo = new GrupoDAO();
Grupo grupo = new Grupo();
grupo.GRUP_Interno = objUsuario.GRUP_Interno;
grupo = DataGrupo.ObtenerGrupoPorID(grupo);
usuario.GRUP_Nombre = grupo.GRUP_Nombre;
}
//Obtenemos el ultimo ingreso del usuario al sistema
HistorialIngresoDAO histIngrDAO = new HistorialIngresoDAO();
HistorialIngreso histIngr = new HistorialIngreso();
histIngr.USUA_Interno = objUsuario.USUA_Interno;
histIngr = histIngrDAO.ObtenerUltimoIngresoUsuario(histIngr);
if (histIngr != null)
{
usuario.HIIN_FechaIngreso = histIngr.HIIN_FechaIngreso;
}
ListaUsuarios.Add(usuario);
}
return(ListaUsuarios);
}
protected override void Seed(CodingCraftHOMod1Ex4Identity.Models.ApplicationDbContext context)
{
var userManager = new ApplicationUserManager(new UserStore <Usuario, Grupo, int, UsuarioLogin, UsuarioGrupo, UsuarioIdentificacao>(context));
var roleManager = new ApplicationRoleManager(new RoleStore <Grupo, int, UsuarioGrupo>(context));
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = roleManager.FindByName(roleName);
if (role == null)
{
role = new Grupo {
Name = roleName
};
var roleresult = roleManager.Create(role);
}
var user = userManager.FindByName(name);
if (user == null)
{
user = new Usuario {
UserName = name, Email = name
};
var result = userManager.Create(user, password);
result = userManager.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = userManager.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var result = userManager.AddToRole(user.Id, role.Name);
}
}
private void DeleteGroupButton_Click(object sender, RoutedEventArgs e)
{
bool deleteDone = false;
try
{
MessageBoxResult confirmation = CustomMessageBox.ShowYesNo("¿Seguro que desea eliminar el GRUPO "
+ " con NRC " + actualGroup.Nrc
+ "?", "Confirmación", "Si", "No");
if (confirmation == MessageBoxResult.Yes)
{
Grupo group;
using (SCPPContext context = new SCPPContext())
{
group = context.Grupo.FirstOrDefault(s => s.Nrc == actualGroup.Nrc);
context.Grupo.Remove(group);
context.SaveChanges();
}
actualGroup = group;
deleteDone = true;
}
else
{
return;
}
if (deleteDone == true)
{
MessageBoxResult result = CustomMessageBox.ShowOK("El registro ha sido eliminado con éxito.", "Eliminación", "Finalizar");
ReturnToPreviousList(new object(), new RoutedEventArgs());
}
}
catch (EntityException)
{
Restarter.RestarSCPP();
}
}
public int AsignarGrupo(Grupo grupo, Equipo equipo)
{
int periodoActual = Convert.ToInt32(DateTime.Now.ToString("yyyyMM"));
DataTable relacionAActualizarSiExiste = baseDeDatos.ConsultarBase(String.Format("select * from equipogrupo where Grupo_idGrupo = {0} and Equipo_idEquipo = {1} and periodoFin = {2}", grupo.identificador, equipo.identificador, periodoActual));
var idRelacion = 0;
foreach (DataRow relacionAActualizar in relacionAActualizarSiExiste.Rows)
{
idRelacion = Convert.ToInt32(relacionAActualizar["idEquipoGrupo"]);
}
if (idRelacion > 0)
{
var registros = baseDeDatos.ModificarBase(String.Format("update equipogrupo set periodoFin is null where idEquipoGrupo = {1}", idRelacion));
return(registros);
}
else
{
var registros = baseDeDatos.ModificarBase(String.Format("INSERT INTO equipogrupo (periodoInicio, Equipo_idEquipo, Grupo_idGrupo) VALUES({0},{1},{2})", periodoActual, equipo.identificador, grupo.identificador));
return(registros);
}
}
public int DesasignarGrupo(Grupo grupo, Equipo equipo)
{
DataTable relacionAEliminarTable = baseDeDatos.ConsultarBase(String.Format("select * from equipogrupo where Equipo_idEquipo = {0} and Grupo_idGrupo = {1} and periodoFin is null", equipo.identificador, grupo.identificador));
var idRelacion = 0;
foreach (DataRow relacionAEliminar in relacionAEliminarTable.Rows)
{
idRelacion = Convert.ToInt32(relacionAEliminar["idEquipoGrupo"]);
}
int periodoFin = Convert.ToInt32(DateTime.Now.ToString("yyyyMM"));
var registros = baseDeDatos.ModificarBase(String.Format("update equipogrupo set periodoFin = {0} where idEquipoGrupo = {1}", periodoFin, idRelacion));
EventoBitacora evento = new EventoBitacora()
{
fecha = DateTime.Now, descripcion = "Se desasigna el grupo " + grupo.identificador + " al equipo " + equipo.identificador, criticidad = 1, funcionalidad = "ADMINISTRACION DE EQUIPOS", usuario = GestorSistema.ObtenerInstancia().ObtenerUsuarioEnSesion()
};
GestorDeBitacora.ObtenerInstancia().RegistrarEvento(evento);
return(registros);
}
public JogoViewModel(Grupo g)
{
this.Grupo = g;
this.NomeGrupo = g.Nome;
if (Grupo.Equals(Storage.Storage.Jogo.G1))
{
this.NumeroGrupo = "Grupo 1";
}
else
{
this.NumeroGrupo = "Grupo 2";
}
this.IsVisibleContainerContagem = false;
this.IsVisibleBtnIniciar = false;
this.IsVisibleBtnMostrar = true;
this.Palavra = "********";
this.MostrarPalavra = new Command(MostrarPalavraCommand);
this.Acertou = new Command(AcertouCommand);
this.Errou = new Command(ErrouCommand);
this.Iniciar = new Command(IniciarCommand);
}
// GET: Grupo/Edit/5
public ActionResult Edit(int id)
{
DataTable dt = DGrupo.ObtenerGrupo(id);
ViewBag.carreras = DCarrera.LlenarCmbCarreras(); // este viewbag llenara el dropdown (combobox)
if (dt.Rows.Count == 1)
{
Grupo grupo = new Grupo();
grupo.IdGrupo = Convert.ToInt32(dt.Rows[0][0].ToString());
grupo.ClaveGrupo = Convert.ToString(dt.Rows[0][1].ToString());
grupo.Nombre = Convert.ToString(dt.Rows[0][2].ToString());
grupo.estatus = Convert.ToInt32(dt.Rows[0][3].ToString());
grupo.IdCarrera = Convert.ToInt32(dt.Rows[0][4].ToString());
return(View(grupo));
}
else
{
return(RedirectToAction("Index"));
}
}
public frmGrupo(string modo, Grupo oGrupo)
{
InitializeComponent();
frmModo = modo;
miGrupo = oGrupo;
if (frmModo == "CONSULTA")
{
txtNombre.Enabled = false;
txtDescripcion.Enabled = false;
btnGuardar.Enabled = false;
btnGuardar.Visible = false;
txtNombre.Text = oGrupo.IDgrupo;
txtDescripcion.Text = oGrupo.Descripcion;
}
if (frmModo == "MODIFICACION")
{
txtNombre.Enabled = false;
txtNombre.Text = oGrupo.IDgrupo;
txtDescripcion.Text = oGrupo.Descripcion;
txtDescripcion.Focus();
}
}
public List <Grupo> FormarGrupos(List <Filme> filmes)
{
grupos = new List <Grupo>();
while (filmes.Count > 0)
{
grupo = new Grupo();
var primeiro = filmes.First();
filmes.RemoveAt(0);
var ultimo = filmes.Last();
filmes.RemoveAt(filmes.Count - 1);
grupo.Filmes = new List <Filme>();
grupo.Filmes.Add(primeiro);
grupo.Filmes.Add(ultimo);
grupos.Add(grupo);
}
return(grupos);
}
public ActionResult Eliminar(int txtIdGrupo)
{
using (var bd = new BDDemoLoginEntities())
{
using (var transaccion = new System.Transactions.TransactionScope())
{
Grupo oGrupo = bd.Grupo.Where(p => p.IDGRUPO == txtIdGrupo).First();
oGrupo.HABILITADO = 0;
// borra permisos existentes
int cantPermisos = bd.GrupoPermiso.Where(p => p.IDGRUPO == txtIdGrupo).Count();
for (int i = 0; i < cantPermisos; i++)
{
GrupoPermiso oGrupoPermiso = bd.GrupoPermiso.Where(p => p.IDGRUPO == txtIdGrupo).First();
oGrupoPermiso.HABILITADO = 0;
}
bd.SaveChanges();
transaccion.Complete();
}
}
return(RedirectToAction("Index"));
}
/// <summary>
/// RETORNA TODOS OS GRUPOS PELA CONSULTA DE NOMES INDEPENDENTE DE CATEGORIAS
/// </summary>
/// <param name="nome"></param>
/// <returns></returns>
public List <Grupo> selectAllGruposPorNome(string nome)
{
try
{
SQL = string.Format("SELECT id, nome, id_categ, ativo FROM produto_grupo WHERE nome LIKE '%{0}%' ORDER BY nome", nome);
DataSet ds = con.ConsultaSQL(SQL);
List <Grupo> lista = new List <Grupo>();
foreach (DataRow dr in ds.Tables[0].Rows)
{
Grupo obj = new Grupo
{
Id = int.Parse(dr["id"].ToString()),
nome = dr["nome"].ToString()
};
lista.Add(obj);
}
return(lista);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public JsonResult modificarGrupo(/*string Grupo1,*/ string Descripcion, int Id, int lineaNegocio)
{
object respuesta = null;
try
{
Grupo oGrupo = db.Grupo.Where(a => a.Id == Id && a.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
//oGrupo.Grupo1 = Grupo1;
oGrupo.DescripcionGrupo = Descripcion;
Log log = new Log();
log.insertaBitacoraModificacion(oGrupo, "Id", oGrupo.Id, "Grupo.html", Request.UserHostAddress);
db.SaveChanges();
respuesta = new { success = true, results = "ok" };
}
catch (Exception ex)
{
respuesta = new { success = false, results = ex.Message };
}
return(Json(respuesta, JsonRequestBehavior.AllowGet));
}
public async Task EnviarMensagem(Usuario usuario, string msg, string nomeGrupo)
{
Grupo grupo = _banco.Grupos.FirstOrDefault(a => a.Nome == nomeGrupo);
if (!grupo.Usuarios.Contains(usuario.Email))
{
throw new Exception("Usuário não pertence ao grupo!");
}
Mensagem mensagem = new Mensagem();
mensagem.NomeGrupo = nomeGrupo;
mensagem.Texto = msg;
mensagem.UsuarioId = usuario.Id;
mensagem.UsuarioJson = JsonConvert.SerializeObject(usuario);
mensagem.Usuario = usuario;
mensagem.DataCriacao = DateTime.Now;
_banco.Mensagens.Add(mensagem);
_banco.SaveChanges();
await Clients.Group(nomeGrupo).SendAsync("ReceberMensagem", mensagem, nomeGrupo);
}
public JogoViewModel(Grupo grupo)
{
Grupo = grupo;
if (grupo == Data.Data.Jogo.Grupo1)
{
NumeroGrupo = "Grupo 1 ";
}
else
{
NumeroGrupo = "Grupo 2 ";
}
IsVisibleContainerContagem = false;
IsVisibleBtnIniciar = false;
IsVisibleBtnMostrar = true;
Palavra = "**********";
MostrarBalavra = new Command(MostrarPalavraAction);
Iniciar = new Command(IniciarAction);
Acertou = new Command(AcertouAction);
Errou = new Command(ErrouAction);
}
public IActionResult ObterGrupoPorId(int idGrupo)
{
try
{
Grupo result = _repo.Grupo.ObterGrupoPorId(idGrupo);
if (result == null)
{
_logger.LogInfo($"Erro ao obter o grupo de id: {idGrupo}.");
return(NotFound());
}
_logger.LogInfo($"Obter o grupo {result.IdGrupo} do banco.");
GrupoModel grupo = _mapper.Map <GrupoModel>(result);
return(Ok(grupo));
}
catch (Exception ex)
{
_logger.LogError($"Ocorreu um erro ao obter o grupo: {idGrupo} - {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public bool Update(Grupo data)
{
long regs = 0;
StringBuilder sql = new StringBuilder();
try
{
using (_appConn = new AppDbConnection())
{
sql.Append(" update tab_grupo ");
sql.Append(String.Format(" set grupo_desc = '{0}'", data.Descricao));
sql.Append(String.Format(" where grupo_id = {0}", data.Id.ToString()));
regs = _appConn.ExecuteNonQuery(sql.ToString());
}
}
catch (Exception)
{
throw;
}
return(regs > 0);
}
protected void btn_eliminar_asignacion_Click(object sender, ImageClickEventArgs e)
{
ImageButton imb = sender as ImageButton;
GridViewRow gvr = (GridViewRow)imb.NamingContainer;
int index = gvr.RowIndex;
string equipo = grid_equipos.Rows[index].Cells[1].Text;
string grupo = droplist_grupo_eliminar.SelectedValue;
bool correcto = Grupo.eliminar_asignacion_grupo(equipo, grupo);
string mensaje;
if (correcto)
{
mostrar_equipos_grupos();
mensaje = "mensaje('','success','Equipo: " + equipo + " eliminado','" + login.TOP_END_BIG.ToString() + "')";
}
else
{
mensaje = "mensaje('','error','Error al eliminar el equipo','" + login.TOP_END_BIG.ToString() + "')";
}
ClientScript.RegisterStartupScript(this.GetType(), "id", mensaje, true);
}
public ActionResult Edit(Grupo grupo)
{
if (ModelState.IsValid)
{
db.Entry(grupo).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
ViewBag.ColegioId = new SelectList(db.Colegio, "ColegioId", "NombreColegio", grupo.ColegioId);
return View(grupo);
}
protected override string toHTMLContenido(int nivel, Propuesta prop, Grupo g, string email, int width)
{
string ret = "";
Usuario u = g.getUsuario(email);
bool tieneFlores = false;
if (u != null) tieneFlores = u.floresDisponibles().Count > 0;
bool editar = (prop == null && tieneFlores && modo != eModo.prevista && modo != eModo.consenso)
|| (prop != null && prop.esPrevista() && (modo == eModo.revisar || modo == eModo.editar));
editar = editar && !consensoAlcanzado;
bool puedeVariante = prop != null && !prop.esPrevista() && modo == eModo.editar && tieneFlores;
//validaciones de este nivel
validar(prop);
if (nivel == 1)
{
titulo = (string)getValue("s.titulo", prop);
etiqueta = "Manifiesto";
//titulo
ret += "<div class='titulo1'><nobr>" + nombre + ":" + txt("s.titulo", prop, width - 250, tieneFlores) + "</nobr></div>";
//etiqueta
ret += "<div class='titulo2'><nobr>" + tr("Etiqueta") + ": Manifiesto ";
if (prop == null)
ret += "<span style='color:gray;font-size:12px;'>" + tr("(Etiqueta en el arbol)") + "</span>";
ret += "</nobr></div>";
//fecha
if (modo == eModo.consenso)
ret += "<div class='titulo2'><nobr>" + tr("Fecha") + ":" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + "</nobr></div>";
//tema
ret += "<div class='tema'>" + tr("Visión") + "</div>";
if (editar)
ret += "<div class='smalltip' style='width:" + width + "px'>" + tr("La vision") + "</div>";
ret += area("s.vision", prop, width, 120, tieneFlores);
}
else if (nivel == 2)
{
//Mision
ret += "<div class='tema'>" + tr("Mision") + "</div>";
if (editar)
ret += "<div class='smalltip' style='width:" + width + "px'>" + tr("Mision") + "</div>";
ret += area("s.mision", prop, width, 120, tieneFlores);
//variante
if (puedeVariante)
ret += "<div style='width:" + width + "px;text-align:right;'><input type='button' class='btn' value='" + tr("Proponer variante") + "' onclick='doVariante(" + prop.nodoID + ")'></div>";
}
else if (nivel == 3)
{
//Objetivo
ret += "<div class='tema'>" + tr("Objetivo") + "</div>";
if (editar)
ret += "<div class='smalltip' style='width:" + width + "px'>" + tr("Objetivo") + "</div>";
ret += area("s.objetivo", prop, width, 120, tieneFlores);
//variante
if (puedeVariante)
ret += "<div style='width:" + width + "px;text-align:right;'><input type='button' class='btn' value='" + tr("Proponer variante") + "' onclick='doVariante(" + prop.nodoID + ")'></div>";
}
else if (nivel == 4)
{
ret += "<div class='tema'>" + tr("Servicios") + "</div>";
if (editar)
ret += "<div class='smalltip' style='width:" + width + "px'>" + tr("Servicios") + "</div>";
ret += area("s.servicios", prop, width, 120, tieneFlores);
//variante
if (puedeVariante)
ret += "<div style='width:" + width + "px;text-align:right;'><input type='button' class='btn' value='" + tr("Proponer variante") + "' onclick='doVariante(" + prop.nodoID + ")'></div>";
}
else
{
throw new Exception("Nivel [" + nivel + "] no existe en este modelo");
}
//fin nivel
if (prop != null && prop.nodoID != 0 && modo != eModo.consenso)
ret += HTMLFlores(g.arbol.getNodo(prop.nodoID), false, g.getUsuario(email));
//mensajes de error
if (errores.ContainsKey(nivel))
{
ret += "<div class='error' style='width:" + (width-4) + "px'>" + errores[nivel] + "</div>";
}
return ret;
}
public bool InsertarGrupos(Grupo Grupo)
{
if (ModelState.IsValid)
{
db.Grupo.Add(Grupo);
db.SaveChanges();
return true;
}
else
{
return false;
}
}
public JsonResult Grupo(int? id, Grupo item)
{
switch (Request.HttpMethod)
{
case "POST":
return Json(InsertarGrupos(item));
case "PUT":
// return Json(ActualizarGrupos(item));
case "GET":
return Json(ObtenerGrupo(id.GetValueOrDefault()),
JsonRequestBehavior.AllowGet);
case "DELETE":
return Json(EliminarGrupos(id.GetValueOrDefault()));
}
return Json(new { Error = true, Message = "Operación HTTP desconocida" });
}
public virtual void Editar(Grupo grupo)
{
var colecao = MongoDatabase.GetCollection<Grupo>(NomeColecao);
colecao.ReplaceOne(Builders<Grupo>.Filter.Eq(x => x.Id, grupo.Id), grupo);
}
public void Inserir(Grupo grupo)
{
var colecao = MongoDatabase.GetCollection<Grupo>(NomeColecao);
colecao.InsertOne(grupo);
}
