public ActionResult EditarCiclo(Ciclo Emp)
{
try
{
if (ModelState.IsValid)
{
DataAccessCiclo objDB = new DataAccessCiclo();
if (objDB.EditarCiclos(Emp))
{
ViewBag.Message = "Ciclo Editado con exito!";
}
}
return(View());
} catch {
return(View());
}
}
public List <CursoMaestroModel> ObtenerCursosAsignadoxID(long colegioId, long maestroId, int actitudinal)
{
List <CursoMaestroModel> Cursos = new List <CursoMaestroModel>();
try
{
//Se obtiene el ciclo actual del colegio
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == colegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
Cursos = db.Database.SqlQuery <CursoMaestroModel>("dbo.sp_consulta_curso_asignados_x_maestro @ColegioId, @MaestroId, @CicloId, @Actitudinal", new SqlParameter("@ColegioId", colegioId), new SqlParameter("@MaestroId", maestroId), new SqlParameter("@CicloId", CicloActual.CicloId), new SqlParameter("@Actitudinal", actitudinal)).ToList();
}
}
catch (Exception)
{}
return(Cursos);
}
public string GuardarAsistencia(List <Asistencia> entidad, long colegioId, long cursoId, long gradoId, long seccionId, long usuarioId, DateTime fecha)
{
string Mensaje = "OK";
long CicloActualId = 0;
DateTime FechaActual = fecha;
try
{
//Se obtiene el ciclo actual del colegio
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == colegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
CicloActualId = CicloActual.CicloId;
}
if (CicloActualId == 0)
{
return("Se le informa que el colegio no tiene activado el ciclo escolar");
}
//Se elimina las asistencias
List <Asistencia> Asistencias = db.Set <Asistencia>().Where(x => x.ColegioId == colegioId && x.CursoId == cursoId && x.GradoId == gradoId && x.SeccionId == seccionId && x.CicloId == CicloActualId && x.FechaAsistencia == FechaActual).ToList();
db.Set <Asistencia>().RemoveRange(Asistencias);
entidad.ForEach(x =>
{
x.CicloId = CicloActualId;
x.FechaAsistencia = FechaActual;
x.ResponsableId = usuarioId;
x.Fecha = DateTime.Today;
db.Set <Asistencia>().Add(x);
});
db.SaveChanges();
}
catch (Exception ex)
{
Mensaje = string.Format("Descripción del Error {0}", ex.Message);
}
return(Mensaje);
}
public Ciclo ObtenerCiclos(int cod)
{
Ciclo ciclos = new Ciclo();
SqlConnection con = new SqlConnection(Conexion_global.strConexion);
SqlCommand cmd = new SqlCommand("getCiclo", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@cod", cod));
con.Open();
var registros = cmd.ExecuteReader();
while (registros.Read())
{
ciclos.Idciclo = int.Parse(registros["Idciclo"].ToString());
ciclos.Nomciclo = registros["NomCiclo"].ToString();
}
con.Close();
return(ciclos);
}
// GET: api/ValoresAbertosBase
public IEnumerable <ValoresAbertosBaseDTO> GetValoresAbertosBase(string codEvento = null, string matricula = null, int?codCiclo = null)
{
if (matricula != null && codCiclo != null)
{
IEnumerable <ValoresAbertosBaseDTO> lista = new HashSet <ValoresAbertosBaseDTO>();
Ciclo ciclo = db.Ciclo.Find(codCiclo);
if (ciclo == null)
{
return(null);
}
db.ValoresAbertosBase
.Where(x => x.MatriculaFuncionario == matricula && x.MesOrcamento.CicloCod == codCiclo)
.Select(x => x.CodEvento).Distinct().ToList().ForEach(x =>
{
foreach (MesOrcamento m in ciclo.MesesOrcamento)
{
ValoresAbertosBase v = db.ValoresAbertosBase.Find(x, m.Codigo, matricula);
if (v == null)
{
((HashSet <ValoresAbertosBaseDTO>)lista).Add(new ValoresAbertosBaseDTO
{
CodEvento = x,
CodMesOrcamento = m.Codigo,
MatriculaFuncionario = matricula,
Valor = 0
});
}
else
{
((HashSet <ValoresAbertosBaseDTO>)lista).Add(new ValoresAbertosBaseDTO(v));
}
}
});
return(lista);
}
return(db.ValoresAbertosBase.ToList()
.Where(x => (codEvento == null || x.CodEvento == codEvento) && (matricula == null || x.MatriculaFuncionario == matricula) && (codCiclo == null || x.MesOrcamento.CicloCod == codCiclo))
.Select(x => new ValoresAbertosBaseDTO(x)));
}
private void cboCiclos_SelectedIndexChanged(object sender, EventArgs e)
{
Ciclo ciclo = (Ciclo)cboCiclos.SelectedItem;
lblNombreCiclo.Text = ciclo.Nombre;
lblAlumnosCiclo.Text = ciclo.Alumnos.Count().ToString();
var numAlumAsignado = Program.gFCT.AlumnosAsignados(ciclo.Id, out string msgErrorAlumAsign);
if (numAlumAsignado == -1)
{
MessageBox.Show(msgErrorAlumAsign);
Close();
}
lblAsignados.Text = numAlumAsignado.ToString();
dgvAlumnosCiclo.DataSource = (from alum in Program.gFCT.AlumnosOrdenados(ciclo.Id, out string msgErrorAlumOrdenados)
select new { alum.Nombre, alum.Telefono, alum.Aprobado }).ToList();
if (msgErrorAlumOrdenados != "")
{
MessageBox.Show(msgErrorAlumOrdenados);
Close();
}
dgvAlumnosEmpresa.DataSource = (from alumEmp in Program.gFCT.EmpresaAlumno(ciclo.Id, out string msgErrorEmprAlum)
select new { alumEmp.Nombre, Empresa = alumEmp.FCT.Empresa.Nombre }).ToList();
if (msgErrorEmprAlum != "")
{
MessageBox.Show(msgErrorEmprAlum);
Close();
}
dgvOfertas.DataSource = (from ofEmp in Program.gFCT.EmpresaOfertaFCT(ciclo.Id, out string msgErrorEmpOfertFCT)
select new { ofEmp.Empresa.Nombre, ofEmp.Empresa.TelefonoContacto, ofEmp.Cantidad, Asignadas = ofEmp.Empresa.FCTs.Count() }).ToList();
if (msgErrorEmpOfertFCT != "")
{
MessageBox.Show(msgErrorEmpOfertFCT);
Close();
}
}
// GET: api/ValoresAbertosContratacoes
public IEnumerable <ValoresAbertosContratacaoDTO> GetValoresAbertosContratacao(string codEvento = null, int?codContratacao = null, int?codCiclo = null)
{
if (codContratacao != null && codCiclo != null)
{
IEnumerable <ValoresAbertosContratacaoDTO> lista = new HashSet <ValoresAbertosContratacaoDTO>();
Ciclo ciclo = db.Ciclo.Find(codCiclo);
if (ciclo == null)
{
return(null);
}
db.ValoresAbertosContratacao
.Where(x => x.CodContratacao == codContratacao && x.MesOrcamento.CicloCod == codCiclo)
.Select(x => x.CodEvento).Distinct().ToList().ForEach(x =>
{
foreach (MesOrcamento m in ciclo.MesesOrcamento)
{
ValoresAbertosContratacao v = db.ValoresAbertosContratacao.Find(x, m.Codigo, codContratacao);
if (v == null)
{
((HashSet <ValoresAbertosContratacaoDTO>)lista).Add(new ValoresAbertosContratacaoDTO
{
CodEvento = x,
CodMesOrcamento = m.Codigo,
CodContratacao = codContratacao.Value,
Valor = 0
});
}
else
{
((HashSet <ValoresAbertosContratacaoDTO>)lista).Add(new ValoresAbertosContratacaoDTO(v));
}
}
});
return(lista);
}
return(db.ValoresAbertosContratacao.ToList()
.Where(x => (codEvento == null || x.CodEvento == codEvento) && (codContratacao == null || x.CodContratacao == codContratacao) && (codCiclo == null || x.MesOrcamento.CicloCod == codCiclo))
.Select(x => new ValoresAbertosContratacaoDTO(x)));
}
public CicloDTO(Ciclo c)
{
if (c == null)
{
return;
}
Codigo = c.Codigo;
DataInicio = c.DataInicio;
DataFim = c.DataFim;
StatusCod = c.StatusCod;
Descricao = c.Descricao;
StatusNome = c.StatusCiclo.Nome;
TipoCod = c.TipoCod;
TipoNome = c.TipoCiclo.Nome;
if (c.MesesOrcamento != null)
{
Meses = new List <MesOrcamentoDTO>();
Meses = c.MesesOrcamento.ToList().Select(x => new MesOrcamentoDTO(x));
}
}
public FormPago()
{
InitializeComponent();
turno = new Turno();
ciclo = new Ciclo();
grupo = new Grupo();
costos = new Costo();
meses = new Mes();
alumnoModel = new AlumnoViewModel();
presentadorCiclos = new PresentadorCiclos(new SQLCicloRepositorio(), this);
presentadorCiclos.PresentarCiclos();
_DetallePago = new ConceptoPagoDetalle();
_CarroPago = new CarroPago();
presentadorPago = new PresentadorPago(new SQLPagoRepositorio(), this);
grupoAlumnoTC = new GrupoAlumnoTC();
oconceptoCostoCiclo = new ConceptoCostoCiclo();
presentadorPagosDetalle = new PresentadorPagosDetalle(new SQLPagoRepositorio(), this);
presentadorPagosDetalle.PresentarPagosDetalle();
}
public List <Curso> Buscar(string search, long colegioId, long tipoId)
{
List <Curso> Cursos = new List <Curso>();
long CicloId = 0;
try
{
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == colegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
CicloId = CicloActual.CicloId;
}
Cursos = db.Set <Curso>().Include("Ciclo").Include("Tipo").Include("Grados").AsNoTracking().Where(x => x.Nombre.ToLower().Contains(search.ToLower()) && x.ColegioId == colegioId && x.CicloId == CicloId && x.TipoId == tipoId).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CursoId).Take(200).ToList();
}
catch (Exception)
{ }
return(Cursos);
}
//To Add Ciclo
public bool AgregarCiclos(Ciclo obj)
{
SqlConnection con = new SqlConnection(Conexion_global.strConexion);
SqlCommand com = new SqlCommand("AddCiclo", con);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.AddWithValue("@Nomciclo", obj.Nomciclo);
con.Open();
int i = com.ExecuteNonQuery();
con.Close();
if (i >= 1)
{
return(true);
}
else
{
return(false);
}
}
//Duplico los rubros existentes en el ciclo actual y los copio para el nuevo ciclo
public void NewCicle_DuplicateRubros(Ciclo currentCicle, Ciclo newCicle)
{
int tam = Rubros.Count;
for (int i = 0; i < tam; i++)
{
Rubro rubro = Rubros.ElementAt(i);
if (rubro.Ciclo.CicloId == currentCicle.CicloId)
{
Rubro copiaTemp = new Rubro
{
RubroNombre = rubro.RubroNombre,
RubroTipo = rubro.RubroTipo,
RubroValorEsperado = rubro.RubroValorEsperado,
RubroValorActual = rubro.RubroValorEsperado,
Ciclo = newCicle //!!
};
AddRubro(copiaTemp);
}
}
}
public Ciclo ObtenerCicloPorId(int id)
{
using (SqlConnection conexion = new SqlConnection(ConexionConfig.Cadena))
{
Comando = new SqlCommand("paObtenerCicloPorId", conexion);
Comando.CommandType = CommandType.StoredProcedure;
Comando.Parameters.Add("@idciclo", SqlDbType.Int).Value = id;
conexion.Open();
Leer = Comando.ExecuteReader();
Ciclo ciclo = null;
while (Leer.Read())
{
ciclo = new Ciclo();
ciclo.Id = (int)Leer["Id"];
ciclo.Año = (int)Leer["Año"];
ciclo.Fksemestre = (int)Leer["Fk_Semestre"];
ciclo.Nombre = (string)Leer["Nombre"];
}
return(ciclo);
}
}
public void Update(string ibge, Ciclo model)
{
try
{
Helpers.HelperConnection.ExecuteCommand(ibge, conn =>
conn.Execute(_command.Update, new
{
@data_inicial = model.data_inicial,
@data_final = model.data_final,
@num_ciclo = model.num_ciclo,
@situacao = model.situacao,
@data_situacao = model.data_situacao,
@id_usuario = model.id_usuario,
@id = model.id,
}));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Agregarciclo(Ciclo Emp)
{
try
{
if (ModelState.IsValid)
{
DataAccessCiclo objDB = new DataAccessCiclo();
if (objDB.AgregarCiclos(Emp))
{
ModelState.Clear();
ViewBag.Message = "Ciclo Agregado con exito!";
}
}
return(View());
}
catch
{
return(View());
}
}
public List <Ciclo> ObtenerCiclos()
{
using (SqlConnection conexion = new SqlConnection(ConexionConfig.Cadena))
{
Comando = new SqlCommand("paObtenerCiclos", conexion);
Comando.CommandType = CommandType.StoredProcedure;
conexion.Open();
Leer = Comando.ExecuteReader();
List <Ciclo> cilos = new List <Ciclo>();
while (Leer.Read())
{
Ciclo ciclo = new Ciclo();
ciclo.Id = (int)Leer["Id"];
ciclo.Año = (int)Leer["Año"];
ciclo.Fksemestre = (int)Leer["Fk_Semestre"];
ciclo.Nombre = (string)Leer["Nombre"];
ciclo.Periodo = (string)Leer["Ciclo"];
cilos.Add(ciclo);
}
return(cilos);
}
}
public int AlumnosAsignadosPorCiclo(string idCiclo, out string mensaje)
{
mensaje = "";
Ciclo cicloBuscar = new Ciclo(idCiclo);
Ciclo ciclo = BdFCTsEntities.Ciclos.ToList().Where(com => com.Equals(cicloBuscar)).SingleOrDefault();
if (ciclo == null)
{
mensaje = "No existe el ciclo ";
return(0);
}
List <FCT> listaFcts = BdFCTsEntities.FCTs.ToList();
List <Alumno> listaAlum = ciclo.Alumnos.ToList();
int numAsignados = listaAlum.FindAll(alum => listaFcts.Contains(alum.FCT)).Count();
if (numAsignados == 0)
{
mensaje = "Este ciclo no tiene alumnos asignados";
return(0);
}
return(numAsignados);
}
/*Commented under version 1.5
* ObservableCollection<RubroPorCiclo> RubrosPorCiclos { get; set; }
*/
//====
public void LoadCollectionsFromDatabase()
{
//Specify the query & Load the data from DB!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
var ciclosInDB = from Ciclo ciclo in rubroDB.Ciclos
select ciclo;
Ciclos = new ObservableCollection <Ciclo>(ciclosInDB);
if (Ciclos.Count < 1)
{
Ciclo nuevoCiclo = new Ciclo()
{
Cerrado = false
};
rubroDB.Ciclos.InsertOnSubmit(nuevoCiclo);
rubroDB.SubmitChanges();
Ciclos.Add(nuevoCiclo);
}
ultimoCiclo = Ciclos.Last();
if (selectedCiclo == null)
{
selectedCiclo = ultimoCiclo;
}
var rubrosInDB = from Rubro rubro in rubroDB.Rubros where (rubro.Ciclo.CicloId == selectedCiclo.CicloId)
select rubro;
Rubros = new ObservableCollection <Rubro>(rubrosInDB);
/*
* var rubrosPorCiclosInDB = from RubroPorCiclo rpc in rubroDB.RubrosPorCiclos
* select rpc;
* RubrosPorCiclos = new ObservableCollection<RubroPorCiclo>(rubrosPorCiclosInDB);
*/
//
}
public ActionResult Inserir([FromHeader] string ibge, [FromBody] Ciclo model)
{
try
{
ibge = _config.GetConnectionString(Connection.GetConnection(ibge));
//valida se existe ciclo com o mesmo período
var itens = _repository.ValidaExistenciaCicloPeriodo(ibge, model.data_inicial, model.data_final);
if (itens.Count > 0)
{
return(BadRequest(TrataErro.GetResponse("Já existe um ciclo vigente no período informado.", true)));
}
model.id = _repository.GetNewId(ibge);
_repository.Insert(ibge, model);
var principal = HttpContext.User;
int?id_usuario = null;
if (principal?.Identities?.FirstOrDefault().Claims != null)
{
id_usuario = Convert.ToInt32(principal?.Identities?.FirstOrDefault().Claims.FirstOrDefault()?.Value);
}
var ciclolog = new CicloLog
{
id_ciclo = model.id,
situacao = model.situacao,
id_usuario = model.id_usuario
};
_repository.InserirLogCiclo(ibge, ciclolog);
return(Ok(model));
}
catch (Exception ex)
{
var response = TrataErro.GetResponse(ex.Message, true);
return(StatusCode((int)HttpStatusCode.InternalServerError, response));
}
}
public IHttpActionResult PostCiclo(Ciclo ciclo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
DateTime data = new DateTime(ciclo.DataInicio.Year, ciclo.DataInicio.Month, 1);
DateTime fim = new DateTime(ciclo.DataFim.Year, ciclo.DataFim.Month, 1);
while (data <= fim)
{
db.MesOrcamento.Add(new MesOrcamento {
});
}
db.Entry(ciclo).State = EntityState.Added;
db.SaveChanges();
db.Entry(ciclo).State = EntityState.Detached;
return(CreatedAtRoute("DefaultApi", new { id = ciclo.Codigo }, new CicloDTO(db.Ciclo.Find(ciclo.Codigo))));
}
public ActionResult Crear(CicloViewModel cvm)
{
try
{
if (!ModelState.IsValid)
{
/* pvm.TipoPersonas = _ctx.TipoPersonas.ToList();
* return View("FormPersona", pvm);*/
cvm.modalidadList = _ctx.Modalidades.ToList();
//Algo estuvo mal.
return(View("FormCiclo", cvm));
}
if (cvm.Id == 0)
{
Ciclo c = new Ciclo();
c.fecha_inicio = cvm.fecha_inicio;
c.fecha_fin = cvm.fecha_fin;
c.ModalidadId = cvm.ModalidadId.Value;
_ctx.Ciclos.Add(c);
}
else
{
//Estan editando
var cicloExistente = _ctx.Ciclos.SingleOrDefault(x => x.Id == cvm.Id);
if (cicloExistente != null)
{
cicloExistente.fecha_inicio = cvm.fecha_inicio;
cicloExistente.fecha_fin = cvm.fecha_fin;
cicloExistente.ModalidadId = cvm.ModalidadId.Value;
}
}
}
catch
{
return(View());
}
_ctx.SaveChanges();
return(RedirectToAction("Index"));
}
public List <Ciclo> SeleccionarTodos()
{
// SqlConnection requiere el using System.Data.SqlClient;
SqlConnection conexion = new SqlConnection(Conexion.Cadena);
List <Ciclo> lista = new List <Ciclo>();
try
{
conexion.Open(); // un error aca: revisar cadena de conexion
// El command permite ejecutar un comando en la conexion establecida
SqlCommand comando = new SqlCommand("PA_SeleccionarCiclo", conexion);
// Como es en Store Procedure se debe indicar el tipo de comando
comando.CommandType = System.Data.CommandType.StoredProcedure;
// NO recibe parametros
// Finalmente ejecutamos el comando
// al ser una consulta debemos usar ExecuteReader
SqlDataReader reader = comando.ExecuteReader();
// es necesario recorrer el reader para extraer todos los registros
while (reader.Read()) // cada vez que se llama el Read retorna una tupla
{
Ciclo s = new Ciclo();
s.Id = Convert.ToInt32(reader["Id"]);
s.Nombre = reader["Nombre"].ToString();
lista.Add(s);
}
}
catch (Exception)
{
throw;
}
finally
{
conexion.Close();
}
return(lista);
}
/// <summary>
/// Salvamento do Cancelamento do Ciclo
/// </summary>
/// <param name="sender">Objeto</param>
/// <param name="e">Evento</param>
private void ButtonOK_Click(object sender, EventArgs e)
{
if (lookUpEditMotivo.EditValue != null)
{
ProjetoUltimoFiltro.RnSetUltimoMotivoCancelamento(Session, Ciclo.Projeto,
(MotivoCancelamento)lookUpEditMotivo.EditValue);
}
else
{
XtraMessageBox.Show(CicloDesenv.RnValidarMotivoCancelamento(null), "Erro",
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error,
System.Windows.Forms.MessageBoxDefaultButton.Button1);
return;
}
DateTime data = DateTime.MinValue;
string erro;
if (DtInicioProxCiclo.Visible && DtInicioProxCiclo.Enabled)
{
data = DtInicioProxCiclo.DateTime;
erro = Ciclo.RnDataProximoCiclo(data);
if (!string.IsNullOrEmpty(erro))
{
XtraMessageBox.Show(erro, "Erro",
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error,
System.Windows.Forms.MessageBoxDefaultButton.Button1);
return;
}
}
Ciclo.CsSituacaoCiclo = CsSituacaoCicloDomain.Cancelado;
IsCancel = false; // Indica que não foi cancelado
Ciclo.RnCancelarCiclo(lookUpEditMotivo.EditValue as MotivoCancelamento, data);
Close();
}
//=== NEW CICLE
public void StartNewCicle()
{
//Encuentro el ciclo actual y lo cierro
ultimoCiclo.Cerrado = true;
Ciclo nuevoCiclo = new Ciclo {
Cerrado = false
};
//Add to db
rubroDB.Ciclos.InsertOnSubmit(nuevoCiclo);
rubroDB.SubmitChanges();
//Add to collection
Ciclos.Add(nuevoCiclo);
//Llamada a NewCiclce_DuplicateRubros
NewCicle_DuplicateRubros(ultimoCiclo, Ciclos.Last());
//Actualizo variable cicloActual
ultimoCiclo = nuevoCiclo;
//Vuelvo a consultar la bd
LoadCollectionsFromDatabase();
}
public string Guardar(Actividad entidad)
{
string Mensaje = "OK";
//Se obtiene el ciclo actual del colegio
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == entidad.ColegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
entidad.CicloId = CicloActual.CicloId;
}
else
{
return("Se le informa que el colegio no tiene activado el ciclo escolar");
}
if (entidad.ActividadId == 0)
{
Mensaje = Agregar(entidad);
}
return(Mensaje);
}
// GET: api/ValoresAbertosCRs
public IEnumerable <ValoresAbertosCRDTO> GetValoresAbertosCR(string cr = null, string codEvento = null, int?codCiclo = null)
{
if (cr != null && codEvento != null && codCiclo != null)
{
IEnumerable <ValoresAbertosCRDTO> lista = new HashSet <ValoresAbertosCRDTO>();
Ciclo ciclo = db.Ciclo.Find(codCiclo);
if (ciclo == null)
{
return(null);
}
foreach (MesOrcamento m in ciclo.MesesOrcamento)
{
ValoresAbertosCR v = db.ValoresAbertosCR.Find(codEvento, m.Codigo, cr);
if (v == null)
{
((HashSet <ValoresAbertosCRDTO>)lista).Add(new ValoresAbertosCRDTO
{
CodEvento = codEvento,
CodMesOrcamento = m.Codigo,
CodigoCR = cr,
Valor = 0
});
}
else
{
((HashSet <ValoresAbertosCRDTO>)lista).Add(new ValoresAbertosCRDTO(v));
}
}
return(lista);
}
return(db.ValoresAbertosCR.ToList()
.Where(x => (cr == null || x.CodigoCR == cr) && (codCiclo == null || x.MesOrcamento.CicloCod == codCiclo) && (codEvento == null || x.CodEvento == codEvento))
.Select(x => new ValoresAbertosCRDTO(x)));
}
/// <summary>
/// Ativa a função RnCriarEstoriaID ao clicar no botão save
/// </summary>
protected override void OnSaving()
{
if (Oid.Equals(new Guid()) || estoriaPaiOld != EstoriaPai ||
(moduloOld != null && moduloOld != Modulo))
{
RnCriarEstoriaID();
}
RnSetarPrioridadeZeroComFilhos();
if (NbPrioridade > 0 && _NbPrioridadeOld > 0)
{
OrdenacaoUtil.RnAplicarOrdenacao(this);
}
else if (_NbPrioridadeOld == 0 && NbPrioridade >= 1 &&
Oid != new Guid() && CsSituacao != CsEstoriaDomain.Pronto)
{
// Utilizado quando a entrega é removida(replanejada) de um ciclo
// e retorna para o backlog. Ou seja, ela desce da prioridade 0 para 1.
OrdenacaoUtil.RnRepriorizar(this, CsOrdenacaoDomain.DescerOrdem);
}
if (estoriaPai != null)
{
GetSomaEstoriasFilhas();
}
// Chamada do método para recálculo dos pontos do ciclo
if (Ciclo != null && !Oid.Equals(new Guid()))
{
Ciclo.RnCalcularPontosPlanejadosERealizados();
Ciclo.Save();
}
base.OnSaving();
}
public GradoModel ObtenerEncabezadoGrado(long gradoId, long seccionId, long colegioId)
{
GradoModel GradoActual = new GradoModel();
try
{
//Se obtiene el ciclo actual del colegio
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == colegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
GradoActual = db.Database.SqlQuery <GradoModel>("dbo.sp_consulta_encabezado_grado @ColegioId, @CicloId, @GradoId, @SeccionId", new SqlParameter("@ColegioId", colegioId), new SqlParameter("@CicloId", CicloActual.CicloId), new SqlParameter("@GradoId", gradoId), new SqlParameter("@SeccionId", seccionId)).FirstOrDefault();
if (GradoActual != null)
{
GradoActual.Alumnos = new List <AlumnoxGrado>();
GradoActual.Alumnos = db.Database.SqlQuery <AlumnoxGrado>("dbo.sp_consulta_alumno_x_grado @ColegioId, @GradoId, @SeccionId, @CicloId", new SqlParameter("@ColegioId", colegioId), new SqlParameter("@GradoId", gradoId), new SqlParameter("@SeccionId", seccionId), new SqlParameter("@CicloId", CicloActual.CicloId)).ToList();
}
}
}
catch (Exception)
{ }
return(GradoActual);
}
public CursoModel ObtenerCuadroxCurso(long gradoId, long seccionId, long cursoId, long colegioId)
{
CursoModel CursoActual = new CursoModel();
try
{
//Se obtiene el ciclo actual del colegio
Ciclo CicloActual = db.Set <Ciclo>().AsNoTracking().Where(x => x.ColegioId == colegioId && x.Activo).OrderByDescending(x => x.Fecha).ThenByDescending(x => x.CicloId).FirstOrDefault();
if (CicloActual != null)
{
CursoActual = db.Database.SqlQuery <CursoModel>("dbo.sp_consulta_detalle_curso_x_grado @ColegioId, @GradoId, @SeccionId, @CursoId, @CicloId", new SqlParameter("@ColegioId", colegioId), new SqlParameter("@GradoId", gradoId), new SqlParameter("@SeccionId", seccionId), new SqlParameter("@CursoId", cursoId), new SqlParameter("@CicloId", CicloActual.CicloId)).FirstOrDefault();
if (CursoActual != null)
{
CursoActual.Cuadros = new List <CuadroxCursoModel>();
CursoActual.Cuadros = db.Database.SqlQuery <CuadroxCursoModel>("dbo.sp_consulta_cuadro_x_curso @ColegioId, @CursoId, @GradoId, @SeccionId, @CicloId", new SqlParameter("@ColegioId", colegioId), new SqlParameter("@CursoId", CursoActual.CursoId), new SqlParameter("@GradoId", CursoActual.GradoId), new SqlParameter("@SeccionId", CursoActual.SeccionId), new SqlParameter("@CicloId", CicloActual.CicloId)).ToList();
}
}
}
catch (Exception)
{ }
return(CursoActual);
}
public List <Ciclo> GetCiclos()
{
int Id = 1;;
List <Ciclo> ciclos = new List <Ciclo>();
SqlConnection con = new SqlConnection(Conexion_global.strConexion);
SqlCommand cmdc = new SqlCommand("ListadoCiclo", con);
cmdc.CommandType = CommandType.StoredProcedure;
cmdc.Parameters.Add(new SqlParameter("@Id", Id));
con.Open();
var registros = cmdc.ExecuteReader();
while (registros.Read())
{
Ciclo art = new Ciclo
{
Idciclo = int.Parse(registros["Idciclo"].ToString()),
Nomciclo = registros["NomCiclo"].ToString()
};
ciclos.Add(art);
}
con.Close();
return(ciclos);
}
/// <summary>
/// Guarda la ventas en la base de datos
/// </summary>
/// <param name="ventas">lista de ventas a grabar</param>
public void GuardarVentas(List<VENTA> ventas, bool esCorporacion)
{
try
{
Guid idLaboratorio = ventas[0].IDLABORATORIO;
DateTime fechaVenta = ventas[0].FECHA;
Ciclo ciclo = null;
int existeVenta = 0;
List<Guid> idLabs = null;
List<VENTA> ventasBorrar = null;
using (DQBaseContext context = new DQBaseContext(ConnectionString))
{
using (TransactionScope transaction=new TransactionScope())
{
if (esCorporacion)
{
idLabs=new List<Guid>(ventas.Select(x => x.IDLABORATORIO));
existeVenta = (from venta in context.VENTA
where idLabs.Contains(venta.IDLABORATORIO)
&& venta.FECHA == fechaVenta
select venta).Count();
}
else
{
existeVenta = (from venta in context.VENTA
where venta.IDLABORATORIO == idLaboratorio
&& venta.FECHA == fechaVenta
select venta).Count();
}
if (existeVenta == 0)
{
ventas.ForEach(venta =>
{
context.VENTA.ApplyChanges(venta);
});
context.SaveChanges();
bool existeCiclo = (from cic in context.Ciclo
where cic.FechaCiclo == fechaVenta
select cic).Any();
if (!existeCiclo)
{
ciclo = new Ciclo
{
IdCiclo = Guid.NewGuid(),
FechaCiclo = fechaVenta,
EsBorrado=false,
};
context.Ciclo.ApplyChanges(ciclo);
context.SaveChanges();
}
transaction.Complete();
}
else
{
var cicloVenta = context.Ciclo.FirstOrDefault(x => x.FechaCiclo == fechaVenta);
if (cicloVenta.EsPublicado) throw new Exception("La ventas no pueden ser publicadas");
if (esCorporacion)
{
idLabs = new List<Guid>(ventas.Select(x => x.IDLABORATORIO));
ventasBorrar = (from venta in context.VENTA
where idLabs.Contains(venta.IDLABORATORIO)
&& venta.FECHA == fechaVenta
select venta).ToList();
}
else
{
ventasBorrar = (from venta in context.VENTA
where venta.IDLABORATORIO == idLaboratorio
&& venta.FECHA == fechaVenta
select venta).ToList();
}
ventasBorrar.ForEach(venta =>
{
context.VENTA.DeleteObject(venta);
});
ventas.ForEach(venta =>
{
context.VENTA.ApplyChanges(venta);
});
context.SaveChanges();
transaction.Complete();
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
