public ActionResult Index(int?page, string search)
{
CustomHelper.setTitulo("Jornada", "Listado");
List <Jornada> Jornadas = new List <Jornada>();
try
{
if (!string.IsNullOrWhiteSpace(search) && search != null)
{
Jornadas = new JornadaBL().Buscar(search, CustomHelper.getColegioId()).ToList();
}
else
{
Jornadas = new JornadaBL().ObtenerListado(true, CustomHelper.getColegioId());
}
}
catch (Exception ex)
{
ViewBag.Error = string.Format("Message: {0} StackTrace: {1}", ex.Message, ex.StackTrace);
return(View("~/Views/Shared/Error.cshtml"));
}
ViewBag.Search = search;
int pageSize = 15;
int pageNumber = (page ?? 1);
return(View(Jornadas.ToPagedList(pageNumber, pageSize)));
}
/// <summary>
/// Apagar os ficheiros xml que contêm a informação dos clubes e dos jogos e limpar as listas Clubes e Jornadas
/// </summary>
public void ApagarClubesJogosJornadas()
{
MetodosClube.ApagarClube();
MetodosJornada.ApagarInfoJogo();
Clubes.Clear();
Jornadas.Clear();
}
public ActionResult DeleteConfirmed(int id)
{
Jornadas jornadas = db.Jornadas.Find(id);
db.Jornadas.Remove(jornadas);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Crear([Bind("CampeonatoID, CategoriaID, SerieID, Ronda, GrupoJornada, EquipoIDLocal, EquipoIDVisita , FechaInicial, Hora")] JornadasCrear jornadasCrear)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
if (jornadasCrear.EquipoIDLocal == jornadasCrear.EquipoIDVisita)
{
return(BadRequest("El equipo local y visitante no pueden ser el mismo equipo."));
}
if (JornadaExiste(jornadasCrear))
{
return(BadRequest("Ya existe esta relación de juego, seleccione otros equipos"));
}
// Creamos el partido
Partidos partido = new Partidos
{
PartidoEstadoID = 1,
FechaHora = jornadasCrear.FechaInicial.AddHours(jornadasCrear.Hora)
};
_context.Partidos.Add(partido);
_context.SaveChanges();
//Creamos la jornada y pasamos el id del partido
Jornadas jornadas = new Jornadas()
{
// Le asignamos valores a la jornada
CampeonatoID = jornadasCrear.CampeonatoID,
PartidoID = partido.ID,
EquipoIDLocal = jornadasCrear.EquipoIDLocal,
EquipoIDVisita = jornadasCrear.EquipoIDVisita,
CategoriaID = jornadasCrear.CategoriaID,
SerieID = jornadasCrear.SerieID,
GrupoJornada = jornadasCrear.GrupoJornada,
Ronda = jornadasCrear.Ronda
};
_context.Jornadas.Add(jornadas);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
string errMsg = FormateadorCadenas.ObtenerMensajesErrores(ex);
return(BadRequest(errMsg));
}
catch (Exception ex)
{
string errMsg = FormateadorCadenas.ObtenerMensajesErrores(ex);
return(BadRequest(errMsg));
}
return(Ok());
}
public ActionResult Edit([Bind(Include = "JornadaID,DataInicio,DataFinal,Descricao")] Jornadas jornadas)
{
if (ModelState.IsValid)
{
db.Entry(jornadas).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jornadas));
}
public void CargarDatos(int?JornadaId)
{
this.JornadaId = JornadaId;
if (JornadaId.HasValue)
{
LBPEntities context = new LBPEntities();
Jornadas objJornada = context.Jornadas.FirstOrDefault(X => X.JornadaId == JornadaId);
}
}
public ActionResult Create([Bind(Include = "JornadaID,DataInicio,DataFinal,Descricao")] Jornadas jornadas)
{
if (ModelState.IsValid)
{
db.Jornadas.Add(jornadas);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jornadas));
}
public void Put(int id, [FromBody] Jornadas newObj)
{
var oldObj = db.Jornadas.Find(id);
if (oldObj == null)
{
return;
}
newObj.Id = oldObj.Id;
db.Entry(oldObj).CurrentValues.SetValues(newObj);
db.SaveChanges();
}
// GET: Jornadas/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Jornadas jornadas = db.Jornadas.Find(id);
if (jornadas == null)
{
return(HttpNotFound());
}
return(View(jornadas));
}
public void CargarDatos(int?JornadaId)
{
LBPEntities context = new LBPEntities();
this.JornadaId = JornadaId;
this.Descripcion = Descripcion;
if (JornadaId.HasValue)
{
Jornadas objJornada = context.Jornadas.FirstOrDefault(X => X.JornadaId == JornadaId);
this.Descripcion = objJornada.Descripcion;
}
}
public ActionResult DeleteJornadas(int?JornadaId)
{
DeleteJornadasViewModel objViewModel = new DeleteJornadasViewModel();
objViewModel.CargarDatos(JornadaId);
LBPEntities context = new LBPEntities();
Jornadas objJornadas = new Jornadas();
if (objViewModel.JornadaId.HasValue)
{
objJornadas = context.Jornadas.FirstOrDefault(X => X.JornadaId == JornadaId);
}
context.Jornadas.Remove(objJornadas);
context.SaveChanges();
return(RedirectToAction("LstJornadas"));
}
public ActionResult AddEditJornadas(AddEditJornadasViewModel objViewModel)
{
LBPEntities context = new LBPEntities();
Jornadas objJornada = new Jornadas();
if (objViewModel.JornadaId.HasValue)
{
objJornada = context.Jornadas.FirstOrDefault(X => X.JornadaId == objViewModel.JornadaId);
objJornada.Descripcion = objViewModel.Descripcion;
}
else
{
objJornada.Descripcion = objViewModel.Descripcion;
context.Jornadas.Add(objJornada);
}
context.SaveChanges();
return(RedirectToAction("LstJornadas"));
}
public IActionResult CargaInicial([Bind("CampeonatoID, CategoriaID, SerieID, Ronda, Dias, FechaInicial, Hora")] JornadasCarga jornadasCarga)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (jornadasCarga.Dias[0] == null)
{
return(BadRequest("Deben seleccionar al menos un dia a configurar."));
}
var juegos = _context.Jornadas.Where(x =>
x.CampeonatoID == jornadasCarga.CampeonatoID &&
x.CategoriaID == jornadasCarga.CategoriaID &&
x.SerieID == jornadasCarga.SerieID &&
x.Ronda == jornadasCarga.Ronda).ToList();
if (juegos.Count > 0)
{
return(BadRequest("Ya existe fechas configuradas."));
}
try
{
// Obtenemos los dias
int indice = 0;
int[] dias = new int[jornadasCarga.Dias.Count()];
foreach (var item in jornadasCarga.Dias)
{
dias[indice] = Convert.ToInt32(item);
indice++;
}
// Obtenemos los equipos que se han inscripto en el campeonato
var equipos = (from e in _context.Equipos
join i in _context.Inscripciones on e.ID equals i.EquipoID
where i.CampeonatoID == jornadasCarga.CampeonatoID &&
e.CategoriaID == jornadasCarga.CategoriaID &&
e.SerieID == jornadasCarga.SerieID
select e).OrderBy(x => x.ID).ToList();
if (equipos.Count <= 1)
{
return(BadRequest("No existen equipos registrados."));
}
// Colocamos todos los id de equipos en una matriz
indice = 0;
int[] matriz = new int[equipos.Count()];
equipos.ForEach(delegate(Equipos equipo)
{
matriz[indice] = equipo.ID;
indice++;
});
// Se calcula el numero de fechas a realizarse
int fechas = equipos.Count();
if ((fechas) % 2 == 0)
{
//Si es numero impar el total de equipos se resta 1
fechas = fechas - 1;
}
// Obtenemos primer dia de las jornadas.
DateTime fechaInicial;
int dia = (int)jornadasCarga.FechaInicial.DayOfWeek;
if (dias.Contains(dia))
{
fechaInicial = jornadasCarga.FechaInicial.AddHours(jornadasCarga.Hora);
}
else
{
int i = dias.Max();
if (dia > i)
{
fechaInicial = jornadasCarga.FechaInicial.AddDays(7 + (dias.Min() - dia)).AddHours(jornadasCarga.Hora);
}
else
{
i = 0;
for (int x = 0; x < dias.Length; x++)
{
if (dias[x] > dia)
{
i = dias[x];
break;
}
}
fechaInicial = jornadasCarga.FechaInicial.AddDays(i - dia).AddHours(jornadasCarga.Hora);
}
}
//Guardamos El dia que iniciamos
dia = (int)fechaInicial.DayOfWeek;
//Pasamos todas las jornadas
for (int x = 1; x <= fechas; x++)
{
int i = 0;
// Insertamos en base de datos los registros de las jornadas
for (int j = equipos.Count() - 1; i < j; j--)
{
// Creamos el partido primero
Partidos partido = new Partidos
{
PartidoEstadoID = 1,
FechaHora = fechaInicial
};
_context.Partidos.Add(partido);
_context.SaveChanges();
//Creamos la jornada y pasamos el id del partido
Jornadas jornadas = new Jornadas()
{
// Le asignamos valores a la jornada
CampeonatoID = jornadasCarga.CampeonatoID,
PartidoID = partido.ID,
EquipoIDLocal = matriz[i],
EquipoIDVisita = matriz[j],
CategoriaID = jornadasCarga.CategoriaID,
SerieID = jornadasCarga.SerieID,
GrupoJornada = x,
Ronda = jornadasCarga.Ronda
};
_context.Jornadas.Add(jornadas);
_context.SaveChanges();
// Por cada partido agregamos 2 horas.
fechaInicial = fechaInicial.AddHours(2);
i++;
}
// Se reacomoda la matriz para que el segundo pase a ser el ultimo
int ultimaPosicion = matriz[equipos.Count() - 1];
for (int y = equipos.Count() - 1; y > 1; y--)
{
matriz[y] = matriz[y - 1];
}
matriz[1] = ultimaPosicion;
// Reiniciamos el contador de i para nuevamente tomar la primera posición en la tabla
i = 0;
// Intercambiamos los dias seleccionados, y configurando que sean las 8 de la mañana
fechaInicial = fechaInicial.Date;
// Tomamos el indice del dia en arreglo del dias y nos pasamos al siguiente
int indexdias = Array.IndexOf(dias, dia) + 1;
dia = (int)fechaInicial.DayOfWeek;
// Si solo se tiene un dia en el arreglo hacemos el ciclo a la siguiente semana
if (dias.Length == 1)
{
if (dias[0] == 6)
{
fechaInicial = fechaInicial.AddDays(dias[0] - dia).AddHours(jornadasCarga.Hora);
}
else
{
fechaInicial = fechaInicial.AddDays(7 + (dias[0] - dia)).AddHours(jornadasCarga.Hora);
}
}
else
{
// Si se pasa del elementos del arreglo tomamos el primero
if (indexdias > (dias.Length - 1))
{
fechaInicial = fechaInicial.AddDays(7 + (dias[0] - dia)).AddHours(jornadasCarga.Hora);
}
else
{
if (dias[indexdias - 1] == 0)
{
fechaInicial = fechaInicial.AddDays(dias[indexdias] - dia).AddHours(jornadasCarga.Hora);
}
else
{
fechaInicial = fechaInicial.AddDays(7 + (dias[indexdias] - dia)).AddHours(jornadasCarga.Hora);
}
}
}
//Guardamos para el siguiente ciclo
dia = (int)fechaInicial.DayOfWeek;
}
}
catch (DbUpdateConcurrencyException ex)
{
string errMsg = FormateadorCadenas.ObtenerMensajesErrores(ex);
return(BadRequest(errMsg));
}
catch (Exception ex)
{
string errMsg = FormateadorCadenas.ObtenerMensajesErrores(ex);
return(BadRequest(errMsg));
}
return(Ok());
}
public void AdicionarJornada(JornadaTrabalho jornada)
{
Jornadas.Add(jornada);
}
public ReactiveCadastroContratoViewModel(IReactiveRepository repository, DispatcherScheduler dispatcherScheduler)
: base(repository, dispatcherScheduler)
{
// NOTE: Inicialização dos campos
// Carrega os contratos do banco
Repository.GetAll <Contrato>()
.Busy(this)
.Subscribe(contratos =>
{
foreach (var contrato in contratos)
{
ContratosSalvos.Add(contrato);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as naturalidades do banco de maneira assíncrona
Repository.GetAll <Naturalidade>()
.Busy(this)
.Subscribe(naturalidades =>
{
foreach (var naturalidade in naturalidades)
{
Naturalidades.Add(naturalidade);
}
NaturalidadeSelecionada = Naturalidades.First();
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.GetAll <EstadoCivil>()
.Busy(this)
.Subscribe(estadosCivis =>
{
foreach (var estadoCivil in estadosCivis)
{
EstadosCivis.Add(estadoCivil);
}
EstadoCivilSelecionado = EstadosCivis.First();
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os estados do banco de maneira assíncrona
Repository.GetAll <Estado>()
.Busy(this)
.Subscribe(estados =>
{
foreach (var estado in estados)
{
Estados.Add(estado);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os bairros do banco de maneira assíncrona
Repository.GetAll <Bairro>()
.Busy(this)
.Subscribe(bairros =>
{
foreach (var bairro in bairros)
{
Bairros.Add(bairro);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os cidades do banco de maneira assíncrona
Repository.GetAll <Cidade>()
.Busy(this)
.Subscribe(cidades =>
{
foreach (var cidade in cidades)
{
Cidades.Add(cidade);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as secretarias do banco de maneira assíncrona
Repository.GetAll <Secretaria>()
.Busy(this)
.Subscribe(secretarias =>
{
foreach (var secretaria in secretarias)
{
Secretarias.Add(secretaria);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as jornadas do banco de maneira assíncrona
Repository.GetAll <Jornada>()
.Busy(this)
.Subscribe(jornadas =>
{
foreach (var jornada in jornadas)
{
Jornadas.Add(jornada);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// NOTE: Validação dos campos.
// Para cada campo abaixo é criado um fluxo que verifica se o campo está preenchido. Caso não esteja
// uma notificação de erro será propagada. O fluxo é acionado de maneira reativa, através da interação
// do usuário na aplicação.
var nomeHasErrors = this.WhenAnyValue(s => s.Nome, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(nomeHasErrors, nameof(Nome));
var cpfHasErros = this.WhenAnyValue(s => s.Cpf, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(cpfHasErros, nameof(Cpf));
var rgHasErros = this.WhenAnyValue(s => s.Rg, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(rgHasErros, nameof(Rg));
var orgExpHasErros = this.WhenAnyValue(s => s.OrgExp, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(orgExpHasErros, nameof(OrgExp));
var enderecoHasErros = this.WhenAnyValue(s => s.Endereco, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(enderecoHasErros, nameof(Endereco));
var estadoCivilHasErros = this.WhenAny(s => s.EstadoCivilSelecionado, e => e.Value is null);
var naturalidadeHasErros = this.WhenAny(s => s.NaturalidadeSelecionada, e => e.Value is null);
var estadoHasErros = this.WhenAny(s => s.EstadoSelecionado, e => e.Value is null);
var bairroHasErros = this.WhenAny(s => s.BairroSelecionado, e => e.Value is null);
var cidadeHasErros = this.WhenAny(s => s.CidadeSelecionada, e => e.Value is null);
var secretariaHasErros = this.WhenAny(s => s.SecretariaSelecionada, e => e.Value is null);
var orgaoHasErros = this.WhenAny(s => s.OrgaoSelecionado, e => e.Value is null);
var deparmentoHasErros = this.WhenAny(s => s.DepartamentoSelecionado, e => e.Value is null);
var dotacaoHasErros = this.WhenAny(s => s.DotacaoSelecionado, e => e.Value is null);
var descricaoVinculoHasErros = this.WhenAny(s => s.DescricaoVinculoSelecionado, e => e.Value is null);
var cargoHasErros = this.WhenAny(s => s.CargoSelecionado, e => e.Value is null);
var jornadaHasErros = this.WhenAny(s => s.JornadaSelecionada, e => e.Value is null);
// Criamos um fluxo que é a combinação de todos os fluxos de validação acima.
// Caso algum fluxo apresente o valor verdadeiro, isto é, caso algum fluxo notifique uma mensagem de erro,
// este fluxo irá propagar uma notificação que fará com que o comando abaixo não possa ser executado.
var salvarCanExecute = Observable.CombineLatest(
this.WhenAnyValue(s => s.IsBusy),
nomeHasErrors,
cpfHasErros,
rgHasErros,
orgExpHasErros,
estadoCivilHasErros,
naturalidadeHasErros,
estadoHasErros,
enderecoHasErros,
bairroHasErros,
cidadeHasErros,
secretariaHasErros,
orgaoHasErros,
deparmentoHasErros,
dotacaoHasErros,
descricaoVinculoHasErros,
cargoHasErros,
jornadaHasErros)
.Select(observables => !observables.Any(r => r == true));
SalvarCommand = ReactiveCommand.Create(SalvarExecute, salvarCanExecute);
// Regras de negócio
// Ao selecionar uma nova secretaria carregamos dados referentes a esta secretaria
this.WhenAnyValue(s => s.SecretariaSelecionada)
.Subscribe(newSecretaria =>
{
if (newSecretaria != null)
{
Repository.Get <DescricaoVinculo>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(descricaoVinculos =>
{
foreach (var descricaoVinculo in descricaoVinculos)
{
DescricaoVinculos.Add(descricaoVinculo);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Orgao>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(orgaos =>
{
foreach (var orgao in orgaos)
{
Orgaos.Add(orgao);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Departamento>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(departamentos =>
{
foreach (var departamento in departamentos)
{
Departamentos.Add(departamento);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Dotacao>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(dotacoes =>
{
foreach (var dotacao in dotacoes)
{
Dotacoes.Add(dotacao);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Cargo>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(cargos =>
{
foreach (var cargo in cargos)
{
Cargos.Add(cargo);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
}
});
}
// Isso é um construtor, presente em qualquer linguagem de programação.
// Todo o código escrito aqui será chamado SOMENTE UMA VEZ durante a inicialização da janela
public CadastroContratoViewModel() : base(new Repository())
{
// Carregamos todos os Contratos gravados no banco de dados. isso é similar a um "SELECT * FROM Contrato";
var contratos = Repository.GetAll <Contrato>();
// Populamos o combobox com os contatos recuperados
foreach (var contrato in contratos)
{
ContratosSalvos.Add(contrato);
}
// Carregamos todas as Naturalidades gravados no banco de dados. isso é similar a um "SELECT * FROM Naturalidade";
var naturalidades = Repository.GetAll <Naturalidade>();
// Populamos o combobox com as naturalidades recuperados
foreach (var naturalidade in naturalidades)
{
Naturalidades.Add(naturalidade);
}
// Carregamos todas os estados civis gravados no banco de dados. isso é similar a um "SELECT * FROM EstadoCivil";
var estadosCivis = Repository.GetAll <EstadoCivil>();
// Populamos o combobox com os estadosCivis recuperados
foreach (var estadoCivil in estadosCivis)
{
EstadosCivis.Add(estadoCivil);
}
// Aqui definimos que inicialmente o estado civil selecionado será o primeiro elemento do combobox
EstadoCivilSelecionado = EstadosCivis.First();
// Carregamos todas os Estados gravados no banco de dados. isso é similar a um "SELECT * FROM Estado";
var estados = Repository.GetAll <Estado>();
// Populamos o combobox com os estados recuperados
foreach (var estado in estados)
{
Estados.Add(estado);
}
// Carregamos todas os Bairros gravados no banco de dados. isso é similar a um "SELECT * FROM Bairro";
var bairros = Repository.GetAll <Bairro>();
// Populamos o combobox com os bairros recuperados
foreach (var bairro in bairros)
{
Bairros.Add(bairro);
}
// Carregamos todas as Cidades gravados no banco de dados. isso é similar a um "SELECT * FROM Cidade";
var cidades = Repository.GetAll <Cidade>();
// Populamos o combobox com as cidades recuperados
foreach (var cidade in cidades)
{
Cidades.Add(cidade);
}
// Carregamos todas as Secretarias gravados no banco de dados. isso é similar a um "SELECT * FROM Secretaria";
var secretarias = Repository.GetAll <Secretaria>();
// Populamos o combobox com as secretarias recuperados
foreach (var secretaria in secretarias)
{
Secretarias.Add(secretaria);
}
// Carregamos todas as Jornadas gravados no banco de dados. isso é similar a um "SELECT * FROM Jornada";
var jornadas = Repository.GetAll <Jornada>();
// Populamos o combobox com as jornadas recuperados
foreach (var jornada in jornadas)
{
Jornadas.Add(jornada);
}
// Criamos um comando para o botão de Salvar. O método "SalvarExecute" será chamado sempre que o usuário acionar o botão
SalvarCommand = new DelegateCommand(SalvarExecute);
// Criamos uma rotina que será executada sempre que a secretaria selecionada mudar.
// Diferente dos demais códigos escritos no construtor, esse código pode ser chamado mais de uma vez.
this.WhenAnyValue(s => s.SecretariaSelecionada)
.Subscribe(newSecretaria =>
{
// Atenção: O código de todo esse bloco será executado sempre que uma nova secretaria for selecionada.
// "newSecretaria" representa a nova secretaria selecionada pelo usuário.
// Caso a nova secretaria selecionada não seja null, isto é, não seja uma secretária inválida
if (newSecretaria != null)
{
// Carregamos todas as descrições associadas a nova secretaria selecionada. isso é similar a um "SELECT * FROM DescricaoVinculo WHERE SecretariaId = @newSecretariaId";
var descricaoVinculos = Repository.Get <DescricaoVinculo>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com as descricaoVinculos recuperados
foreach (var descricaoVinculo in descricaoVinculos)
{
DescricaoVinculos.Add(descricaoVinculo);
}
// Carregamos todos os orgãos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Orgao WHERE SecretariaId = @newSecretariaId";
var orgaos = Repository.Get <Orgao>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os orgaos recuperados
foreach (var orgao in orgaos)
{
Orgaos.Add(orgao);
}
// Carregamos todos os departamentos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Departamento WHERE SecretariaId = @newSecretariaId";
var departamentos = Repository.Get <Departamento>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os departamentos recuperados
foreach (var departamento in departamentos)
{
Departamentos.Add(departamento);
}
// Carregamos todos as dotações associadas a nova secretaria selecionada. isso é similar a um "SELECT * FROM Dotacao WHERE SecretariaId = @newSecretariaId";
var dotacoes = Repository.Get <Dotacao>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os departamentos recuperados
foreach (var dotacao in dotacoes)
{
Dotacoes.Add(dotacao);
}
// Carregamos todos os Cargos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Cargo WHERE SecretariaId = @newSecretariaId";
var cargos = Repository.Get <Cargo>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os cargos recuperados
foreach (var cargo in cargos)
{
Cargos.Add(cargo);
}
}
});
}
public void Post(Jornadas sync)
{
db.Jornadas.Add(sync);
db.SaveChanges();
}
