[Authorize] public async Task <IHttpActionResult> Create(AutorInternoCapitulo Obj)
                                                                  {
                                                                      try { log.Info(new MDCSet(this.ControllerContext.RouteData));
                                                                            var result = await _repository.Create(Obj);

                                                                            return(Ok(Obj));//regresamos el objeto par saber su id una vez guardado
                                                                      }
                                                                      catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);

                                                                                            return(InternalServerError(e)); }
                                                                  }
                                                                public async Task <AutorInternoCapitulo> Create(AutorInternoCapitulo Obj)
                                                                {
                                                                    try
                                                                    {
                                                                        var result = _ctx.dbSetAutorInternoCapitulo.Add(Obj);
                                                                        await _ctx.SaveChangesAsync();

                                                                        return(result);
                                                                    }
                                                                    catch (Exception e)
                                                                    {
                                                                        throw new Exception(e.Message, e);
                                                                    }
                                                                }
Пример #3
0
        public async Task <IEnumerable <Capitulos> > getData(DataServerSide ss)
        {
            List <Capitulos> ListCursoInterno = new List <Capitulos>();

            try
            {
                var v = (from a in _db.dbSetCapitulos.Where(e => e.EstadoFlujoId == 3)    select a);

                ss.recordsTotal = v.Count();

                if (!String.IsNullOrEmpty(ss.Titulo)) //busqueda por titulo
                {
                    var listaDA = await GetDALikeTituloLibroNuevo(ss.Titulo);

                    v = v.Where(e => listaDA.Contains(e.CapitulosId));
                }

                if (!String.IsNullOrEmpty(ss.Capitulo)) //busqueda por titulo
                {
                    var listaDA = await GetDALikeTituloCapituloNuevo(ss.Capitulo);

                    v = v.Where(e => listaDA.Contains(e.CapitulosId));
                }

                //País
                if (!string.IsNullOrEmpty(ss.Tipo))
                {
                    v = v.Where(e => e.Pais.ToString().Equals(ss.Tipo));
                }

                if (!string.IsNullOrEmpty(ss.Autor)) //Autor externo
                {
                    var AutoresE = await GetPKAutorExternoByCollateLatin1(ss.Autor);

                    v = v.Where(e => AutoresE.Contains(e.CapitulosId));
                }

                if (!string.IsNullOrEmpty(ss.Becario)) //Tomado como autor interno
                {
                    var entiti = await _db.dbSetAutorInternoCapitulo
                                 .Where(e => e.ClavePersona.ToString().Contains(ss.Becario))
                                 .Include(e => e.Capitulos)
                                 .AsNoTracking().ToListAsync();

                    if (entiti.Count == 0)
                    {
                        var reg = new AutorInternoCapitulo();
                        reg.CapitulosId = -1;
                        v = v.Where(e => e.CapitulosId == reg.CapitulosId

                                    );
                    }
                    else
                    {
                        HashSet <String> claves = null;
                        var registros           = entiti.Select(x => x.CapitulosId.ToString()).ToList();
                        claves = new HashSet <String>(registros);
                        v      = v.Where(e => claves.Contains(e.CapitulosId.ToString()));
                    }
                }


                //caja
                if (!string.IsNullOrEmpty(ss.searchValue))
                {
                    var p = ss.searchValue.ToLower();

                    var listaDA = await GetDALikeTituloLibroNuevo(ss.searchValue);

                    var listaDC = await GetDALikeTituloCapituloNuevo(ss.searchValue);

                    var listaDE = await GetDALikeEditorialNuevo(ss.searchValue);

                    v = v.Where(e => listaDA.Contains(e.CapitulosId) || e.Year.ToString().Contains(p) || listaDC.Contains(e.CapitulosId) || listaDE.Contains(e.CapitulosId));
                }


                if (!String.IsNullOrEmpty(ss.Editorial))
                {
                    var listaDA = await GetDALikeEditorialNuevo(ss.Editorial);

                    v = v.Where(e => listaDA.Contains(e.CapitulosId));
                }


                if (!String.IsNullOrEmpty(ss.Editor)) //busqueda por titulo
                {
                    var listaDA = await GetDALikeEditor(ss.Editor);

                    v = v.Where(e => listaDA.Contains(e.CapitulosId));
                }

                //sort
                if (!(string.IsNullOrEmpty(ss.sortColumn) && string.IsNullOrEmpty(ss.sortColumnDir)))
                {
                    //for make sort simpler we will add Syste.Linq.Dynamic reference
                    v = v.OrderBy(ss.sortColumn + " " + ss.sortColumnDir);
                }
                ss.recordsFiltered = v.Count();
                var entities = await v.Skip(ss.skip).Take(ss.pageSize).AsNoTracking().ToListAsync();

                return(entities.OrderByDescending(e => e.Year));
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }