public static List <Suceso> GetHistorialCronogramas(int cronogramaId, int deportePeriodoId, int competidorId)
{
List <Suceso> lsu = new List <Suceso>();
List <SqlParameter> lp = new List <SqlParameter>();
lp.Add(new SqlParameter("CronogramaId", cronogramaId));
lp.Add(new SqlParameter("DeportePeriodoId", deportePeriodoId));
lp.Add(new SqlParameter("CompetidorId", competidorId));
DBTransaction db = new DBTransaction();
DataTable dt = db.GetStoreProcedure("conj.pHistorialCronograma", lp);
int FindIndice = -1;
foreach (DataRow dr in dt.Rows)
{
Suceso sc = ConvertToSucesos(dr);
sc.Competidor = Competidor.ConvertToCompetidor(dr);
sc.Competidor.Equipo = Equipo.ConvertToEquipo(dr);
sc.ParametrosSuceso = ParametrosSuceso.ConvertToParametroSuceso(dr);
sc.SucesoPersonas = new List <SucesoPersona>();
if (sc.ParametrosSuceso.RegistraPersona >= 1 && !string.IsNullOrEmpty(dr["PlanillaPersonaId"].ToString()))
{
SucesoPersona scp = SucesoPersona.ConvertToSucesoPersona(dr);
scp.PlanillaPersona = PlanillaPersona.ConvertPlanillaPersona(dr, true);
FindIndice = lsu.FindIndex(delegate(Suceso s) { return(s.SucesoId == sc.SucesoId); });
if (FindIndice > 0)
{
lsu.ElementAt(FindIndice).SucesoPersonas.Add(scp);
}
else
{
sc.SucesoPersonas.Add(scp);
FindIndice = -1;
}
}
else
{
FindIndice = -1;
}
if (FindIndice < 0)
{
lsu.Add(sc);
}
}
return(lsu);
}
public async Task <IHttpActionResult> ValidaServicioCompetidor(Competidor model)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
var entity = await _entityRepo.ValidaServicioCompetidor(model);
return(Ok(entity));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> UpdateEstado([FromBody] Competidor model)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _entityRepo.UpdateEstado(model);
return(Ok("Estado acualizado correctamente."));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <Competidor> GetByID(int id)
{
Competidor competidor = new Competidor();
try
{
competidor = await _context.Competidores.FirstAsync(c => c.ID == id);
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados.");
}
return(competidor);
}
// GET: Competidors/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Competidor competidor = db.Competidors.Find(id);
if (competidor == null)
{
return(HttpNotFound());
}
ViewBag.MarcaID = new SelectList(db.Marcas, "MarcaID", "Codigo", competidor.MarcaID);
ViewBag.ZonaID = new SelectList(db.Zonas, "ZonaID", "Codigo", competidor.ZonaID);
return(View(competidor));
}
public async Task <IActionResult> Cadastrar(List <int> viewModel)
{
Competidor competidorTemp = new Competidor();
Time time = await this._timeRepository.GetByCasa(_casa);
foreach (var item in viewModel)
{
competidorTemp = await _competidorRepository.GetByID(item);
competidorTemp.Time = time;
competidorTemp.TimeID = time.ID;
await this._competidorRepository.Update(competidorTemp);
}
return(RedirectToAction("Index", "Time"));
}
public async Task Update(Competidor model)
{
try
{
var _model = await _dbComp.Competidor.FirstOrDefaultAsync(e => e.CompetidorId == model.CompetidorId);
if (_model != null)
{
_dbComp.Entry(_model).CurrentValues.SetValues(model);
await _dbComp.SaveChangesAsync();
//Se eliminan los adjuntos anteriores del registro, esto evita tener multiples listas de adjuntos (nuevos, viejos) por cada adjunto que agregue/elimine el usuario
var fksAdjuntos = await _dbComp.AdjuntoPorCompetidor.Where(e => e.CompetidorId == model.CompetidorId).ToListAsync();
if (fksAdjuntos.Count() > 0)
{
var listaAdjuntos = fksAdjuntos.Select(x => x.AdjuntoId).ToList();
_dbComp.AdjuntoPorCompetidor.RemoveRange(fksAdjuntos);
await _dbComp.SaveChangesAsync();
await new AdjuntoRepository().DeleteByCollectionIds(listaAdjuntos);
}
//Se registran los adjuntos de nuevo
if (model.AdjuntoPorCompetidor.Count > 0)
{
foreach (var item in model.AdjuntoPorCompetidor)
{
Adjunto obj = new Adjunto();
obj.RutaCompleta = item.Adjunto.RutaCompleta;
obj.nombre = item.Adjunto.nombre;
obj.ModuloId = "CR";
var entities = _dbGEN.dbSetAdjuntos.Add(obj);
await _dbGEN.SaveChangesAsync();
await insertaAdjuntosCompetidor(item.Autor, obj.AdjuntoId, item.tipo, model.CompetidorId);//string autor, long IdAdjunto, string tipo, int idcompetidor
}
// await insertaAdjunto(model);
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateEstado(Competidor model)
{
try
{
var _model = await _dbComp.Competidor.FirstOrDefaultAsync(e => e.CompetidorId == model.CompetidorId);
if (_model != null)
{
_model.Estado = model.Estado;
await _dbComp.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Response> Update(Competidor competidor)
{
Response response = new Response();
if (string.IsNullOrWhiteSpace(competidor.Nome))
{
response.Erros.Add("O nome do competidor deve ser informado.");
}
else if (competidor.Nome.Length < 2 || competidor.Nome.Length > 50)
{
response.Erros.Add("O nome do competidor deve ser informado.");
}
if (competidor.Escolaridade < Entity.Enums.Escolaridade.Quarto)
{
response.Erros.Add("Para se inscrever como competidor o aluno deve estar cursando no mínimo o quarto ano.");
}
if (competidor.Casa != competidor.Time.Casa)
{
response.Erros.Add("A casa do competidor é diferente da casa do time!");
}
if (response.Erros.Count > 0)
{
response.Sucesso = false;
return(response);
}
try
{
await _competidorRepository.Update(competidor);
response.Sucesso = true;
return(response);
}
catch (Exception ex)
{
response.Erros.Add("Erro no banco de dados, contate o administrador.");
response.Sucesso = false;
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
return(response);
}
}
public async Task <IActionResult> Cadastrar(CompetidorInsertViewModel viewModel)
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CompetidorInsertViewModel, Competidor>();
});
IMapper mapper = configuration.CreateMapper();
Competidor competidor = mapper.Map <Competidor>(viewModel);
try
{
await this._competidorService.Insert(competidor);
}
catch (Exception ex)
{
ViewBag.Errors = ex.Message;
}
return(View());
}
public async Task <Response> Insert(Competidor competidor)
{
Response response = new Response();
try
{
this._context.Competidores.Add(competidor);
await this._context.SaveChangesAsync();
response.Sucesso = true;
}
catch (Exception ex)
{
response.Sucesso = false;
response.Erros.Add("Erro no banco de dados.");
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
}
return(response);
}
private async Task EliminaServicio(Competidor model)
{
try
{
foreach (var item in model.ServicioAntDel)
{
var _model = await _dbComp.ServicioPorCompetidor.FirstOrDefaultAsync(e => e.ServicioId == item);
if (_model != null)
{
_dbComp.ServicioPorCompetidor.Remove(_model);
await _dbComp.SaveChangesAsync();
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> Update([FromBody] Competidor model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _entityRepo.Update(model);
return(Ok("Registro actualizado exitosamente!"));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public bool InsertCompetidorGolfCompetidor([FromBody] CompetidorGolfCompetidor gcompetidor)
{
Competidor cp = new Competidor();
bool resultado = true;
GolfCompetidor gcp = new GolfCompetidor();
gcp.CompetidorId = gcompetidor.CompetidorId;
gcp.CategoriaId = gcompetidor.CategoriaId;
gcp.Handicap = gcompetidor.Handicap;
gcp.Club = gcompetidor.Club;
if (gcompetidor.Accion == 0)
{
resultado = InsertGolfCompetidor(gcp);
}
else
{
resultado = resultado && UpdateGolfCompetidor(gcp);
}
return(resultado);
}
public ActionResult Competir([FromBody] Competidor competidor)
{
try
{
if (_competidorRepositorio.ExisteInscricao(competidor))
{
return(BadRequest("Competidor já inscrito nesse campeonato"));
}
else if (_competidorRepositorio.EhOrganizador(competidor))
{
return(BadRequest("Você não pode competir no seu próprio campeonato"));
}
competidor.StatusInscricaoId = (int)StatusCompetidorEnum.Pendente;
_competidorRepositorio.Competir(competidor);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
private async Task insertaProducto(Competidor model)
{
try
{
for (int i = 0; i < model.ProductoId.Length; i++)
{
var Prod = model.ProductoId[i];
ProductoPorCompetidor obj = new ProductoPorCompetidor();
obj.Autor = model.Autor;
obj.FechaRegistro = model.FechaRegistro;
obj.Estado = true;
obj.ProductoId = Prod;
obj.CompetidorId = model.CompetidorId;
var entities = _dbComp.ProductoPorCompetidor.Add(obj);
await _dbComp.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
private void SendConfirmation( Competidor _record )
{
//url to send data to
string apiUrl = "https://mandrillapp.com/api/1.0/messages/send-template.json";
//account api key needed to send email
//created at: https://mandrillapp.com/settings
string mandrillKey = "uyacaLccRLJ6quQDIWuE8w";
//name of the email template created in mandrill
string mandrillTemplateId = "form-comprobante-tarjeta";
//list of emails to send the email to
List<string> toEmails = new List<string>();
toEmails.Add( _record.CORREO );
//list of to names for emails above
List<string> toNames = new List<string>();
toNames.Add("Mr. Example");
//replacement values to add to the email
//these replacement tags must be added to your Mandrill tempalte: ex: <a href="*|site_url|*">Site Url</a>
List<KeyValuePair<string, string>> replacementValues = new List<KeyValuePair<string, string>>();
replacementValues.Add(new KeyValuePair<string, string>("REGISTRO" , _record.REGISTRO));
replacementValues.Add(new KeyValuePair<string, string>("FCHREG" , _record.FCHREG.ToString()));
replacementValues.Add(new KeyValuePair<string, string>("APELLIDOS", ReplaceASCII(_record.APELLIDOS)));
replacementValues.Add(new KeyValuePair<string, string>("NOMBRES", ReplaceASCII(_record.NOMBRES)));
replacementValues.Add(new KeyValuePair<string, string>("DOCUMENTO" , _record.DOCUMENTO));
replacementValues.Add(new KeyValuePair<string, string>("CORREO" , _record.CORREO));
replacementValues.Add(new KeyValuePair<string, string>("ID" , _record.ID));
replacementValues.Add(new KeyValuePair<string, string>("CATEGORIA", ReplaceASCII(_record.GetCategoria())));
replacementValues.Add(new KeyValuePair<string, string>("TALLA" , _record.TALLA ));
replacementValues.Add(new KeyValuePair<string, string>("EVENTO", ReplaceASCII(_record.GetEvento())));
replacementValues.Add(new KeyValuePair<string, string>("SEXO" , _record.SEXO));
replacementValues.Add(new KeyValuePair<string, string>("INVOICENUMBER" , _record.INVOICENUMBER));
replacementValues.Add(new KeyValuePair<string, string>("CONFIRMATIONNUMBER" , _record.CONFIRMATIONNUMBER));
replacementValues.Add(new KeyValuePair<string, string>("CI" , _record.CI));
replacementValues.Add(new KeyValuePair<string, string>("CARDNUMBER" , _record.CARDNUMBER));
dynamic sendParams = new System.Dynamic.ExpandoObject();
sendParams.key = mandrillKey;
sendParams.template_name = mandrillTemplateId;
sendParams.template_content = new List<dynamic>();
sendParams.message = new System.Dynamic.ExpandoObject();
sendParams.message.to = new List<dynamic>();
//to emails
for (int x = 0; x < toEmails.Count; x++)
{
sendParams.message.to.Add(new System.Dynamic.ExpandoObject());
sendParams.message.to[x].email = toEmails[x];
}
//to names - in same order as to emails
for (int x = 0; x < toNames.Count; x++)
{
//dont add if email wasnt added
if (toEmails.Count >= x + 1)
{
sendParams.message.to[x].name = toNames[x];
}
}
//additional mandrill options
sendParams.message.track_opens = true;
//sendParams.message.track_clicks = true;
//create replacement values object to merge in
sendParams.message.global_merge_vars = new List<dynamic>();
int counter = 0;
foreach (var pair in replacementValues)
{
sendParams.message.global_merge_vars.Add(new System.Dynamic.ExpandoObject());
sendParams.message.global_merge_vars[counter].name = pair.Key;
sendParams.message.global_merge_vars[counter].content = pair.Value;
counter++;
}
//json send parameters
string jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(sendParams);
//create web client to post data
var request = new System.Net.WebClient();
//set content type to json since we are posting json data
request.Headers[HttpRequestHeader.ContentType] = "application/json; charset=utf-8";
//post json data and get the response
string responseString = request.UploadString(apiUrl, jsonString);
//read the results
bool success = false;
if (!string.IsNullOrWhiteSpace(responseString))
{
dynamic resultObj = Newtonsoft.Json.JsonConvert.DeserializeObject(responseString);
if (resultObj != null)
{
if (resultObj[0] != null)
{
if (resultObj[0].status == "sent")
{
success = true;
UpdateCompetidor(_record.REGISTRO);
}
}
}
}
}
/// <summary>
/// Obtiene competidores acorde los parametros de busqueda por el usuario
/// </summary>
/// <returns>IEnumerable<Object></returns>
public async Task <IEnumerable <Object> > GetConsultaParametrizadaCompetidores(Competidor parametros)
{
try
{
var competidores = (from cp in _dbComp.Competidor
.Include(e => e.Empresa)
.Include(e => e.SegmentoMercado)
.Include(e => e.LineaDesarrolloTecnologico)
select cp).AsNoTracking();
var listaProductos = await(from p in _dbComp.ProductoPorCompetidor.AsNoTracking()
select new
{
p.ProductoId,
p.CompetidorId
}).ToListAsync();
var listaServicios = await(from s in _dbComp.ServicioPorCompetidor.AsNoTracking()
select new
{
s.ServicioId,
s.CompetidorId
}).ToListAsync();
if (competidores != null)
{
if (parametros.EmpresaId != 0) //Busqueda por empresa
{
competidores = competidores.Where(e => e.EmpresaId == parametros.EmpresaId);
}
if (!String.IsNullOrEmpty(parametros.TipoCompetidor)) //Busqueda por tipo competidor
{
competidores = competidores.Where(e => e.TipoCompetidor != null && e.TipoCompetidor == parametros.TipoCompetidor);
}
if (parametros.LineaDesarrolloTecnologicoId != null)
{
if (parametros.LineaDesarrolloTecnologicoId == 0)
{
competidores = competidores.Where(x => x.LineaDesarrolloTecnologicoId == null);
}
else
{
competidores = competidores.Where(x => x.LineaDesarrolloTecnologicoId == parametros.LineaDesarrolloTecnologicoId);
}
}
if (parametros.SegmentoMercadoId != 0 && parametros.SegmentoMercadoId != null) //Busqueda por segmento de mercado
{
competidores = competidores.Where(e => e.SegmentoMercadoId != null && e.SegmentoMercadoId == parametros.SegmentoMercadoId);
}
if (parametros.idProducto != 0)
{
var tempLista = listaProductos.Where(e => e.ProductoId == parametros.idProducto).Select(x => x.CompetidorId);
if (tempLista.Count() > 0)
{
competidores = competidores.Where(e => tempLista.Contains(e.CompetidorId));
}
}
if (parametros.idServicio != 0)
{
var tempListaServ = listaServicios.Where(e => e.ServicioId == parametros.idServicio).Select(x => x.CompetidorId);
if (tempListaServ.Count() > 0)
{
competidores = competidores.Where(e => tempListaServ.Contains(e.CompetidorId));
}
}
//******Se inicia el proceso de proyeccion******
//Los resultados lo guardaremos en una lista de X objeto
List <BusquedaParamsCR> datos = competidores.Select(x => new BusquedaParamsCR //Es una clase no mapeada que contiene caracteristicas
//que nos permiten albergar SOLO los datos necesarios
{
CompetidorId = x.CompetidorId, //Rescatamos los parametros que se requieren para el front
TipoCompetidor = x.TipoCompetidor,
SegmentoMercado = x.SegmentoMercado.NomSegMerc,
NombreEmpresa = x.Empresa.NombreEmpresa,
Estado = x.Estado,
LineaInvestigacion = x.LineaDesarrolloTecnologico.NomLinDesTec
}).ToList();
foreach (var d in datos)
{
var FKProductos = listaProductos.Where(e => e.CompetidorId == d.CompetidorId).Select(e => e.ProductoId).ToList();
d.listaProductos = await(from prod in _dbComp.Producto
where FKProductos.Contains(prod.ProductoId)
select prod.NomProd).AsNoTracking().ToListAsync();
var FKServicios = listaServicios.Where(e => e.CompetidorId == d.CompetidorId).Select(e => e.ServicioId).ToList();
d.listaServicios = await(from serv in _dbComp.Servicio
where FKServicios.Contains(serv.ServicioId)
select serv.NomServ).AsNoTracking().ToListAsync();
}
return(datos);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public void Modificar([FromBody] Competidor competidor)
{
context.Update(competidor);
context.SaveChanges();
}
public void Insertar([FromBody] Competidor competidor)
{
context.Add(competidor);
context.SaveChanges();
}
public void AltaCompetidor(Competidor competidor)
{
CompetidoresRepositorio.AltaCompetidor(competidor);
}
public Competidor GetCompetidor(int competidorId)
{
return(Competidor.GetCompetidor(competidorId));
}
public void GuardarCompetidor(Competidor competidor)
{
contexto.Competidor.Add(competidor);
contexto.SaveChanges();
}
public void GuardarCompetidor(Competidor competidor)
{
competidoresDAO.GuardarCompetidor(competidor);
}
public bool DeleteCompetidor(int competidorid)
{
Competidor cc = new Competidor();
return(cc.DeleteCompetidor(competidorid));
}
public Task <Response> Delete(Competidor competidor)
{
throw new NotImplementedException();
}
