public CreateIncidenteForm(IncidentesListForm listForm, Incidente incidente)
{
InitializeComponent();
this.attrs = new IncidenteAttrs(incidente);
this.incidente = incidente;
this.listForm = listForm;
}
//Se da de alta un incidente nuevo
public async Task <Incidente> AltaIncidente(Incidente incidente)
{
var jDatos = JsonConvert.SerializeObject(incidente);
using (SqlConnection connection = new SqlConnection(conexionSQL))
{
using (SqlCommand cmd = new SqlCommand("TSP_Tickets", connection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@Opcion", 1));
cmd.Parameters.Add(new SqlParameter("@jTicket", jDatos));
var response = new Incidente();
await connection.OpenAsync();
using (SqlDataReader reader = await cmd.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
response = MapToIncidente(reader);
}
}
return(response);
}
}
//await GeneralesRepository.EjecutaSpSinRetornoAsync(conexionDB, "TSP_GuardarTicket", incidente.Titulo, incidente.UsuarioAsig, incidente.Id_Usuario, incidente.Id_Estatus, incidente.Tipo, incidente.Prioridad);
}
public static bool IncidenteCreate(IncidenteViewModel entrada, out Incidente modelo, ContextPage contexto)
{
modelo = new Incidente();
modelo = entrada.Incidente;
SqlGeneric sqlService = new SqlGeneric();
modelo.codigo = sqlService.RetornaNovaPosicao(11, contexto.idOrganizacao);
if (modelo.codigo != null)
{
//************ Objetos de controle de acesso ******************
modelo.criadoEm = DateTime.Now;
modelo.criadoPor = contexto.idUsuario;
modelo.criadoPorName = contexto.nomeUsuario;
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = contexto.idUsuario;
modelo.modificadoPorName = contexto.nomeUsuario;
modelo.idOrganizacao = contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
} // end of if
return(false);
} // end of method IncidenteCreate
public async Task <IActionResult> PutIncidente(int id, Incidente incidente)
{
if (id != incidente.IncidenteId)
{
return(BadRequest());
}
_context.Entry(incidente).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IncidenteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void materialRaisedButton1_Click(object sender, EventArgs e)
{
Incidente incidente = new Incidente();
this.mainForm.EmbedForm(new CreateIncidenteForm(this, incidente), tabPage);
this.Visible = false;
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Incidente incidente = db.Incidente.Find(id);
if (incidente == null)
{
return(HttpNotFound());
}
switch (incidente.tipo)
{
case (int)TipoIncidente.chatWpp:
return(RedirectToAction("Edit", "IncidenteChatWpp", new { id = id }));;
case (int)TipoIncidente.llamado:
return(RedirectToAction("Edit", "IncidenteLlamado", new { id = id }));;
case (int)TipoIncidente.mail:
return(RedirectToAction("Edit", "IncidenteMail", new { id = id }));;
default:
break;
}
return(HttpNotFound());
}
public async Task <IActionResult> Post([FromBody] Incidente incidente, string userId)
{
try
{
if (ModelState.IsValid)
{
incidente.Id = null;
_incidenteRepository.ExecuteUnderTransaction(() =>
{
_incidenteRepository.Insert(incidente);
});
var eventMessage = new NotificarIncidenteCriadoEvent(userId);
_eventBus.Publish(eventMessage);
return(Ok(true));
}
return(BadRequest(ModelState));
}
catch (Exception e)
{
return(BadRequest(false));
}
}
public async Task <ActionResult <Incidente> > PostIncidente(Incidente incidente)
{
_context.Incidentes.Add(incidente);
await _context.SaveChangesAsync();
if (incidente.Classificacao > 10)
{
var accessToken = _httpContextAccessor.HttpContext.Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
try
{
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var url = this._configuration.GetValue <string>("tcc-api:comunicacao");
var content = await client.PostAsync(new Uri(url + "/api/PlanosAcao/incidente/" + incidente.IncidenteId), null);
}
catch (Exception ex)
{
var str = ex.GetBaseException().Message;
}
}
return(CreatedAtAction("GetIncidente", new { id = incidente.IncidenteId }, incidente));
}
public async Task <ActionResult <Incidente> > PostIncidente(Incidente incidente)
{
_context.Incidente.Add(incidente);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetIncidente", new { id = incidente.IdIncidente }, incidente));
}
public async Task <IActionResult> InsertIncidente(Incidente incidente)
{
var currentUser = HttpContext.User;
if (currentUser.HasClaim(c => c.Type == "username"))
{
var username = currentUser.Claims.FirstOrDefault(c => c.Type == "username").Value;
Usuario user = await _context.Usuarios.FirstOrDefaultAsync <Usuario>(u => u.Username == username);
await _context.Incidentes.AddAsync(incidente);
await _context.SaveChangesAsync();
Bitacora bitacora = new Bitacora
{
Fecha = DateTime.Now,
UsuarioId = user.Id,
DescripcionBitacora = $"Insertó nuevo Incidente ID {incidente.Id}"
};
await _context.Bitacora.AddAsync(bitacora);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
return(Unauthorized());
}
private RenglonDeIncidente renglonDe(Incidente incidente, int indice)
{
var renglon = new RenglonDeIncidente(incidente, this.OnIncidenteEdit, this.onIncidenteRemove);
this.incluirEnLista(indice, renglon);
return(renglon);
}
public void Gerenciar(Incidente value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
repository.Gerenciar(value);
}
public void addIncidente(Incidente incidente)
{
using (var repositorio = new Repositorio())
{
repositorio.Guardar(incidente);
this.dibujarRenglones(repositorio);
}
}
public ActionResult DeleteConfirmed(int id)
{
Incidente incidente = db.Incidente.Find(id);
incidente.is_eliminado = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void ButtonDesasignar_Click(object sender, EventArgs e)
{
if ((BindingSourceIncidentesAsignados.Current != null))
{
Incidente select = pEstacion.Incidentes.Where(i => i.Id == ((KeyValue)BindingSourceIncidentesAsignados.Current).Clave).First();
pEstacion.Incidentes.Remove(select);
BindIncidentes();
}
}
public ActionResult Assumir(ItemInbox item)
{
try
{
List <Incidente> lista = IncidenteBusiness.Consulta.Where(a =>
string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(item.UniqueKey)).ToList();
if (lista == null || lista.Count == 0)
{
throw new Exception("Não foi possível recuperar o incidente através da identificação recebida.");
}
else
{
ReiniciarCache(CustomAuthorizationProvider.UsuarioAutenticado.Login);
bool first = true;
foreach (Incidente obj in lista)
{
obj.StatusWF = "SO";
obj.DataExclusao = DateTime.Now;
obj.UsuarioExclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login;
IncidenteBusiness.Alterar(obj);
if (first)
{
first = false;
Incidente obj2 = new Incidente();
PropertyCopy.Copy(obj, obj2);
obj2.ID = Guid.NewGuid().ToString();
obj2.StatusWF = "RS";
if (!string.IsNullOrEmpty(item.Comentarios))
{
obj2.MensagemPasso = item.Comentarios;
}
obj2.Responsavel = CustomAuthorizationProvider.UsuarioAutenticado.Login;
obj2.UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login;
obj2.UsuarioExclusao = null;
obj2.DataExclusao = DateTime.MaxValue;
IncidenteBusiness.Inserir(obj2);
Severino.GravaCookie("MensagemSucesso", "O incidente " + obj2.Codigo + " foi redirecionado para a sua caixa pessoal.", 10);
}
}
}
return(Json(new { sucesso = "O passo do workflow associado ao documento foi aprovado com sucesso." }));
}
catch (Exception ex)
{
return(Json(new { erro = ex.Message }));
}
}
public ActionResult Download(string id)
{
try
{
if (!string.IsNullOrEmpty(id))
{
try
{
Incidente incidentePersistido = IncidenteBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(id));
if (incidentePersistido == null)
{
throw new Exception("As informações para geração do pacote zip de arquivos não são válidas.");
}
List <Arquivo> arquivos = ArquivoBusiness.Consulta.Where(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UKObjeto.Equals(id)).ToList();
if (arquivos == null || arquivos.Count == 0)
{
throw new Exception("Nenhum arquivo encontrado para o documento.");
}
byte[] conteudo = ArquivoBusiness.BaixarTodosArquivos(incidentePersistido.Codigo, arquivos);
var mimeType = string.Empty;
try
{
mimeType = MimeMapping.GetMimeMapping(incidentePersistido.Codigo + ".zip");
}
catch { }
if (string.IsNullOrWhiteSpace(mimeType))
{
mimeType = System.Net.Mime.MediaTypeNames.Application.Octet;
}
Response.AddHeader("Content-Disposition", string.Format("inline; filename=\"{0}\"", incidentePersistido.Codigo + ".zip"));
return(File(conteudo, mimeType));
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(Content(ex.Message, "text/html"));
}
}
else
{
Response.StatusCode = 500;
return(Content("Parâmetros para visualização de arquivo inválido.", "text/html"));
}
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(Content(ex.Message, "text/html"));
}
}
public void OnIncidenteEdit(int incidenteId)
{
using (var repositorio = new Repositorio())
{
Incidente incidente = repositorio.Obtener <Incidente>(incidenteId);
this.mainForm.EmbedForm(new EditIncidenteForm(this, incidente), tabPage);
}
this.Visible = false;
}
public RenglonDeIncidente(Incidente incidente, Del handleEdit, Del handleRemove)
{
InitializeComponent();
this.nombreLbl.Text = incidente.Nombre;
this.probabilidadLbl.Text = incidente.ProbabilidadDeOcurrencia.ToString();
this.demoraLbl.Text = incidente.TiempoDemora.ToString();
this.id = incidente.Id;
this.handleEdit = handleEdit;
this.handleRemove = handleRemove;
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
Incidente incidente = new Incidente();
this.incidentes = incidente.obtenerIncidentes();
foreach (Incidente elemento in incidentes)
{
this.cbIncidentes.Items.Add(elemento.nombre);
}
}
} // end of method IncidenteCreate
public static bool IncidenteUpdate(IncidenteViewModel entrada, out Incidente modelo)
{
modelo = new Incidente();
modelo = entrada.Incidente;
//************ Objetos de controle de acesso *******************
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = entrada.Contexto.idUsuario;
modelo.modificadoPorName = entrada.Contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
} // end of method IncidenteUpdate
public void Update(Incidente modelo)
{
db.Attach(modelo);
db.Entry(modelo).Property("modificadoPor").IsModified = true;
db.Entry(modelo).Property("modificadoPorName").IsModified = true;
db.Entry(modelo).Property("modificadoEm").IsModified = true;
db.Entry(modelo).Property("descricao").IsModified = true;
db.Entry(modelo).Property("titulo").IsModified = true;
db.SaveChanges();
} // end of method Update
private void onIncidenteRemove(int id)
{
if (MaterialMessageBoxConfirmation.Show("Confirmación", "¿Está seguro que desea eliminar el incidente?") == DialogResult.Yes)
{
using (var repositorio = new Repositorio())
{
Incidente incidente = repositorio.Obtener <Incidente>(id);
repositorio.Eliminar(incidente);
this.dibujarRenglones(repositorio);
}
}
}
public async Task <IList <Incidente> > ToListAsync(Incidente filtro)
{
context.InitProcedure("SpBuscarIncidentes");
if (filtro != null)
{
context.AddParameter("IdIncidente", filtro.IdIncidente, p => p != 0);
context.AddParameter("DescricaoIncidente", filtro.Descricao, p => !string.IsNullOrWhiteSpace(p));
context.AddParameter("IdNaoConformidade", filtro.NaoConformidade?.IdNaoConformidade, p => p != 0);
context.AddParameter("IdEstadoIncidente", (int)filtro.EstadoIncidente, p => p != 0);
}
return(await context.ListAsync <Incidente>());
}
private static Incidente ObtenerIncidenteDePrueba()
{
var incidente = new Incidente()
{
Nombre = "Incidente",
Descripcion = "Descripcion de incidente",
ProbabilidadDeOcurrencia = 10.45,
TiempoDemora = 100
};
return(incidente);
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Incidente incidente = db.Incidente.Find(id);
if (incidente == null)
{
return(HttpNotFound());
}
IncidenteVM incidenteVM = (IncidenteVM)incidente;
return(View(incidenteVM));
}
public IncidenteAttrs(Incidente incidente)
{
InitializeComponent();
pIncidente = incidente;
validables.Add(new Validator <Incidente>(pIncidente, ReglaConcreta <Incidente> .dePresencia((unIncidente => unIncidente.Nombre)), this.errorNombreLbl, this.nombreField));
validables.Add(new Validator <Incidente>(pIncidente,
new ReglaConcreta <Incidente>(unIncidente => unIncidente.ProbabilidadDeOcurrencia >= 0 && unIncidente.ProbabilidadDeOcurrencia <= 100, "Debe ser un valor entre 0 y 100"),
this.errorOcurrenciaLbl, this.probabilidadField));
validables.Add(new Validator <Incidente>(pIncidente, ReglaConcreta <Incidente> .dePositivo((unIncidente => unIncidente.TiempoDemora)), this.errorDemoraLbl, this.demoraField));
BindingSourceIncidente.DataSource = pIncidente;
probabilidadField.IsNumeric = true;
demoraField.IsNumeric = true;
}
public async Task <IActionResult> UpdateIncidente(Incidente incidente)
{
var currentUser = HttpContext.User;
if (currentUser.HasClaim(c => c.Type == "username"))
{
var username = currentUser.Claims.FirstOrDefault(c => c.Type == "username").Value;
Usuario user = await _context.Usuarios.FirstOrDefaultAsync <Usuario>(u => u.Username == username);
var incidenteObj = await _context.Incidentes.SingleOrDefaultAsync(b => b.Id == incidente.Id);
if (incidenteObj != null)
{
incidenteObj.ProcesoId = incidente.ProcesoId;
incidenteObj.AreaId = incidente.AreaId;
incidenteObj.ActividadId = incidente.ActividadId;
incidenteObj.CausaBasicaId = incidente.CausaBasicaId;
incidenteObj.CausaInmediataId = incidente.CausaInmediataId;
incidenteObj.ClasificacionId = incidente.ClasificacionId;
incidenteObj.EfectoId = incidente.EfectoId;
incidenteObj.Fecha = incidente.Fecha;
incidenteObj.GeneroId = incidente.GeneroId;
incidenteObj.JornadaId = incidente.JornadaId;
incidenteObj.Observado = incidente.Observado;
incidenteObj.ParteCuerpoId = incidente.ParteCuerpoId;
incidenteObj.RiesgoId = incidente.RiesgoId;
incidenteObj.TurnoId = incidente.TurnoId;
incidenteObj.Descripcion = incidente.Descripcion;
_context.Incidentes.Update(incidenteObj);
Bitacora bitacora = new Bitacora
{
Fecha = DateTime.Now,
UsuarioId = user.Id,
DescripcionBitacora = $"Actualizó Incidente ID {incidente.Id}"
};
await _context.Bitacora.AddAsync(bitacora);
await _context.SaveChangesAsync();
return(StatusCode(202));
}
return(StatusCode(400));
}
return(Unauthorized());
}
public void Gerenciar(Incidente value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.NaoConformidade?.IdNaoConformidade == 0)
{
throw new ArgumentOutOfRangeException(nameof(value.NaoConformidade), "Selecione uma Não Conformidade");
}
context.InitProcedure("SpGerenciarIncidentes");
context.AddParameter("IdIncidente", value.IdIncidente, p => p != 0);
context.AddParameter("DescricaoIncidente", value.Descricao, p => !string.IsNullOrWhiteSpace(p));
context.AddParameter("IdNaoConformidade", value.NaoConformidade?.IdNaoConformidade, p => p != 0);
context.AddParameter("IdUsuarioOperacao", value.IdUsuarioOperacao);
context.AddParameter("IdEstadoIncidente", (int)value.EstadoIncidente, p => p != (int)enumEstadoIncidente.Todos);
value.IdIncidente = context.ExecuteScalar <int>();
}
public void CRUDIncidente()
{
using (var session = NHibernateHelper.OpenSession())
using (var transaction = session.BeginTransaction())
{
var incidente = new Incidente()
{
Nombre = "Incidente 1",
Descripcion = "Descripcion de incidente",
ProbabilidadDeOcurrencia = 10.45,
TiempoDemora = 100
};
session.SaveOrUpdate(incidente);
session.Flush();
var incidenteDB = session.Query <Incidente>()
.Where(x => x.Descripcion == incidente.Descripcion && x.Nombre == incidente.Nombre)
.FirstOrDefault();
Assert.IsNotNull(incidenteDB);
incidenteDB.ProbabilidadDeOcurrencia = 67.13;
incidenteDB.Nombre = "otro nombre";
session.SaveOrUpdate(incidente);
session.Flush();
incidenteDB = session.Query <Incidente>()
.Where(x => x.Descripcion == incidente.Descripcion && x.TiempoDemora == incidente.TiempoDemora)
.FirstOrDefault();
Assert.AreEqual(incidenteDB.Nombre, "otro nombre");
Assert.AreEqual(incidenteDB.ProbabilidadDeOcurrencia, 67.13);
Assert.AreEqual(incidenteDB.Descripcion, incidente.Descripcion);
session.Delete(incidenteDB);
var existeIncidente = session.Query <Incidente>()
.Any(x => x.Descripcion == incidente.Descripcion && x.TiempoDemora == incidente.TiempoDemora);
Assert.IsFalse(existeIncidente);
}
}