private static void AddCreateIndex(List<ISearchEntity> CreateEntities, ISearchEntity entity) { var query = from e in CreateEntities where e.EntityIdentity == entity.EntityIdentity select e; List<ISearchEntity> temp = new List<ISearchEntity>(); foreach (var q in query) temp.Add(q); foreach (ISearchEntity e in temp) CreateEntities.Remove(e); CreateEntities.Add(entity); }
private static void AddCreateIndex(List <ISearchEntity> CreateEntities, ISearchEntity entity) { var query = from e in CreateEntities where e.EntityIdentity == entity.EntityIdentity select e; List <ISearchEntity> temp = new List <ISearchEntity>(); foreach (var q in query) { temp.Add(q); } foreach (ISearchEntity e in temp) { CreateEntities.Remove(e); } CreateEntities.Add(entity); }
public void CreateSingleIndex(ISearchEntity IndexEntity) { Analyzer analyzer = new StandardAnalyzer(); IndexWriter writer = new IndexWriter(ConfigElement.IndexDirectory, analyzer, false); ProductModel product = (ProductModel)IndexEntity; Document doc = new Document(); doc.Add(new Field("productid", Convert.ToString(product.EntityIdentity), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("productname", Convert.ToString(product.ProductName), Field.Store.YES, Field.Index.TOKENIZED)); doc.Add(new Field("cateid", Convert.ToString(product.CategoryID), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("catepath", Convert.ToString(product.CategoryPath), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("keywords", Convert.ToString(product.Keywords), Field.Store.YES, Field.Index.TOKENIZED)); doc.Add(new Field("description", Convert.ToString(product.Description), Field.Store.YES, Field.Index.TOKENIZED)); doc.Add(new Field("price", Convert.ToString(product.Price), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("createtime", Convert.ToString(product.CreateTime), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("updatetime", Convert.ToString(product.UpdateTime), Field.Store.YES, Field.Index.UN_TOKENIZED)); doc.Add(new Field("mainimage", Convert.ToString(product.ProductImage), Field.Store.YES, Field.Index.UN_TOKENIZED)); writer.AddDocument(doc); writer.Optimize(); writer.Close(); }
public SearchService(ISearchEntity searchEntity, IDbContext dbContext) { this._searchEntity = searchEntity; this._dbContext = dbContext; }
public static void SetCommonEntityFields(this ISearchEntity entity) { entity.CreatedById = entity.ModifiedById = -1; //Ideally it should be the logged in user id entity.CreatedOn = entity.ModifiedOn = DateTime.UtcNow; }
/// <summary> /// Retorna un objeto desde un entitySearch, el tipo del objeto de retorno será del tipo que utilice el atributo EntityIndexAttribute . /// para esto buscará todas las clases que tnengan el atributo EntityIndexAttribute que vincula la clase con el índice /// del entitySearch, una vez encontrada hará lo mismo con los atributos de cada propiedad para finalmente crear un objeto tipado con todos los valores del entitySearch. /// </summary> /// <typeparam name="T">Las entidades tienen un tipo de dato geo, que depende de la base de datos a usar.</typeparam> /// <param name="entitySearch">entitySearch a convertir</param> /// <param name="anyElementInAssembly">assembly donde buscar la clase que sea del tipo de la entidad</param> /// <param name="nms">namespace donde se encuentra la clase que sea del tipo de entidad</param> /// <param name="geoConvert"></param> /// <param name="sEntity"></param> /// <param name="hash"></param> /// <returns>objeto de una clase que representa una entidad</returns> public static object GetEntityFromSearch <T>(IEntitySearch <T> entitySearch, Type anyElementInAssembly, string nms, Func <T, object> geoConvert, ISearchEntity <T> sEntity, IHashSearchHelper hash) { // obtiene el tipo de clase de acuerdo al índice de la entidad. var type = GetEntityType(entitySearch.index, anyElementInAssembly, nms); // crea una nueva instancia del tipo determinado por la entidad // por ejemplo, si el indice de entidad correspondiera a 1 que es Persona, esta sería la clase persona. var entity = Collections.CreateEntityInstance(type); if (type.GetProperty("Id") == null) { throw new Exception("un elemento a convertir en EntitySearch debe llevar id"); } // asigna el id del objeto convertido // todas los elementos de la base de datos tienn la propiedad id. type.GetProperty("Id")?.SetValue(entity, entitySearch.id); // busca todas las propiedades que tengan el atributo baseIndexAttribute que identifica la metadata donde reside el índice y el tipo de dato. var props = entity.GetType().GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(BaseIndexAttribute), true)).ToList(); // recorre las propiedades de una clase y le asigna los valores correspondientes a las propiedades del entitySearch props.ForEach(prop => { // obtiene el atributo y su metadata var attr = prop.GetCustomAttribute <BaseIndexAttribute>(true); // con la metadata de la propiedad (índice, tipo de dato y si es o no entidad, obtiene el valor o la colección de valores de una propiedad. var values = Collections.FormatValues(prop, GetValues <T>(entitySearch, attr.IsEntity, attr.KindIndex, attr.Index, geoConvert, hash, sEntity, anyElementInAssembly, nms)); // asigna el valor a la clase. prop.SetValue(entity, values); }); var hashModel = hash.HashModel(entity); var hashHeader = hash.HashHeader(type); if (entitySearch.hh.Equals(hashHeader) && entitySearch.hm.Equals(hashModel)) { // retorna un objeto tipado desde un entitySearch. return(entity); } throw new Exception("Hash incorrectos"); }
/// <summary> /// Retorna el valor de una propiedad de un objeto, desde un entitySearch indicando cual es la propiedad. /// </summary> /// <see cref="KindProperty">Tipo de propiedad de valor</see> /// <see cref="KindEntityProperty">Tipo de propiedad de referencia</see> /// <typeparam name="T">Tipo de valor a entregar</typeparam> /// <param name="entitySearch">Entidad a convertir</param> /// <param name="isEntity">Determina si la propiedad que se desea obtener es de tipo entidad o es una propiedad primitiva (DateTime, número, etc.)</param> /// <param name="typeRelated">identificador del tipo de valor a obtener, para el caso de las propiedades sería KindProperty y para entidades KindEntityProperty</param> /// <param name="indexProperty">índice de la propiedad</param> /// <param name="geoConvert">convierte el tipo geo del entitySearch a el objeto de la instancia de la clase a obtener</param> /// <param name="hash"></param> /// <param name="anyElementInAssembly">Tipo de un objeto que se encuentre en el assembly donde está la clase con la metadata</param> /// <param name="nms">namespace donde se encuentra la clase con la metadata</param> /// <param name="sEntity">Interface para obtener un entitySearch desde una clase local</param> /// <returns>valor de una propiedad</returns> public static List <object> GetValues <T>(IEntitySearch <T> entitySearch, bool isEntity, int typeRelated, int indexProperty, Func <T, object> geoConvert, IHashSearchHelper hash, ISearchEntity <T> sEntity = null, Type anyElementInAssembly = null, string nms = null) { // se la propiedad corresponde a una entidad referencial local, debe tener los argumentos para obtener la entidad desde el repositorio. if ((sEntity == null || anyElementInAssembly == null || string.IsNullOrWhiteSpace(nms)) && isEntity) { throw new Exception("si el tipo a recuperar es de tipo entidad "); } // retorno si es nulo. List <object> values = new List <object>(); // si es entidad if (isEntity) { // castea el tipo al tipo de entidad. var relatedEntity = (KindEntityProperty)typeRelated; switch (relatedEntity) { // si es referencia retornará la colección de ids del tipo de entidad solicitada. case KindEntityProperty.REFERENCE: return((List <object>)entitySearch.rel?.Where(relatedId => relatedId.index == indexProperty).Select(s => s.id).Cast <object>().ToList() ?? values); // al ser local, debe ir a buscar el objeto al repositorio del search y convertirlo en el objeto que indica la metadata de la propidad case KindEntityProperty.LOCAL_REFERENCE: return(entitySearch.rel?.ToList().FindAll(relatedId => relatedId.index == indexProperty).Select(relatedId => GetEntityFromSearch(sEntity.GetEntity(indexProperty, relatedId.id), anyElementInAssembly, nms, geoConvert, sEntity, hash)).ToList() ?? values); default: return(null); } } // si es de tipo propidad de valor. castea a enumeración. var props = (KindProperty)typeRelated; // retorna el valor o colección de valores desde una propiedad. switch (props) { case KindProperty.STR: return(Props.GetPropValues(entitySearch.str, indexProperty).Cast <object>().ToList()); case KindProperty.SUGGESTION: return(Props.GetPropValues(entitySearch.sug, indexProperty).Cast <object>().ToList()); case KindProperty.NUM64: return(Props.GetPropValues(entitySearch.num64, indexProperty).Cast <object>().ToList()); case KindProperty.NUM32: return(Props.GetPropValues(entitySearch.num32, indexProperty).Cast <object>().ToList()); case KindProperty.DBL: return(Props.GetPropValues(entitySearch.dbl, indexProperty).Cast <object>().ToList()); case KindProperty.BOOL: return(Props.GetPropValues(entitySearch.bl, indexProperty).Cast <object>().ToList()); case KindProperty.GEO: return(Props.GetPropValues(entitySearch.geo, indexProperty).Cast <T>().Select(geoConvert).ToList()); case KindProperty.ENUM: return(Props.GetPropValues(entitySearch.enm, indexProperty).Cast <object>().ToList()); case KindProperty.DATE: return(Props.GetPropValues(entitySearch.dt, indexProperty).Cast <object>().ToList()); default: return(null); } }