public static void DeletePrograma(Programa p, LainsaSci ctx)
{
// buscamos las revisiones programadas que corresponde a
// este programa
var rs = (from rev1 in p.Revisions
where rev1.Estado == "PROGRAMADA"
select rev1);
// primero desprogramamos las revisiones
foreach (Revision r in rs)
{
r.Estado = "PLANIFICADA";
r.Programa = null;
ctx.SaveChanges();
// ahora buscamos revisiones del mismo dispositivo programadas
var rs2 = (from rev2 in r.Dispositivo.Revisiones
where rev2.Estado == "PROGRAMADA"
select rev2);
foreach (Revision r2 in rs2)
{
r2.Estado = "PLANIFICADA";
r2.Programa = null;
ctx.SaveChanges();
}
}
foreach (Sustitucion s in p.Sustitucions)
{
ctx.Delete(s);
}
ctx.Delete(p);
ctx.SaveChanges();
}
public static void DelProceso(Proceso proc, LainsaSci ctx)
{
Permiso per = (from p in ctx.Permisos
where p.Proceso == proc
select p).FirstOrDefault <Permiso>();
ctx.Delete(per);
ctx.Delete(proc);
}
public static void DeleteRevision(Revision r, LainsaSci ctx)
{
// primero eliminamos sus datos
ctx.Delete(r.DatosRevisions);
// y ahora la revisón
ctx.Delete(r);
// ok y guardamos
ctx.SaveChanges();
}
public static void BorrarDispositivo(Dispositivo dsp, LainsaSci ctx)
{
foreach (Revision rev in dsp.Revisiones)
{
ctx.Delete(rev.DatosRevisions);
}
ctx.Delete(dsp.Revisiones);
ctx.Delete(dsp.ResumenesRevisones);
ctx.Delete(dsp);
ctx.SaveChanges();
}
private void GuardarIncidenciaEvolucions(TIncidencia ti, Incidencia inci, SqlCeConnection conn, LainsaSci ctx)
{
IList <TIncidenciaEvolucion> ltie = CntSciTerminal.GetTIncidenciaEvolucions(ti, conn);
foreach (TIncidenciaEvolucion tie in ltie)
{
if (tie.Abm == 0)
{
continue; // no cambiada
}
switch (tie.Abm)
{
case 1:
// alta
// aqui no verificamos un doble pase de fcihero porque lo ha sido en la
// incidencia padre.
IncidenciaEvolucion ie = new IncidenciaEvolucion();
ie.Incidencia = inci; // en esta rutina la incidencia es conocida
ie.FechaEvolucion = tie.FechaEvolucion;
ie.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
ie.Comentarios = tie.Comentarios;
ie.Operativo = tie.Operativo;
ctx.Add(ie);
break;
case 2:
// baja
IncidenciaEvolucion ie2 = CntLainsaSci.GetIncidenciaEvolucion(tie.IncidenciaEvolucionId, ctx);
if (ie2 != null)
{
ctx.Delete(ie2);
}
break;
case 3:
// modificada
// este caso no debería darse pero por si acaso
IncidenciaEvolucion ie3 = CntLainsaSci.GetIncidenciaEvolucion(tie.IncidenciaEvolucionId, ctx);
if (ie3 != null)
{
Incidencia i3 = CntLainsaSci.GetIncidencia(tie.Incidencia.IncidenciaId, ctx);
ie3.Incidencia = i3;
ie3.FechaEvolucion = tie.FechaEvolucion;
ie3.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
ie3.Comentarios = tie.Comentarios;
ie3.Operativo = tie.Operativo;
}
break;
default:
break;
}
ctx.SaveChanges();
}
}
// guardar las evoluciones relacionadas con una incidencia.
private void GuardarIncidenciaEvolucion(TIncidencia ti, int abm, SqlCeConnection conn, LainsaSci ctx)
{
Incidencia incidencia = CntLainsaSci.GetIncidencia(ti.IncidenciaId, ctx);
if (incidencia == null)
{
return;
}
// caso de las bajas, se eliminan todas las asociadas.
if (abm == 2)
{
ctx.Delete(incidencia.IncidenciaEvolucions);
}
else
{
IncidenciaEvolucion ie;
IList <TIncidenciaEvolucion> tlie = CntSciTerminal.GetTIncidenciaEvolucions(ti, conn);
foreach (TIncidenciaEvolucion tie in tlie)
{
if (tie.Abm == 0)
{
continue;
}
switch (tie.Abm)
{
case 1:
// alta
ie = new IncidenciaEvolucion();
ie.Incidencia = incidencia;
ie.FechaEvolucion = tie.FechaEvolucion;
ie.Comentarios = tie.Comentarios;
ie.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
ctx.Add(ie);
break;
case 2:
// baja
// ya ha sido tratado en un paso anterior.
break;
case 3:
// modificación
ie = CntLainsaSci.GetIncidenciaEvolucion(tie.IncidenciaEvolucionId, ctx);
ie.FechaEvolucion = tie.FechaEvolucion;
ie.Comentarios = tie.Comentarios;
ie.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
break;
default:
break;
}
}
}
}
public static void EliminarRevisionesPendientes(Dispositivo d, LainsaSci ctx)
{
var rs = (from r in ctx.Revisions
where r.Dispositivo.DispositivoId == d.DispositivoId &&
r.Estado != "REALIZADA"
select r);
foreach (Revision r in rs)
{
ctx.Delete(r.DatosRevisions);
ctx.Delete(r.Sustitucions);
}
ctx.Delete(rs);
// al haber eliminado todas las revisiones lo lógico es que los resúmenes
// tengan fecha de siguiente nula
foreach (ResumenRevision rr in d.ResumenesRevisones)
{
rr.FechaSiguiente = new DateTime(1, 1, 1);
}
ctx.SaveChanges();
}
public static void DeleteGrupoTrabajo(GrupoTrabajo gt, LainsaSci ctx)
{
if (gt.Usuarios != null)
{
foreach (Usuario u in gt.Usuarios)
{
u.GrupoTrabajo = null;
}
}
ctx.Delete(gt);
ctx.SaveChanges();
}
protected void btnEliminar_Click(object sender, EventArgs e)
{
if (txtFiltro.Text != "")
{
Filtro f = CntLainsaSci.GetFiltro("Incidencia", txtFiltro.Text, usuario, ctx);
if (f != null)
{
string nom = f.Nombre;
ctx.Delete(f);
ctx.SaveChanges();
CargarFiltros(null);
rdcFiltro.SelectedValue = "";
RadNotification1.Text = String.Format("El filtro '{0}' ha sido eliminado", nom);
RadNotification1.Show();
}
}
}
private void GuardarDispositivos(SqlCeConnection conn)
{
IList <TDispositivo> disps = CntSciTerminal.GetTDispositivos(conn);
RadProgressContext context = RadProgressContext.Current;
context.PrimaryTotal = 1;
context.PrimaryValue = 1;
context.PrimaryPercent = 100;
int total = disps.Count;
context.SecondaryTotal = total;
int i = 0;
foreach (TDispositivo disp in disps)
{
i++;
if (disp.Abm == 0)
{
continue;
}
RadProgress(context, i, total, disp.Nombre);
// hay tres casos posible segun el valor de ABM
// 0 = No cambia
// 1 = nuevo
// 2 = baja
// 3 = modificación
Dispositivo dispositivo;
switch (disp.Abm)
{
case 1:
// nuevo
// primero comprobamos que ese dispositivo no se ha dado de alta previamente
Dispositivo dsp = (from d in ctx.Dispositivos
where d.CodBarras == disp.CodBarras
select d).FirstOrDefault <Dispositivo>();
if (dsp != null)
{
break; // ya existe han cargado dos veces el fichero.
}
dispositivo = new Dispositivo();
dispositivo.Nombre = disp.Nombre;
dispositivo.Instalacion = CntLainsaSci.GetInstalacion(disp.Instalacion.InstalacionId, ctx);
dispositivo.Operativo = disp.Operativo;
dispositivo.TipoDispositivo = CntLainsaSci.GetTipoDispositivo(disp.Tipo.TipoId, ctx);
if (disp.Modelo != null)
{
dispositivo.ModeloDispositivo = CntLainsaSci.GetModelodispositivo(disp.Modelo.ModeloId, ctx);
}
dispositivo.CodBarras = disp.CodBarras;
dispositivo.Funcion = "";
dispositivo.Estado = disp.Estado;
dispositivo.Caducado = false;
dispositivo.CargaKg = 0;
ctx.Add(dispositivo);
break;
case 2:
// baja
dispositivo = CntLainsaSci.GetDispositivo(disp.DispositivoId, ctx);
if (dispositivo != null)
{
ctx.Delete(dispositivo);
}
break;
case 3:
// modificación
dispositivo = CntLainsaSci.GetDispositivo(disp.DispositivoId, ctx);
if (dispositivo != null)
{
dispositivo.Operativo = disp.Operativo;
dispositivo.Estado = disp.Estado;
}
break;
default:
break;
}
ctx.SaveChanges();
}
context.CurrentOperationText = "Importación finalizada.";
context.OperationComplete = true;
}
public static void CTXEliminar(Object o, LainsaSci ctx)
{
ctx.Delete(o);
}
public static void DeleteGrupoUsuario(GrupoUsuario gu, LainsaSci ctx)
{
ctx.Delete(gu.Permisos);
ctx.Delete(gu);
ctx.SaveChanges();
}
//
private void GuardarIncidenciaEvolucions(SqlCeConnection conn, LainsaSci ctx)
{
IList <TIncidenciaEvolucion> ltie = CntSciTerminal.GetTIncidenciaEvolucions(conn);
foreach (TIncidenciaEvolucion tie in ltie)
{
if (tie.Abm == 0)
{
continue; // no cambiada
}
if (tie.Incidencia.Abm == 1)
{
continue; // las evoluciones de las incidencias creadas ya han sido procesadas (GuardarIncidencias)
}
switch (tie.Abm)
{
case 1:
// alta
// primero evitar un doble procesamiento
IncidenciaEvolucion ie1 = (from ine in ctx.IncidenciaEvolucions
where ine.Incidencia.IncidenciaId == tie.Incidencia.IncidenciaId &&
ine.FechaEvolucion == tie.FechaEvolucion &&
ine.Comentarios == tie.Comentarios
select ine).FirstOrDefault <IncidenciaEvolucion>();
if (ie1 != null)
{
break; // la evolución entendemos que ya ha sido dada de alta
}
IncidenciaEvolucion ie = new IncidenciaEvolucion();
Incidencia i = CntLainsaSci.GetIncidencia(tie.Incidencia.IncidenciaId, ctx);
ie.Incidencia = i;
ie.FechaEvolucion = tie.FechaEvolucion;
ie.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
ie.Comentarios = tie.Comentarios;
ie.Operativo = tie.Operativo;
ctx.Add(ie);
break;
case 2:
// baja
IncidenciaEvolucion ie2 = CntLainsaSci.GetIncidenciaEvolucion(tie.IncidenciaEvolucionId, ctx);
if (ie2 != null)
{
ctx.Delete(ie2);
}
break;
case 3:
// modificada
IncidenciaEvolucion ie3 = CntLainsaSci.GetIncidenciaEvolucion(tie.IncidenciaEvolucionId, ctx);
if (ie3 != null)
{
Incidencia i3 = CntLainsaSci.GetIncidencia(tie.Incidencia.IncidenciaId, ctx);
ie3.Incidencia = i3;
ie3.FechaEvolucion = tie.FechaEvolucion;
ie3.Usuario = CntLainsaSci.GetUsuario(tie.Usuario.UsuarioId, ctx);
ie3.Comentarios = tie.Comentarios;
ie3.Operativo = tie.Operativo;
}
break;
default:
break;
}
ctx.SaveChanges();
}
}
// lee secuancialmente las incidencias del fichero de terminal y las guarda en la base de datos
private void GuardarIncidencias(SqlCeConnection conn, LainsaSci ctx)
{
IList <TIncidencia> lti = CntSciTerminal.GetTIncidencias(conn);
Incidencia incidencia;
foreach (TIncidencia ti in lti)
{
// no ha sufrido cambios
if (ti.Abm == 0)
{
continue;
}
switch (ti.Abm)
{
case 1:
// alta
// comprobar que no se ha dado de alta previamente
// es el caso de recarga del mismo fichero
Incidencia inci = (from i in ctx.Incidencias
where i.Dispositivo.DispositivoId == ti.TDispositivo.DispositivoId &&
i.FechaApertura == ti.FechaApertura &&
i.Comentarios == ti.Comentarios
select i).FirstOrDefault <Incidencia>();
if (inci != null)
{
break;
}
incidencia = new Incidencia();
incidencia.FechaApertura = ti.FechaApertura;
incidencia.FechaPrevista = ti.FechaPrevista;
incidencia.FechaCierre = ti.FechaCierre;
incidencia.Dispositivo = CntLainsaSci.GetDispositivo(ti.TDispositivo.DispositivoId, ctx);
if (ti.TEstado != null)
{
incidencia.Estado = CntLainsaSci.GetEstado(ti.TEstado.EstadoId, ctx);
}
if (ti.TPrioridad != null)
{
incidencia.Prioridad = CntLainsaSci.GetPrioridad(ti.TPrioridad.PrioridadId, ctx);
}
if (ti.TResponsable != null)
{
incidencia.Responsable = CntLainsaSci.GetResponsable(ti.TResponsable.ResponsableId, ctx);
}
incidencia.Usuario = CntLainsaSci.GetUsuario(ti.TUsuario.UsuarioId, ctx);
incidencia.Comentarios = ti.Comentarios;
incidencia.Operativo = ti.Operativo;
incidencia.SiguePlan = true; // hasta que no se cambie el programa de terminal para que contemple ese campo.
ctx.Add(incidencia);
ctx.SaveChanges();
// Si es un alta hay que verificar que las evoluciones asociadas se cree contra
// la incidencia de servidor correcta.
GuardarIncidenciaEvolucions(ti, incidencia, conn, ctx);
break;
case 2:
incidencia = CntLainsaSci.GetIncidencia(ti.IncidenciaId, ctx);
if (incidencia != null)
{
ctx.Delete(incidencia.IncidenciaEvolucions);
ctx.SaveChanges();
ctx.Delete(incidencia);
ctx.SaveChanges();
}
break;
case 3:
incidencia = CntLainsaSci.GetIncidencia(ti.IncidenciaId, ctx);
incidencia.FechaApertura = ti.FechaApertura;
incidencia.FechaPrevista = ti.FechaPrevista;
incidencia.FechaCierre = ti.FechaCierre;
incidencia.Dispositivo = CntLainsaSci.GetDispositivo(ti.TDispositivo.DispositivoId, ctx);
if (ti.TEstado != null)
{
incidencia.Estado = CntLainsaSci.GetEstado(ti.TEstado.EstadoId, ctx);
}
if (ti.TPrioridad != null)
{
incidencia.Prioridad = CntLainsaSci.GetPrioridad(ti.TPrioridad.PrioridadId, ctx);
}
if (ti.TResponsable != null)
{
incidencia.Responsable = CntLainsaSci.GetResponsable(ti.TResponsable.ResponsableId, ctx);
}
incidencia.Usuario = CntLainsaSci.GetUsuario(ti.TUsuario.UsuarioId, ctx);
incidencia.Comentarios = ti.Comentarios;
incidencia.Operativo = ti.Operativo;
break;
default:
break;
}
ctx.SaveChanges();
}
}
protected void GuardarSustituciones(SqlCeConnection conn, LainsaSci ctx)
{
IList <TSustitucion> ltsu = CntSciTerminal.GetTSustituciones(conn);
foreach (TSustitucion tsu in ltsu)
{
if (tsu.Abm == 0)
{
continue; // no hay cambios
}
Sustitucion sustitucion;
switch (tsu.Abm)
{
case 1:
// alta
// hay que controlar el doble procesamiento del fichero
Sustitucion sus = (from st in ctx.Sustitucions
where st.DispositivoOriginal.DispositivoId == tsu.TDispositivoOriginal.DispositivoId &&
st.DispositivoSustituto.DispositivoId == tsu.TDispositivoSustituto.DispositivoId &&
st.Fecha == tsu.Fecha
select st).FirstOrDefault <Sustitucion>();
if (sus != null)
{
break; // entendemos que ya se ha dado de alta en otro procesamiento.
}
sustitucion = new Sustitucion();
// atributos directos
sustitucion.Fecha = tsu.Fecha;
sustitucion.Comentarios = tsu.Comentarios;
sustitucion.Estado = tsu.Estado;
// atributos como objetos
if (tsu.TUsuario != null)
{
sustitucion.Usuario = CntLainsaSci.GetUsuario(tsu.TUsuario.UsuarioId, ctx);
}
if (tsu.TDispositivoOriginal != null)
{
sustitucion.DispositivoOriginal = CntLainsaSci.GetDispositivo(tsu.TDispositivoOriginal.DispositivoId, ctx);
}
if (tsu.TDispositivoSustituto != null)
{
sustitucion.DispositivoSustituto = CntLainsaSci.GetDispositivo(tsu.TDispositivoSustituto.DispositivoId, ctx);
}
if (tsu.TRevision != null)
{
sustitucion.Revision = CntLainsaSci.GetRevision(tsu.TRevision.RevisionId, ctx);
}
if (tsu.TPrograma != null)
{
sustitucion.Programa = CntLainsaSci.GetPrograma(tsu.TPrograma.ProgramaId, ctx);
}
ctx.Add(sustitucion);
ctx.SaveChanges();
break;
case 2:
// baja
sustitucion = CntLainsaSci.GetSustitucion(tsu.SustitucionId, ctx);
if (sustitucion != null)
{
ctx.Delete(sustitucion);
ctx.SaveChanges();
}
break;
case 3:
// modificacion
sustitucion = CntLainsaSci.GetSustitucion(tsu.SustitucionId, ctx);
if (sustitucion != null)
{
// atributos directos
sustitucion.Fecha = tsu.Fecha;
sustitucion.Comentarios = tsu.Comentarios;
sustitucion.Estado = tsu.Estado;
// atributos como objetos
if (tsu.TUsuario != null)
{
sustitucion.Usuario = CntLainsaSci.GetUsuario(tsu.TUsuario.UsuarioId, ctx);
}
if (tsu.TDispositivoOriginal != null)
{
sustitucion.DispositivoOriginal = CntLainsaSci.GetDispositivo(tsu.TDispositivoOriginal.DispositivoId, ctx);
}
if (tsu.TDispositivoSustituto != null)
{
sustitucion.DispositivoSustituto = CntLainsaSci.GetDispositivo(tsu.TDispositivoSustituto.DispositivoId, ctx);
}
if (tsu.TRevision != null)
{
sustitucion.Revision = CntLainsaSci.GetRevision(tsu.TRevision.RevisionId, ctx);
}
if (tsu.TPrograma != null)
{
sustitucion.Programa = CntLainsaSci.GetPrograma(tsu.TPrograma.ProgramaId, ctx);
}
ctx.SaveChanges();
}
break;
}
}
}
public static void BorrarTerminal(Terminal t, LainsaSci ctx)
{
t.Programas.Clear();
ctx.Delete(t);
}
public static void PlanificarRevisiones(ResumenRevision rr, LainsaSci ctx)
{
// Hay que evitar que un dispositivo que no sigue planificación planifique.
if (!rr.Dispositivo.Operativo && !rr.Dispositivo.SiguePlan)
{
return;
}
// NO se planifican dispositivos caducados
if (rr.Dispositivo.Caducado)
{
return;
}
// Eliminar todas las revisiones de ese dispositivo para esa plantilla, no realizadas
var rs = from r in rr.Dispositivo.Revisiones
where r.PlantillaRevision.PlantillaId == rr.PlantillaRevision.PlantillaId
select r;
IList <Revision> revisiones = new List <Revision>();
foreach (Revision r in rs)
{
if (CntLainsaSci.FechaNula(r.FechaRevision))
{
// hay que salvar las programadas para poder recargarlas
if (r.Programa != null)
{
Revision rev = new Revision
{
Dispositivo = r.Dispositivo,
PlantillaRevision = r.PlantillaRevision,
FechaPlanificada = r.FechaPlanificada,
Programa = r.Programa,
FechaProgramada = r.FechaPlanificada
};
revisiones.Add(rev);
}
ctx.Delete(r.DatosRevisions);
ctx.Delete(r.Sustitucions);
ctx.Delete(r);
}
}
ctx.SaveChanges();
if (CntLainsaSci.FechaNula(rr.FechaUltima))
{
return;
}
DateTime fechaBase = rr.FechaUltima;
DateTime fechaSiguiente = SiguienteFecha(fechaBase, rr.PlantillaRevision);
// buscamos si ya había una revisión que coincida con la que vamos a dar de alta
Revision rev2 = (from r in ctx.Revisions
where r.Dispositivo.DispositivoId == rr.Dispositivo.DispositivoId && r.PlantillaRevision.PlantillaId == rr.PlantillaRevision.PlantillaId && r.FechaRevision == fechaSiguiente && r.Dispositivo.Operativo == true
select r).FirstOrDefault <Revision>();
if (rev2 == null)
{
rev2 = new Revision();
rev2.Dispositivo = rr.Dispositivo;
rev2.FechaPlanificada = fechaSiguiente;
// Comprobamos si caemos en caducidad
if (fechaSiguiente >= rev2.Dispositivo.FechaCaducidad)
{
rev2.CaduProx = true;
}
else
{
// calculamos en que fecha caerá la siguiente y si es fuera de caducidad
DateTime fechaSS = SiguienteFecha(fechaSiguiente, rr.PlantillaRevision);
if (fechaSS >= rev2.Dispositivo.FechaCaducidad)
{
rev2.CaduProx = true;
}
}
rev2.PlantillaRevision = rr.PlantillaRevision;
rev2.Estado = "PLANIFICADA";
//Respetamos la programación en función de las revisiones anteriores
foreach (Revision r in revisiones)
{
if (r.Dispositivo.DispositivoId == rev2.Dispositivo.DispositivoId && r.PlantillaRevision.PlantillaId == rev2.PlantillaRevision.PlantillaId && r.FechaPlanificada == rev2.FechaPlanificada)
{
rev2.Programa = r.Programa;
rev2.FechaProgramada = r.FechaProgramada;
rev2.Estado = "PROGRAMADA";
r.Programa.Revisions.Add(rev2);
}
}
ctx.Add(rev2);
// buscamos la revisión anterior que tenga datos
Revision rva = (from rv in ctx.Revisions
where rv.Dispositivo.DispositivoId == rev2.Dispositivo.DispositivoId &&
rv.PlantillaRevision.PlantillaId == rev2.PlantillaRevision.PlantillaId &&
rv.Estado == "REALIZADA" &&
rv.FechaRevision < rev2.FechaPlanificada
select rv).FirstOrDefault <Revision>();
foreach (Campo c in rr.PlantillaRevision.Campos)
{
DatosRevision dr = new DatosRevision();
dr.Campo = c;
// si hay anterior copiamos
if (rva != null)
{
DatosRevision dr2 = (from d in rva.DatosRevisions
where d.Campo.Nombre == c.Nombre
select d).FirstOrDefault <DatosRevision>();
if (dr2 != null)
{
dr.Valor = dr2.Valor;
}
}
dr.Revision = rev2;
ctx.Add(dr);
}
ctx.SaveChanges();
}
// Actualizamos la fecha siguiente en esta plantilla
rr.FechaSiguiente = fechaSiguiente;
ctx.SaveChanges();
}
