public static void EliminarPendientesDispositivo(Dispositivo dsp, LainsaSci ctx)
{
if (!dsp.Caducado)
{
return;
}
if (CntLainsaSci.FechaNula(dsp.FechaBaja))
{
return;
}
var rs = (from r in dsp.Revisiones
where r.FechaPlanificada >= dsp.FechaBaja
select r);
foreach (Revision r in rs)
{
DeleteRevision(r, ctx);
}
}
public static Usuario Login(string login, string password, LainsaSci ctx)
{
// (1) Leemos el usuario al que pertenece ese login
Usuario u = CntLainsaSci.GetUsuario(login, ctx);
// (1.1) Si no existe devolvemos nulo
if (u == null)
{
return(null);
}
// (2) Comprobamos si la contraseña coincide.
if (u.Password == GetHashCode(password))
{
return(u); // (2.1) contraseña correcta
}
else
{
return(null); // (2.2) contraseña incorrecta
}
}
public static void ProgramarInferiores(Revision rev, LainsaSci ctx)
{
int peso = 0;
//
peso = CalculoPeso(rev.PlantillaRevision.TipoPeriodo);
peso = peso * rev.PlantillaRevision.NumeroPeriodos;
// buscamos que para la fecha indicada no haya planificada una de periodicidad superior
int peso2 = 0;
foreach (PlantillaRevision pr in rev.Dispositivo.TipoDispositivo.PlantillaRevisions)
{
peso2 = CalculoPeso(pr.TipoPeriodo) * pr.NumeroPeriodos;
if (peso2 < peso)
{
// fake: una revisión de periodo inferior como si se hubiera hecho en la misma fecha
Revision rev2 = new Revision()
{
FechaRevision = rev.FechaRevision,
Dispositivo = rev.Dispositivo,
PlantillaRevision = pr,
Estado = "REALIZADA"
};
// Eliminar las anteriormente planificadas
var rs = from rx in ctx.Revisions
where rx.Dispositivo.DispositivoId == rev.Dispositivo.DispositivoId &&
rx.PlantillaRevision.PlantillaId == pr.PlantillaId &&
rx.FechaPlanificada > rev.FechaRevision &&
rx.Estado != "REALIZADA"
select rx;
foreach (Revision rx in rs)
{
CntLainsaSci.DeleteRevision(rx, ctx);
}
ProgramarSiguienteRevision(rev2, ctx, false);
}
}
}
public static void ProgramarSiguienteRevision(Revision rev, LainsaSci ctx, bool controlSuperiores)
{
// si la plantilla no es periódica no hay nada que planificar
if (rev.PlantillaRevision.NoPeriodica)
{
return;
}
// si el dispositivo está caducado no hay nada que planificar.
if (rev.Dispositivo.Caducado)
{
return;
}
// si la revisión actual no tiene fecha tampoco podemos planificar.
if (CntLainsaSci.FechaNula(rev.FechaRevision))
{
return;
}
Dispositivo dsp = rev.Dispositivo;
// controlamos si el dispositivo en el intermedio no está operativo y no se planifican
if (!dsp.Operativo && !dsp.SiguePlan)
{
return;
}
PlantillaRevision pr = rev.PlantillaRevision;
ResumenRevision rr = (from rsr in dsp.ResumenesRevisones
where rsr.PlantillaRevision.PlantillaId == pr.PlantillaId
select rsr).FirstOrDefault <ResumenRevision>();
// lo primero es conocer cuando tocaría la siguiente.
DateTime fechaFin = SiguienteFecha(rev.FechaRevision, pr);
// controlar que no hay una revisión de periodo mayor que coincida con ella
//if (controlSuperiores)
//{
// if (HayPlanificadaSuperior(fechaFin, rev, ctx))
// return;
//}
// buscamos si ya había una revisión que exactamente [fecha y tipo]
// coi-ncida con la que vamos a dar de alta
Revision rev2 = (from r in ctx.Revisions
where r.Dispositivo.DispositivoId == dsp.DispositivoId &&
r.PlantillaRevision.PlantillaId == pr.PlantillaId &&
r.FechaPlanificada == fechaFin
select r).FirstOrDefault <Revision>();
if (rev2 == null)
{
rev2 = new Revision();
rev2.Dispositivo = rev.Dispositivo;
rev2.FechaPlanificada = fechaFin;
rev2.PlantillaRevision = pr;
rev2.Estado = "PLANIFICADA";
// Comprobamos si caemos en caducidad
if (fechaFin >= dsp.FechaCaducidad)
{
rev2.CaduProx = true;
}
else
{
// calculamos en que fecha caerá la siguiente y si es fuera de caducidad
DateTime fechaSS = SiguienteFecha(fechaFin, pr);
if (fechaSS >= dsp.FechaCaducidad)
{
rev2.CaduProx = true;
}
}
ctx.Add(rev2);
foreach (Campo c in pr.Campos)
{
DatosRevision dr = new DatosRevision();
dr.Campo = c;
// Miramos los valores de campo en la anterior para copiarlos
DatosRevision dr2 = (from d in rev.DatosRevisions
where d.Campo.Nombre == c.Nombre
select d).FirstOrDefault <DatosRevision>();
if (dr2 != null)
{
dr.Valor = dr2.Valor;
}
dr.Revision = rev2;
ctx.Add(dr);
}
// Eliminmos las posibles inferiores a la planificada.
if (controlSuperiores)
{
EliminarInferiores(rev2, ctx); // esto ya se ha hecho antes
}
ctx.SaveChanges();
}
// Por último actulaizar la fecha en resumen
rr.FechaUltima = rev.FechaRevision;
rr.FechaSiguiente = fechaFin;
ctx.SaveChanges();
}
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();
}
