/// <summary> /// Toma un objeto de base de datos de persistencia, lo convierte a un entitySearch y lo guarda en azure search. /// </summary> /// <typeparam name="T">tipo de dato tipo base de datos.</typeparam> /// <param name="document">entidad o documento de base de datos de persistencia</param> public void AddDocument <T>(T document) where T : DocumentDb { // obtiene un entitySearch desde una entidad de base de datos de persistencia. var entitySearch = Mdm.GetEntitySearch(implements, document, hashOper).Cast <IEntitySearch <GeoPointType> >().ToList(); // añade a registro AddToQueried(nameof(AgroSearch <GeoPointType> .AddDocument), JsonConvert.SerializeObject(entitySearch)); // añade a base de datos. baseMainSearch.AddElements(entitySearch); }
public void Test1() { // assign var assembly = typeof(BarrackTest).Assembly; // action var globalFilters = Mdm.GetMdm(assembly, "0.0.1", new VersionStructure()); Assert.True(globalFilters != null); }
/// <summary> /// Valida recursivamente una instancia de un objeto, de acuerdo al método para validar, /// si es recursivo, busca propiedades de tipo clase y realiza la misma validación. /// </summary> /// <typeparam name="A">Tipo de atributo a buscar</typeparam> /// <param name="element">instancia de objeto donde se buscaran las propiedades que tengan el atributo</param> /// <param name="extraValidation">Función que ejecutará la validación</param> /// <param name="recursive">determina si la busqueda de atributos es recursiva, si fuese así buscará todas las clases que tiene un objeto y buscará dentro de este el atributo en cada propiedad</param> /// <returns>resultado que integra si es valido y los mensajes de error</returns> private async Task <ResultValidate> ValidaProperties <A>(object element, Func <object, string, string, Attribute[], Task <ResultValidate> > extraValidation, bool recursive) where A : Attribute { var propsInfo = element.GetType().GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(A), true)); var messages = new List <string>(); bool valida = true; foreach (var item in propsInfo) { var validation = await extraValidation(item.GetValue(element), element.GetType().Name, item.Name, item.GetCustomAttributes <Attribute>().ToArray()); if (!validation.Valid) { valida = false; messages.AddRange(validation.Messages); } } // propiedades no primitivas var nonPrimitiveProps = element.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(s => !EnumerationExtension.IsPrimitiveAndCollection(s.PropertyType) && !s.PropertyType.IsEnum); if (nonPrimitiveProps.Any() && recursive) { foreach (var propinfo in nonPrimitiveProps) { if (propinfo.GetValue(element) != null) { var castedCollectionElement = Mdm.CreateDynamicList(propinfo.GetValue(element)); foreach (var item in castedCollectionElement) { var res = await ValidaProperties <A>(item, extraValidation, true); if (!res.Valid) { messages.AddRange(res.Messages); valida = false; } } } } } return(new ResultValidate { Valid = valida, Messages = messages.ToArray() }); }
/// <summary> /// Obtiene un entitySearch desde un objeto de la base de datos /// el tipo de dato es por comodidad, si púede revisar internamente convierte cualquier objeto a entitySearch. /// Retorna una colección de EntitySearch, una de referencia y el resto local, ver atributos de la clase para más detalle. /// Vea EntityIndexAtribute, en el se asigna una referencia local o de referenci /// </summary> /// <see cref="EntityIndexAtribute"/> /// <typeparam name="T2">modelo del objeto que se convertirá a entity Search</typeparam> /// <param name="model">objeto a convertir</param> /// <returns>Colección de entity Search</returns> public IEntitySearch <GeoPointType>[] GetEntitySearch <T2>(T2 model) where T2 : DocumentDb { // crea un mapper para convertir un IEntitySearch a EntityBaseSearch<GeoPointType> var mapperLocal = mapper.CreateMapper(); // convierte un elemento de persistencia a un entitySearch<GeoPointType> var document = Mdm.GetEntitySearch( implements, // asignación de tipos para cada interface de un entitySearch model // documento a convertir , hashOper) .Select(mapperLocal.Map <EntityBaseSearch <GeoPointType> >) // mapea el entitySearch de tipo GetEntitySearchImplementedType y lo convierte en EntityBaseSearch<GeoPointType>. .ToArray(); return(document); }
public string HashHeader(Type type) { // obtenemos los diccionarios desde las enumeraciones. var dictRel = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <EntityRelated>(); var dictEnum = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <EnumRelated>(); var dictNum = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <NumRelated>(); var dictStr = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <StringRelated>(); var dictDbl = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <DoubleRelated>(); var dictDt = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <DateRelated>(); var dictGeo = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <GeoRelated>(); var dictBool = Mdm.Reflection.Enumerations.GetDictionaryFromEnum <BoolRelated>(); // obtiene los índices de la clase var indexes = Mdm.PreLoadedDictionary(type); if (indexes == null) { return(string.Empty); } // asigna colecciones de dictionary de los índices de propiedades de un objeto de una base de datos de persistencia. var dict = new JsonDictionaryHeaders { bl = indexes.bl.ToDictionary(s => s, s => dictBool[s]), dbl = indexes.dbl.ToDictionary(s => s, s => dictDbl[s]), dt = indexes.dt.ToDictionary(s => s, s => dictDt[s]), enm = indexes.enm.ToDictionary(s => s, s => dictEnum[s]), geo = indexes.geo.ToDictionary(s => s, s => dictGeo[s]), index = indexes.index, num64 = indexes.num32.ToDictionary(s => s, s => dictNum[s]), num32 = indexes.num64.ToDictionary(s => s, s => dictNum[s]), rel = indexes.rel.ToDictionary(s => s, s => dictRel[s]), str = indexes.str.ToDictionary(s => s, s => dictStr[s]), sug = indexes.sug.ToDictionary(s => s, s => dictStr[s]) }; // serializa para el hash var jsonDict = JsonConvert.SerializeObject(dict); // retorna hash return(Mdm.Reflection.Cripto.ComputeSha256Hash(jsonDict)); }
/// <summary> /// Valida las propiedades que usen el atributo Reference, al detectar este atributo, validará si el elemento existe en la base de datos. /// </summary> /// <param name="elemento">elemento a validar</param> /// <param name="className">nombre de la clase a la que pertenece el elemento</param> /// <param name="propName">nombre de la propiedad</param> /// <param name="attributes">atributos de la propiedad</param> /// <returns>resultado que integra si es valido y los mensajes de error</returns> private async Task <ResultValidate> ValidaReference(object elemento, string className, string propName, Attribute[] attributes) { // si es nulo es válido, no válida nulos if (elemento == null) { return(new ResultValidate { Valid = true }); } // se crea colección desde el objeto var castedCollectionElement = Mdm.CreateDynamicList(elemento); // si es vacia, no valida, requerido valida. if (!castedCollectionElement.Any()) { return(new ResultValidate { Valid = true }); } // si no es string, no es válido if (elemento.GetType() != typeof(string) && elemento.GetType() != typeof(List <string>) && elemento.GetType() != typeof(string[])) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} debe ser string, el atributo reference es solo para strings" } }); } //obtiene el atributo desde el listado de atributos. var attributeLink = (ReferenceAttribute)attributes.FirstOrDefault(s => s.GetType() == typeof(ReferenceAttribute)); // método que permite saber si un elemento existe var mtd = typeof(IExistElement).GetMethod(nameof(IExistElement.ExistsById)); // asigna el elemento generics desde el tipo que mantiene ReferenceAttribute var genericMtd = mtd.MakeGenericMethod(attributeLink.entityOfReference); bool valid = true; var lst = new List <string>(); foreach (var item in castedCollectionElement) { var strElement = (string)item; // si es vacio no se valida if (string.IsNullOrWhiteSpace(strElement)) { break; } // ejecuta el método de busqueda por id, usando el valor de la propiedad. var task = (Task <bool>)genericMtd.Invoke(existElement, new[] { item.ToString() }); // ejecuta asíncrono await task.ConfigureAwait(false); // obtiene la propiedad result var resultProperty = task.GetType().GetProperty("Result"); // obtiene el valor booleano, true si existe. var localValid = (bool)resultProperty.GetValue(task); if (!localValid) { valid = localValid; lst.Add($"No existe {attributeLink.entityOfReference.Name} con id {item}"); } } return(new ResultValidate { Valid = valid, Messages = !valid?lst.ToArray() : Array.Empty <string>() }); }
/// <summary> /// Valida si un elemento es requerido, si es el caso verificará si existe un valor en esa propíedad /// </summary> /// <param name="element">objeto a validar</param> /// <param name="className">Nombre de la clase a la que pertenece el objeto</param> /// <param name="propName">la propiedad que pertenece el objeto</param> /// <param name="attributes">atributos encontrados en la propiedad</param> /// <returns>resultado que integra si es valido y los mensajes de error</returns> private async Task <ResultValidate> ValidaRequired(object element, string className, string propName, Attribute[] attributes) { // si es nulo no es válido if (element == null) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} es obligatorio" } }); } // se crea colección desde el objeto var castedCollectionElement = Mdm.CreateDynamicList(element); // si la lista es vacia, es inválido. if (!castedCollectionElement.Any()) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} es obligatorio, tampoco puede ser una lista vacia" } }); } //obtiene el atributo desde el listado de atributos que sean requerido. var attributeLink = (RequiredAttribute)attributes.FirstOrDefault(s => s.GetType() == typeof(RequiredAttribute)); var valid = true; var lst = new List <string>(); foreach (var item in castedCollectionElement) { // obtiene el tipo, según el tipo validará. var type = item.GetType(); if (type == typeof(int) || type == typeof(int?) || type == typeof(double) || type == typeof(double?) || type == typeof(decimal) || type == typeof(decimal?)) { if (item == null) { lst.Add($"{className}.{propName} es obligatorio"); valid = false; } else { if (int.TryParse(item.ToString(), out var intResult)) { if (intResult == 0) { lst.Add($"{className}.{propName} es obligatorio, ni puede cer cero"); valid = false; } } } } if (type == typeof(bool?) || type == typeof(DateTime?)) { if (item == null) { lst.Add($"{className}.{propName} es obligatorio"); valid = false; } } if (item == null || string.IsNullOrWhiteSpace(item.ToString())) { lst.Add($"{className}.{propName} es obligatorio"); valid = false; } } return(new ResultValidate { Valid = valid, Messages = lst.ToArray() }); }
/// <summary> /// Valida las propiedades que tengan el atributo Unique, /// el atributo indica una propiedad que debe existir un solo valor en toda la base de datos /// por tanto, buscará si ya existe el mismo valor en la misma propiedad para una colección de objetos. /// La colección de objetos esta determinado por el tipo de objeto del elemento. /// si se asigna un id, no considerará el elemento con ese id en la busqueda. /// </summary> /// <param name="elemento">elemento a validar, una propiedad de un objeto</param> /// <param name="className">nombre de la clase</param> /// <param name="propName">nombre de la propiedad del elemento</param> /// <param name="attributes">atributos encontrados</param> /// <param name="id">si se asigna un id, significa que buscará la propiedad y el valor, pero no para ese id.</param> /// <returns>resultado que integra si es valido y los mensajes de error</returns> private async Task <ResultValidate> ValidaUnique(object elemento, string className, string propName, Attribute[] attributes, string id = null) { // si el elemento es nulo, es válido. if (elemento == null) { return(new ResultValidate { Valid = true }); } // se crea colección desde el objeto, con el fin de validar colecciones var castedCollectionElement = Mdm.CreateDynamicList(elemento); // si la colección esta vacia no validará. if (!castedCollectionElement.Any()) { return(new ResultValidate { Valid = true }); } // si no es string, no debería ser validado. if (elemento.GetType() != typeof(string) && elemento.GetType() != typeof(List <string>) && elemento.GetType() != typeof(string[])) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} debe ser string, el atributo unique es solo para strings" } }); } // nombre de la propiedad a buscar var propNameDb = string.Empty; // valor de la propiedad a buscar var value = string.Empty; // atributo que vincula un clase input con una clase de base de datos var attributeLink = (BaseIndexAttribute)attributes.FirstOrDefault(s => s.GetType().IsSubclassOf(typeof(BaseIndexAttribute))); // si es nulo, se buscará una propiedad con el mismo nombre en la clase de la base de datos (T). if (attributeLink == null) { // información de las propiedad de la clase de la base de datos, que tenga el mismo bombre de la clase input. var propDbInfo = typeof(T).GetProperty(propName); // si es nulo, significa que no existe vinculo entre la clase input y la clase de la base de datos. if (propDbInfo == null) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} que tiene que ser validada, no existe en el elemento de la base de datos" } }); } // asigna un nombre para lo propiedad propNameDb = propDbInfo.Name; } // busca todas las propiedades que tengan un atributo fenix, que vincula input con base de datos. var baseIndexAttributes = typeof(T).GetProperties().Where(pinfo => Mdm.Reflection.Attributes.GetAttribute <BaseIndexAttribute>(pinfo) != null); // busca una propiedad de la clase de la base de datos, que tenga los mismos índices. var dbPropInfo = baseIndexAttributes.FirstOrDefault(s => { var attribute = Mdm.Reflection.Attributes.GetAttribute <BaseIndexAttribute>(s); return(attribute.IsEntity == attributeLink.IsEntity && attribute.Index == attributeLink.Index && attribute.KindIndex == attributeLink.KindIndex); }); // si no existe un vinculo, significa que no existe un vinculo entre la propiedad del input y el de la base de datos. if (dbPropInfo == null) { return(new ResultValidate { Valid = false, Messages = new string[] { $"La propiedad del input {className}.{propName} que tiene que ser validada, no existe en el elemento de la base de datos (BaseEntitySearch)" } }); } // asigna el nombre de la propidad que tiene la propiedad de la clase de la base de datos. propNameDb = !string.IsNullOrWhiteSpace(propNameDb)? propNameDb : dbPropInfo.Name; bool valid = true; var lst = new List <string>(); foreach (var item in castedCollectionElement) { // realiza la busqueda en la base de datos var localExists = await existElement.ExistsWithPropertyValue <T>(propNameDb, elemento.ToString(), id); if (localExists) { valid = !localExists; lst.Add($"La propiedad del input {className}.{propName} con valor {elemento} existe previamente en la base de datos"); } } return(new ResultValidate { Valid = valid, Messages = lst.ToArray() }); }
/// <summary> /// Borra un elemento de una colección de AgroData, /// la colección esta determinada por el tipo de dato. /// </summary> /// <typeparam name="T">Tipo de dato a eliminar</typeparam> /// <param name="id">identificador del elemento a eliminar</param> private static void RemoveElementFromDb <T>(string id) { // índice del tipo en el modelo mdm. var index = Mdm.GetIndex(typeof(T)); // si no tiene atributo if (!index.HasValue) { throw new System.Exception("el objeto debe tener el atributo ReferenceHeader"); } // de acuerdo al tipo de entityRelated eliminará el elemento. var entityRelated = (EntityRelated)index.Value; switch (entityRelated) { case EntityRelated.WAITINGHARVEST: AgroData.WaitingHarvest = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.WaitingHarvest); break; case EntityRelated.BARRACK: AgroData.Barracks = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Barracks); break; case EntityRelated.BUSINESSNAME: AgroData.BusinessNames = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.BusinessNames); break; case EntityRelated.CATEGORY_INGREDIENT: AgroData.IngredientCategories = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.IngredientCategories); break; case EntityRelated.CERTIFIED_ENTITY: AgroData.CertifiedEntities = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.CertifiedEntities); break; case EntityRelated.COSTCENTER: AgroData.CostCenters = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.CostCenters); break; case EntityRelated.DOSES: AgroData.Doses = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Doses); break; case EntityRelated.INGREDIENT: AgroData.Ingredients = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Ingredients); break; case EntityRelated.JOB: break; case EntityRelated.NEBULIZER: break; case EntityRelated.PHENOLOGICAL_EVENT: break; case EntityRelated.PLOTLAND: break; case EntityRelated.PRODUCT: AgroData.Products = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Products); break; case EntityRelated.ROLE: break; case EntityRelated.ROOTSTOCK: AgroData.Rootstocks = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Rootstocks); break; case EntityRelated.SEASON: AgroData.Seasons = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Seasons); break; case EntityRelated.SECTOR: AgroData.Sectors = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Sectors); break; case EntityRelated.PREORDER: break; case EntityRelated.TARGET: break; case EntityRelated.TRACTOR: break; case EntityRelated.USER: break; case EntityRelated.VARIETY: AgroData.Varieties = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Varieties); break; case EntityRelated.NOTIFICATION_EVENT: break; case EntityRelated.POLLINATOR: break; case EntityRelated.ORDER_FOLDER: break; case EntityRelated.EXECUTION_ORDER: break; case EntityRelated.ORDER: break; case EntityRelated.BARRACK_EVENT: break; case EntityRelated.DOSES_ORDER: break; case EntityRelated.EXECUTION_ORDER_STATUS: break; case EntityRelated.SPECIE: AgroData.Species = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Species); break; case EntityRelated.GEOPOINT: break; case EntityRelated.BRAND: AgroData.Brands = Mdm.Reflection.Collections.DeleteElementInCollection(id, AgroData.Brands); break; default: break; } }
/// <summary> /// Obtiene un elemento de la colección AgroData, de acuerdo al tipo, seleccionará la colección correspondente para retornar el objeto. /// </summary> /// <typeparam name="T">Tipo de elemento a retornar</typeparam> /// <param name="id">identificador del elemento</param> /// <returns></returns> private static T GetElement <T>(string id) { // índice de la clase, de acuerdo al modelo mdm. var index = Mdm.GetIndex(typeof(T)); // excepción si no tiene el atributo. if (!index.HasValue) { throw new System.Exception("el objeto debe tener el atributo ReferenceHeader"); } // de acuerdo al entityRelated entregará el elemento. var entityRelated = (EntityRelated)index.Value; switch (entityRelated) { case EntityRelated.WAITINGHARVEST: throw new Exception("waitin harvest no es un elemento de base de datos, este elemento no hereda de DocumentBase"); case EntityRelated.BARRACK: return((T)(object)AgroData.Barracks.First(s => s.Id.Equals(id))); case EntityRelated.BUSINESSNAME: return((T)(object)AgroData.BusinessNames.First(s => s.Id.Equals(id))); case EntityRelated.CATEGORY_INGREDIENT: return((T)(object)AgroData.IngredientCategories.First(s => s.Id.Equals(id))); case EntityRelated.CERTIFIED_ENTITY: return((T)(object)AgroData.CertifiedEntities.First(s => s.Id.Equals(id))); case EntityRelated.COSTCENTER: return((T)(object)AgroData.CostCenters.First(s => s.Id.Equals(id))); case EntityRelated.DOSES: return((T)(object)AgroData.Doses.First(s => s.Id.Equals(id))); case EntityRelated.INGREDIENT: return((T)(object)AgroData.Ingredients.First(s => s.Id.Equals(id))); case EntityRelated.JOB: return((T)(object)AgroData.Jobs.First(s => s.Id.Equals(id))); case EntityRelated.NEBULIZER: return((T)(object)AgroData.Nebulizers.First(s => s.Id.Equals(id))); case EntityRelated.PHENOLOGICAL_EVENT: return((T)(object)AgroData.PhenologicalEvents.First(s => s.Id.Equals(id))); case EntityRelated.PLOTLAND: return((T)(object)AgroData.PlotLands.First(s => s.Id.Equals(id))); case EntityRelated.PRODUCT: return((T)(object)AgroData.Products.First(s => s.Id.Equals(id))); case EntityRelated.ROLE: return((T)(object)AgroData.Roles.First(s => s.Id.Equals(id))); case EntityRelated.ROOTSTOCK: return((T)(object)AgroData.Rootstocks.First(s => s.Id.Equals(id))); case EntityRelated.SEASON: return((T)(object)AgroData.Seasons.First(s => s.Id.Equals(id))); case EntityRelated.SECTOR: return((T)(object)AgroData.Sectors.First(s => s.Id.Equals(id))); case EntityRelated.PREORDER: return((T)(object)AgroData.PreOrders.First(s => s.Id.Equals(id))); case EntityRelated.TARGET: return((T)(object)AgroData.ApplicationTargets.First(s => s.Id.Equals(id))); case EntityRelated.TRACTOR: return((T)(object)AgroData.Tractors.First(s => s.Id.Equals(id))); case EntityRelated.USER: break; case EntityRelated.VARIETY: return((T)(object)AgroData.Varieties.First(s => s.Id.Equals(id))); case EntityRelated.NOTIFICATION_EVENT: break; case EntityRelated.POLLINATOR: break; case EntityRelated.ORDER_FOLDER: return((T)(object)AgroData.OrderFolders.First(s => s.Id.Equals(id))); case EntityRelated.EXECUTION_ORDER: break; case EntityRelated.ORDER: break; case EntityRelated.BARRACK_EVENT: break; case EntityRelated.DOSES_ORDER: break; case EntityRelated.EXECUTION_ORDER_STATUS: break; case EntityRelated.SPECIE: return((T)(object)AgroData.Species.First(s => s.Id.Equals(id))); case EntityRelated.GEOPOINT: break; case EntityRelated.BRAND: return((T)(object)AgroData.Brands.First(s => s.Id.Equals(id))); default: throw new Exception("not good"); } throw new Exception("not good"); }
/// <summary> /// Añade un elemento a una colección de AgroData, de acuerdo al tipo de elemento a insertar. /// </summary> /// <typeparam name="T">Tipo de elemento a insertar</typeparam> /// <param name="element">elemento a insertar en una de las colecciones</param> private static void AddElement <T>(T element) where T : DocumentBase { // obtiene el índice desde mdm, utiliza el atributo para identificar a que entitySearch pertenece. var index = Mdm.GetIndex(typeof(T)); // si no tiene el atributo, lanzará error. if (!index.HasValue) { throw new System.Exception("el objeto debe tener el atributo ReferenceHeader"); } // de acuerdo al entityRelated insertaremos en la colección. var entityRelated = (EntityRelated)index.Value; switch (entityRelated) { case EntityRelated.WAITINGHARVEST: // no es un elemento de base de datos break; case EntityRelated.BARRACK: AgroData.Barracks = Mdm.Reflection.Collections.UpsertToCollection((Barrack)(object)element, AgroData.Barracks); break; case EntityRelated.BUSINESSNAME: AgroData.BusinessNames = Mdm.Reflection.Collections.UpsertToCollection((BusinessName)(object)element, AgroData.BusinessNames); break; case EntityRelated.CATEGORY_INGREDIENT: AgroData.IngredientCategories = Mdm.Reflection.Collections.UpsertToCollection((IngredientCategory)(object)element, AgroData.IngredientCategories); break; case EntityRelated.CERTIFIED_ENTITY: AgroData.CertifiedEntities = Mdm.Reflection.Collections.UpsertToCollection((CertifiedEntity)(object)element, AgroData.CertifiedEntities); break; case EntityRelated.COSTCENTER: AgroData.CostCenters = Mdm.Reflection.Collections.UpsertToCollection((CostCenter)(object)element, AgroData.CostCenters); break; case EntityRelated.DOSES: AgroData.Doses = Mdm.Reflection.Collections.UpsertToCollection((Dose)(object)element, AgroData.Doses); break; case EntityRelated.INGREDIENT: AgroData.Ingredients = Mdm.Reflection.Collections.UpsertToCollection((Ingredient)(object)element, AgroData.Ingredients); break; case EntityRelated.JOB: AgroData.Jobs = Mdm.Reflection.Collections.UpsertToCollection((Job)(object)element, AgroData.Jobs); break; case EntityRelated.NEBULIZER: AgroData.Nebulizers = Mdm.Reflection.Collections.UpsertToCollection((Nebulizer)(object)element, AgroData.Nebulizers); break; case EntityRelated.PHENOLOGICAL_EVENT: AgroData.PhenologicalEvents = Mdm.Reflection.Collections.UpsertToCollection((PhenologicalEvent)(object)element, AgroData.PhenologicalEvents); break; case EntityRelated.PLOTLAND: AgroData.PlotLands = Mdm.Reflection.Collections.UpsertToCollection((PlotLand)(object)element, AgroData.PlotLands); break; case EntityRelated.PRODUCT: AgroData.Products = Mdm.Reflection.Collections.UpsertToCollection((Product)(object)element, AgroData.Products); break; case EntityRelated.ROLE: AgroData.Roles = Mdm.Reflection.Collections.UpsertToCollection((Role)(object)element, AgroData.Roles); break; case EntityRelated.ROOTSTOCK: AgroData.Rootstocks = Mdm.Reflection.Collections.UpsertToCollection((Rootstock)(object)element, AgroData.Rootstocks); break; case EntityRelated.SEASON: AgroData.Seasons = Mdm.Reflection.Collections.UpsertToCollection((Season)(object)element, AgroData.Seasons); break; case EntityRelated.SECTOR: AgroData.Sectors = Mdm.Reflection.Collections.UpsertToCollection((Sector)(object)element, AgroData.Sectors); break; case EntityRelated.PREORDER: AgroData.PreOrders = Mdm.Reflection.Collections.UpsertToCollection((PreOrder)(object)element, AgroData.PreOrders); break; case EntityRelated.TARGET: AgroData.ApplicationTargets = Mdm.Reflection.Collections.UpsertToCollection((ApplicationTarget)(object)element, AgroData.ApplicationTargets); break; case EntityRelated.TRACTOR: AgroData.Tractors = Mdm.Reflection.Collections.UpsertToCollection((Tractor)(object)element, AgroData.Tractors); break; case EntityRelated.USER: break; case EntityRelated.VARIETY: AgroData.Varieties = Mdm.Reflection.Collections.UpsertToCollection((Variety)(object)element, AgroData.Varieties); break; case EntityRelated.NOTIFICATION_EVENT: AgroData.NotificationEvents = Mdm.Reflection.Collections.UpsertToCollection((NotificationEvent)(object)element, AgroData.NotificationEvents); break; case EntityRelated.POLLINATOR: break; case EntityRelated.ORDER_FOLDER: AgroData.OrderFolders = Mdm.Reflection.Collections.UpsertToCollection((OrderFolder)(object)element, AgroData.OrderFolders); break; case EntityRelated.EXECUTION_ORDER: break; case EntityRelated.ORDER: break; case EntityRelated.BARRACK_EVENT: break; case EntityRelated.DOSES_ORDER: break; case EntityRelated.EXECUTION_ORDER_STATUS: break; case EntityRelated.SPECIE: AgroData.Species = Mdm.Reflection.Collections.UpsertToCollection((Specie)(object)element, AgroData.Species); break; case EntityRelated.GEOPOINT: break; case EntityRelated.BRAND: AgroData.Brands = Mdm.Reflection.Collections.UpsertToCollection((Brand)(object)element, AgroData.Brands); break; default: throw new System.Exception("not good"); } }