private void UpdateChild(T originalEntity, Type parentType, ArrayList newChilds, Type Class, string childKey) { /*Get All Children from db */ System.Reflection.PropertyInfo orginalChilds = parentType.GetProperty(Class.Name); Type listType = typeof(EntityCollection <>).MakeGenericType(new Type[] { Class }); object oldDbChildList = Activator.CreateInstance(listType); oldDbChildList = orginalChilds.GetValue(originalEntity, null); /* *** */ List <Int32> oldIds = new List <int>(); List <Int32> newIds = new List <int>(); List <object> oldChildList = new List <object>(); foreach (var obj in (IEnumerable)oldDbChildList) { System.Reflection.PropertyInfo Id = Class.GetProperty(childKey); int value = Convert.ToInt32(Id.GetValue(obj, null)); oldIds.Add(value); oldChildList.Add(obj); } foreach (var obj in newChilds.ToArray(Class)) { System.Reflection.PropertyInfo Id = Class.GetProperty(childKey); int value = Convert.ToInt32(Id.GetValue(obj, null)); newIds.Add(value); string qualifiedEntitySetName = this.GetEntitySetName(Class); if (oldIds.Contains(value)) { object childToUpdate = GetUpdatedChildWithAuditInfo(oldChildList, value, obj, childKey); _context.ApplyCurrentValues(qualifiedEntitySetName, childToUpdate); } else { _context.AddObject(qualifiedEntitySetName, obj); } } foreach (var old in oldChildList) { // Are there child items in the DB which are NOT in the // new child item collection anymore? System.Reflection.PropertyInfo Id = Class.GetProperty(childKey); int value = Convert.ToInt32(Id.GetValue(old, null)); if (!newIds.Contains(value)) { // Yes -> It's a deleted child item -> Delete _context.DeleteObject(old); } } }
private void GenericUpdateEntityCollection <T>(EntityCollection <T> collection, ObjectContext dbContext) where T : EntityObject, new() { int count = collection.Count(); int current = 0; List <T> collectionItemList = collection.ToList(); bool isAdded = false; while (current < count) { Object obj = null; dbContext.TryGetObjectByKey(collectionItemList[current].EntityKey, out obj); if (obj == null) { obj = new AgentAirlineMappings(); ((T)obj).EntityKey = collectionItemList[current].EntityKey; dbContext.AddObject(((T)obj).EntityKey.EntitySetName, obj); dbContext.TryGetObjectByKey(collectionItemList[current].EntityKey, out obj); dbContext.ObjectStateManager.ChangeObjectState(obj, System.Data.EntityState.Modified); collection.CreateSourceQuery().Context.ObjectStateManager.ChangeObjectState(collectionItemList[current], System.Data.EntityState.Modified); isAdded = true; } if (obj != null) { dbContext.ApplyCurrentValues <T>(((T)obj).EntityKey.EntitySetName, collectionItemList[current]); if (isAdded) { dbContext.ObjectStateManager.ChangeObjectState(obj, System.Data.EntityState.Added); collection.CreateSourceQuery().Context.ObjectStateManager.ChangeObjectState(collectionItemList[current], System.Data.EntityState.Added); } } current++; } }
/// <summary> /// Use this to query the database with LINQ. /// NOTE: Some operations may not be supported directly on the database. If you continue to /// get errors on a query, try doing .ToList() first and performing the query in memory. /// </summary> /// <typeparam name="T">The class of the object that you want to query.</typeparam> /// <returns>A LINQ query compatible object.</returns> public T Save <T>(ref T item) where T : class, IRepoData, new() { T retval = null; object oldItem = null; var setName = db.CreateObjectSet <T>().EntitySet.Name; EntityKey itemID = item.CastTo <EntityObject>().EntityKey ?? db.CreateEntityKey(setName, item); if (db.TryGetObjectByKey(itemID, out oldItem)) { var existingItem = oldItem.CastTo <T>(); if (oldItem.IsNotNull() && existingItem.Timestamp.DropMillisecods() > item.Timestamp.DropMillisecods()) { retval = existingItem; } else { item.Timestamp = DateTime.Now; db.ApplyCurrentValues(setName, item); } } else { item.Timestamp = DateTime.Now; db.AddObject(setName, item); } return(retval); }
/// <summary> /// Uses a reliable connection retry policy and transaction /// scoping to add and submit a set of EntityObjects. /// </summary> /// <typeparam name="T">Must derive from <typeparamref name="EntityObject"/>.</typeparam> /// <param name="context">Any ObjectContext</param> /// <param name="objects">A set of <typeparamref name="EntityObject"/>s to save.</param> public static void AddObjectsAndSave <T>(this ObjectContext context, IEnumerable <T> objects) where T : EntityObject { if (!objects.Any()) { return; } var policy = new RetryPolicy <SqlAzureTransientErrorDetectionStrategy> (10, TimeSpan.FromSeconds(10)); var tso = new TransactionOptions(); tso.IsolationLevel = IsolationLevel.ReadCommitted; var name = context.GetTableName <T>(); foreach (var item in objects) { context.AddObject(name, item); } policy.ExecuteAction(() => { using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, tso)) { context.SaveChanges(); ts.Complete(); } }); }
public int Add(TElement item, bool isAddNew) { EnsureEntitySet(); Debug.Assert(_objectContext != null, "ObjectContext is null."); // If called for AddNew operation, add item to binding list, pending addition to ObjectContext. if (!isAddNew) { _objectContext.AddObject(TypeHelpers.GetFullName(_entitySet.EntityContainer.Name, _entitySet.Name), item); } _bindingList.Add(item); return(_bindingList.Count - 1); }
public void Guardar(ObjectContext contexto, SaveOptions saveOptions) { if (this.EntityKey == null) { contexto.AddObject(this.GetType().Name, this); } contexto.SaveChanges(saveOptions); }
public void Add <TEntity>(TEntity entity) where TEntity : class { if (entity == null) { throw new ArgumentNullException("entity"); } ObjectContext.AddObject(GetEntityName <TEntity>(), entity); }
public void InsertEntities <EntityType>(ObjectContext objCtx, string entitySetName, IEnumerable <EntityType> newEntities) where EntityType : class { foreach (EntityType entity in newEntities) { objCtx.AddObject(entitySetName, entity); } objCtx.DetectChanges(); objCtx.SaveChanges(); }
private TransactionLogEntry AddLogEntryToDatabase(ObjectContext ctx) { var transactionLogEntry = new TransactionLogEntry(); ctx.AddObject("Entities.TransactionLog", transactionLogEntry); ctx.SaveChanges(); return(transactionLogEntry); }
public void Save(E entity) { String entitySetName = eContainerName + "." + eClass.Name; ctx.AddObject(entitySetName, entity); ctx.SaveChanges(); ctx.Refresh(RefreshMode.StoreWins, entity); ctx.AcceptAllChanges(); }
// // original values // // Extension method for the ObjectContext which will create an object instance that is essentially equivalent // to the original object that was added or attached to the context before any changes were performed. // NOTE: This object will have no relationships--just the original value properties. public static object CreateOriginalValuesObject(this ObjectContext context, object source) { // Get the state entry of the source object // NOTE: For now we require the object to implement IEntityWithKey. // This is something we should be able to relax later. Debug.Assert(source is IEntityWithKey); EntityKey sourceKey = ((IEntityWithKey)source).EntityKey; // This method will throw if the key is null or an entry isn't found to match it. We // could throw nicer exceptions, but this will catch the important invalid cases. ObjectStateEntry sourceStateEntry = context.ObjectStateManager.GetObjectStateEntry(sourceKey); // Return null for added entities & throw an exception for detached ones. In other cases we can // always make a new object with the original values. switch (sourceStateEntry.State) { case EntityState.Added: return(null); case EntityState.Detached: throw new InvalidOperationException("Can't get original values when detached."); } // Create target object and add it to the context so that we can easily set properties using // the StateEntry. Since objects in the added state use temp keys, we know this won't // conflict with anything already in the context. object target = Activator.CreateInstance(source.GetType()); string fullEntitySetName = sourceKey.EntityContainerName + "." + sourceKey.EntitySetName; context.AddObject(fullEntitySetName, target); EntityKey targetKey = context.CreateEntityKey(fullEntitySetName, target); ObjectStateEntry targetStateEntry = context.ObjectStateManager.GetObjectStateEntry(targetKey); // Copy original values from the sourceStateEntry to the targetStateEntry. This will // cause the corresponding properties on the object to be set. for (int i = 0; i < sourceStateEntry.OriginalValues.FieldCount; i++) { // TODO: For best perf we should have a switch on the type here so that we could call // the type-specific methods and avoid boxing. targetStateEntry.CurrentValues.SetValue(i, sourceStateEntry.OriginalValues[i]); } // Detach the object we just created since we only attached it temporarily in order to use // the stateEntry. context.Detach(target); // Set the EntityKey property on the object (if it implements IEntityWithKey). IEntityWithKey targetWithKey = target as IEntityWithKey; if (targetWithKey != null) { targetWithKey.EntityKey = sourceKey; } return(target); }
/// <summary> /// Связывает сущность Entity model с контекстом данных /// </summary> public static void AttachByIdValue <TEntity>(this ObjectContext context, TEntity rootEntity) where TEntity : class, IStoreEntity { context.AddObject(typeof(TEntity).Name, rootEntity); if (rootEntity.ID != 0) { context.ObjectStateManager.GetObjectStateEntry(rootEntity).SetModified(); } }
private static void Manter(ObjectContext context, string nomeTipo, Entidade item) { if (item.Id == 0) { context.AddObject(nomeTipo, item); } else { context.ApplyOriginalValues(nomeTipo, context.GetObjectByKey(context.CreateEntityKey(nomeTipo, item))); context.ApplyCurrentValues(nomeTipo, item); } }
private ObjectStateEntry AddObjectStateEntry(EFEntityInfo entityInfo) { var ose = GetObjectStateEntry(entityInfo.Entity, false); if (ose != null) { return(ose); } ObjectContext.AddObject(entityInfo.EntitySetName, entityInfo.Entity); // Attach has lots of side effect - add has far fewer. return(GetObjectStateEntry(entityInfo)); }
public bool PersistEntity <EntityType>(ObjectContext objCtx, string entitySetName, EntityType newEntity) where EntityType : class { bool isNew = false; object oldObject = null; objCtx.TryGetObjectByKey(objCtx.CreateEntityKey(entitySetName, newEntity), out oldObject); if (oldObject == null) { objCtx.AddObject(entitySetName, newEntity); isNew = true; } else { objCtx.ApplyCurrentValues(entitySetName, newEntity); } objCtx.DetectChanges(); objCtx.SaveChanges(); return(isNew); }
public void Create(E entity) { /* Adds the object to the object context. The entity's EntityState * will be set to Added. Therefore, when SaveChanges is called, it * will be clear to the Entity Framework that this entity needs to * be inserted into the database. */ context.AddObject(GetQualifiedEntitySetName(entityClass.Name), entity); /* Persists back to the database all of the changes made to * the entities. By default, the SaveChanges method calls the method * AcceptAllChanges after it has performed the database * modifications. AcceptAllChanges pushes the current values of * every attached entity into the original values and then changes * their EntityState to Unchanged. */ context.SaveChanges(); }
public void AttachObject(EntityObject entity) { List <EntityObject> list = new List <EntityObject>(); int maxLevel = 2; int curLevel = 0; AttachObjectRelation(entity, ref list, maxLevel, curLevel); EntityKey key = entity.EntityKey; if (key != null) { GetEntity(key); lbc.ApplyPropertyChanges(entity.GetType().Name, entity); } else { lbc.AddObject(entity.GetType().Name, entity); } //for (int i = 0;i < list.Count; i++) //{ // EntityObject curEntity = list[i]; // try // { // EntityKey key = curEntity.EntityKey; // if (key != null) // { // GetEntity(key); // lbc.ApplyPropertyChanges(curEntity.GetType().Name, entity); // } // else // { // lbc.AddObject(curEntity.GetType().Name, entity); // } // } // catch (Exception ex) // { // } //} }
public static int SaveChanges <TEntity>(this ObjectContext dbContext, IEnumerable <TEntity> bindingList, string targetDbSet) { int count = 0; string fullName = targetDbSet; System.Data.Entity.EntityState?state; foreach (var item in bindingList) { TEntity i = (TEntity)item; state = (System.Data.Entity.EntityState)i.GetType().GetProperty("EntityState").GetValue(i, null); if (state != null && state == System.Data.Entity.EntityState.Detached) { dbContext.AddObject(fullName, i); } } count = dbContext.SaveChanges(); return(count); }
private void AddEntityHistories(ObjectContext ctx, EntityState state, HistoryActionType action) { IEnumerable <EntityWrapper> entities = this.Entities.Where(x => x.State == state); foreach (EntityWrapper entityWrapper in entities) { if ((entityWrapper.Entity is EntityObject) && (entityWrapper.Entity is IEntityExtend)) { CoreHistory coreHistory = HistoryManager.CreateCoreHistory((IEntityExtend)entityWrapper.Entity, action, null, null); if (entityWrapper.Entity is IWithHistory) { IList <IHistory> histories = ((IWithHistory)entityWrapper.Entity).CreateHistoryEntities(coreHistory); foreach (IHistory history in histories) { this.GetHistoryEntities(entityWrapper.Key).Add(history); ctx.AddObject(history.EntitySetName, history); } } } } }
/// <summary> /// Adds or attaches the entity to the context. If the entity has an EntityKey, /// the entity is attached, otherwise a clone of it is added. /// </summary> /// <returns>The attached entity.</returns> public static object AddOrAttachInstance(this ObjectContext context, object entity, bool applyPropertyChanges) { EntityKey entityKey = ((IEntityWithKey)entity).EntityKey; if (entityKey == null) { object attachedEntity = GetShallowEntityClone(entity); context.AddObject(context.GetEntitySetName(entity.GetType()), attachedEntity); ((IEntityWithKey)entity).EntityKey = ((IEntityWithKey)attachedEntity).EntityKey; return(attachedEntity); } else { object attachedEntity = context.GetObjectByKey(entityKey); if (applyPropertyChanges) { context.ApplyCurrentValues(entityKey.EntitySetName, entity); } return(attachedEntity); } }
public static void AddExternalIdMapping(ObjectContext context, EventOccurrenceV2 source, EventOccurrence target) { if (!string.IsNullOrEmpty(source.OccurrenceExternalId)) { var mappingExists = context.CreateObjectSet<DataImportEntityIdMap>() .Any(m => m.EntityName == "EventOccurrence" && m.InternalId == target.Id && m.ExternalId == source.OccurrenceExternalId); if (!mappingExists) { context.AddObject("DataImportEntityIdMaps", new DataImportEntityIdMap { EntityName = "EventOccurrence", DataImportId = 2, InternalId = target.Id, ExternalId = source.OccurrenceExternalId }); context.SaveChanges(); } } }
public static void AddExternalIdMapping(ObjectContext context, EventV2 source, Event theEvent) { if (!string.IsNullOrEmpty(source.EventExternalId)) { var existingMappings = context.CreateObjectSet<DataImportEntityIdMap>() .Where(m => m.EntityName == "Event" && m.InternalId == theEvent.Id) .ToList(); if (existingMappings.Count == 1) { if (existingMappings[0].ExternalId != source.EventExternalId) { // Update ExternalId on existing mapping existingMappings[0].ExternalId = source.EventExternalId; } } else { // Remove ambiguous mappings (if any) if (existingMappings.Count > 1) { foreach (var mapping in existingMappings) { context.DeleteObject(mapping); } } // Create new mapping context.AddObject("DataImportEntityIdMaps", new DataImportEntityIdMap { EntityName = "Event", DataImportId = 2, InternalId = theEvent.Id, ExternalId = source.EventExternalId }); } } }
public static void AddObjectsAndSaveWithIdentityInsert <T>( this ObjectContext context, IEnumerable <T> objects) where T : EntityObject { if (!objects.Any()) { return; } Action <IEnumerable <T> > exec = (obj) => { var policy = new RetryPolicy <SqlAzureTransientErrorDetectionStrategy> (10, TimeSpan.FromSeconds(10)); var name = context.GetTableName <T>(); foreach (var item in obj) { context.AddObject(name, item); } policy.ExecuteAction(() => { context.Connection.Open(); var trans = context.Connection.BeginTransaction(); context.ExecuteStoreCommand("SET IDENTITY_INSERT " + context.GetTableName <T>() + " ON"); context.SaveChanges(); context.ExecuteStoreCommand("SET IDENTITY_INSERT " + context.GetTableName <T>() + " OFF"); trans.Commit(); context.AcceptAllChanges(); context.Connection.Close(); }); }; context.AddObjectsAndSave(objects, doThisInstead: exec); }
public void Insert <T>(ObjectContext context, T entity, out OperationResult operationResult) where T : class, new() { try { using (context) { //context.GetTable<T>().InsertOnSubmit(entity); context.AddObject(typeof(T).Name, entity); context.SaveChanges(); operationResult = new OperationResult() { Type = OperationResult.ResultType.Success }; } } catch (Exception ex) { operationResult = new OperationResult() { Type = OperationResult.ResultType.Failure, Message = ex.StackTrace }; } }
private static void InternalAttach(ObjectContext ctx, object entity, bool addToContext, string entitySetName, List <object> analyzedEntities) { var objectType = ObjectContext.GetObjectType(entity.GetType()); var associations = ctx.MetadataWorkspace.GetItems <AssociationType>(DataSpace.OSpace); var os = ctx.MetadataWorkspace.GetItem <EntityType>(objectType.FullName, DataSpace.OSpace); var item = (EntityType)ctx.MetadataWorkspace.GetEdmSpaceType(os); var value = ((XElement)(item.KeyMembers[0].MetadataProperties.First(p => p.Name == "http://EF:InsertWhen").Value)).Value; var idType = ((PrimitiveType)item.Members[item.KeyMembers[0].Name].TypeUsage.EdmType).ClrEquivalentType; var id = entity.GetType().GetProperty(item.KeyMembers[0].Name).GetValue(entity, null); if (id.Equals(Convert.ChangeType(value, idType))) { if (addToContext) { ctx.AddObject(entitySetName, entity); } foreach (var association in ctx.MetadataWorkspace.GetItems <AssociationType>(DataSpace.CSpace).Where(a => a.AssociationEndMembers[1].Name == objectType.Name)) { var propName = association.ReferentialConstraints[0].ToProperties[0].Name; var foreignKey = entity.GetType().GetProperty(propName).GetValue(entity, null); var principalEntity = association.AssociationEndMembers[0].GetEntityType(); var principalIdInsertValue = ((XElement)(principalEntity.KeyMembers[0].MetadataProperties.First(p => p.Name == "http://EF:InsertWhen").Value)).Value; var principalIdType = ((PrimitiveType)principalEntity.Members[principalEntity.KeyMembers[0].Name].TypeUsage.EdmType).ClrEquivalentType; var navPropName = item.NavigationProperties.First(p => p.RelationshipType.FullName == association.FullName).Name; var navObject = entity.GetType().GetProperty(navPropName).GetValue(entity, null); if (!foreignKey.Equals(Convert.ChangeType(principalIdInsertValue, idType))) { ctx.ObjectStateManager.GetObjectStateEntry(navObject).ChangeState(EntityState.Unchanged); } } } else if (addToContext) { ctx.AttachTo(entitySetName, entity); } }
protected override void InsertItem(int index, T item) { base.InsertItem(index, item); objectContext.AddObject(entitySetName, item); }
/// <summary> /// Apply changes from the newEntity to the original entity /// </summary> /// <param name="objectContext">ObjectContext instance.</param> /// <param name="originalTrackedEntity">original entity which is tracked by the context.</param> /// <param name="newEntity">newEntity which contains all the changed values.</param> private static void ApplyChangesToEntity(ObjectContext objectContext, object originalTrackedEntity, object newEntity) { ObjectStateEntry objectStateEntry = objectContext.ObjectStateManager.GetObjectStateEntry(originalTrackedEntity); string entitySetName = ObjectContextServiceProvider.GetEntitySetName(objectStateEntry, objectContext.DefaultContainerName); if (objectStateEntry.State == EntityState.Added) { // In the case of batching if we do a PUT after POST in the same changeset, we need to detach and re-add. objectContext.Detach(originalTrackedEntity); objectContext.AddObject(entitySetName, newEntity); } else { #pragma warning disable 618 // Since we use to do this in V1, keeping the same code there. // Apply property changes as specified in the new object. objectContext.ApplyPropertyChanges(entitySetName, newEntity); #pragma warning restore 618 } }
public void PersistCreationOf(IAggregateRoot entity) { _objectContext.AddObject(GetEntitySetName(), entity); }
public void Create(T entity) { objectContext.AddObject(entitySetName, entity); }
public void InsertEntity <EntityType>(ObjectContext objCtx, string entitySetName, EntityType newEntity) where EntityType : class { objCtx.AddObject(entitySetName, newEntity); objCtx.SaveChanges(); }
public static void GenerarHojadeRuta(ObjectContext pContext, DateTime FInicio, DateTime FFin, Entidades.ContratoEmpresas pContratoEmpresas) { string queryString = @"SELECT VALUE CabeceraHojasDeRuta FROM EntidadesConosud.CabeceraHojasDeRuta AS CabeceraHojasDeRuta"; ObjectQuery <Entidades.CabeceraHojasDeRuta> CabeceraHojasDeRutaQuery1 = new ObjectQuery <Entidades.CabeceraHojasDeRuta>(queryString, pContext); DateTime FechaInicio = FInicio; DateTime FechaFinal = FFin; int ultimonrocarpeta = 1; try { ultimonrocarpeta = CabeceraHojasDeRutaQuery1.Max(c => c.NroCarpeta); ultimonrocarpeta += 1; } catch { } long id = Convert.ToInt64(Helpers.EstadosHoja.NoAprobada); IEnumerable <KeyValuePair <string, object> > entityKeyValues = new KeyValuePair <string, object>[] { new KeyValuePair <string, object>("IdClasificacion", id) }; EntityKey key = new EntityKey("EntidadesConosud.Clasificacion", entityKeyValues); Entidades.Clasificacion _est = (Entidades.Clasificacion)pContext.GetObjectByKey(key); /// Guardo la ultima cabecera antes de generar las nuevas para /// luego obtener los legados de la mism. Entidades.CabeceraHojasDeRuta UltimaCabecera = null; if (pContratoEmpresas.IdContratoEmpresas > 0) { if (!pContratoEmpresas.CabeceraHojasDeRuta.IsLoaded) { pContratoEmpresas.CabeceraHojasDeRuta.Load(); } UltimaCabecera = pContratoEmpresas.CabeceraHojasDeRuta.OrderBy(w => w.Periodo).Last(); } while (GeneraxFecha(ref FechaInicio, ref FechaFinal)) { if (UltimaCabecera == null || !(UltimaCabecera.Periodo.Month == FechaFinal.Month && UltimaCabecera.Periodo.Year == FechaFinal.Year)) { /// control por las dudas que el primer periodo que se intenta crear ya existe. if (UltimaCabecera == null || string.Format("{0:MMyyyy}", FechaInicio) != string.Format("{0:MMyyyy}", UltimaCabecera.Periodo)) { /// controlo que el periodo que se esta intentando crear no exista ya. if (!pContratoEmpresas.CabeceraHojasDeRuta.Any(w => string.Format("{0:MMyyyy}", w.Periodo) == string.Format("{0:MMyyyy}", FechaInicio))) { /// Genero la cabecera de hoja de ruta Entidades.CabeceraHojasDeRuta _CabHojaRuta = new Entidades.CabeceraHojasDeRuta(); _CabHojaRuta.ContratoEmpresas = pContratoEmpresas; _CabHojaRuta.Estado = _est; _CabHojaRuta.Periodo = FechaInicio; _CabHojaRuta.NroCarpeta = ultimonrocarpeta; _CabHojaRuta.Estimacion = string.Empty; _CabHojaRuta.EsFueraTermino = false; pContext.AddObject("EntidadesConosud.CabeceraHojasDeRuta", _CabHojaRuta); queryString = @"SELECT VALUE Plantilla FROM EntidadesConosud.Plantilla AS Plantilla"; ObjectQuery <Entidades.Plantilla> PlantillaQuery1 = new ObjectQuery <Entidades.Plantilla>(queryString, pContext); /// Genero los items de las hojas de ruta foreach (Entidades.Plantilla plan in PlantillaQuery1.Select(p => p)) { Entidades.HojasDeRuta _HojasDeRuta = new Entidades.HojasDeRuta(); _HojasDeRuta.Plantilla = plan; _HojasDeRuta.HojaAprobado = false; _HojasDeRuta.HojaComentario = string.Empty; _HojasDeRuta.AuditadoPor = string.Empty; _HojasDeRuta.DocComentario = string.Empty; _CabHojaRuta.HojasDeRuta.Add(_HojasDeRuta); pContext.AddObject("EntidadesConosud.HojasDeRuta", _HojasDeRuta); } /// Asocio los legajos a la nueva cabecera if (UltimaCabecera != null) { if (!UltimaCabecera.ContEmpLegajos.IsLoaded) { UltimaCabecera.ContEmpLegajos.Load(); } foreach (Entidades.ContEmpLegajos itemContLeg in UltimaCabecera.ContEmpLegajos) { if (!itemContLeg.LegajosReference.IsLoaded) { itemContLeg.LegajosReference.Load(); } Entidades.ContEmpLegajos newContLeg = new Entidades.ContEmpLegajos(); newContLeg.ContratoEmpresas = pContratoEmpresas; newContLeg.Legajos = itemContLeg.Legajos; _CabHojaRuta.ContEmpLegajos.Add(newContLeg); pContext.AddObject("EntidadesConosud.ContEmpLegajos", newContLeg); } } } } } FechaInicio = FechaInicio.AddMonths(1); ultimonrocarpeta += 1; } }
/// <summary> /// Insert new data into context /// </summary> /// <typeparam name="E"></typeparam> /// <param name="entity"></param> public void Add(TEntity entity) { //_ctx.AddObject(entity.GetType().Name, entity); _ctx.AddObject(GetEntitySetName(_ctx), entity); }
private static DiscountCode CreateEventDiscountCode(ObjectContext context, DiscountCodeDtoV2 code) { int discountTypeId = LookupDiscountType(context, code.DiscountType); var discountCode = new DiscountCode { Code = code.Code, Description = code.Description, DiscountTypeId = discountTypeId, DiscountValue = Convert.ToDecimal(code.DiscountValue, CultureInfo.InvariantCulture), StartDate = string.IsNullOrEmpty(code.StartDate) ? new DateTime?() : DateTime.Parse(code.StartDate, CultureInfo.InvariantCulture), EndDate = string.IsNullOrEmpty(code.StartDate) ? new DateTime?() : DateTime.Parse(code.EndDate, CultureInfo.InvariantCulture), IsEnabled = bool.Parse(code.IsEnabled), IsGroupCode = bool.Parse(code.IsGroupCode), IsFromOrgUnit = false, RequiredGroupSize = int.Parse(code.RequiredGroupSize, CultureInfo.InvariantCulture), }; context.AddObject("DiscountCodes", discountCode); return discountCode; }
public static EventOccurrence BuildNewOccurrence(ObjectContext objectContext, int newEventId, EventOccurrence item) { var newOccurrence = new EventOccurrence { ContactName = item.ContactName, ContactEmail = item.ContactEmail, ContactPhone = item.ContactPhone, ContactPhoneExtension = item.ContactPhoneExtension, Cost = item.Cost, CostCenter = item.CostCenter, OrgUnitId = item.OrgUnitId, MaximumAttendees = item.MaximumAttendees, LastUpdated = System.DateTime.UtcNow, PaymentProcessorConfigurationId = item.PaymentProcessorConfigurationId, IsRegistrationEnabled = item.IsRegistrationEnabled, IsNotificationListEnabled = item.IsNotificationListEnabled, IsNotifyContactEnabled = item.IsNotifyContactEnabled, SpecialInstructions = item.SpecialInstructions, LocationOrgUnitId = item.LocationOrgUnitId, LocationName = item.LocationName, Address1 = item.Address1, Address2 = item.Address2, City = item.City, PostalCode = item.PostalCode, StateId = item.StateId, CountryId = item.CountryId, Latitude = item.Latitude, Longitude = item.Longitude, IsGuestDemographicInfoRequired = item.IsGuestDemographicInfoRequired }; newOccurrence.SetPresenter(item.Presenter); newOccurrence.SetIsEnabled(item.IsEnabled); newOccurrence.SetEventId(newEventId); newOccurrence.SetAddress1(item.Address1); newOccurrence.SetAddress2(item.Address2); newOccurrence.SetRegistrationDates(item.RegistrationStartDate, item.RegistrationEndDate); if (item.IsPriceScheduleEnabled) newOccurrence.EnablePricingSchedule(); else newOccurrence.DisablePricingSchedule(); CaptureCostScheduleData(item, newOccurrence); objectContext.AddObject("EventOccurrences", newOccurrence); objectContext.SaveChanges(); //event occurrence documents foreach (var doc in item.EventOccurrencesDocuments) { var newDoc = new EventOccurrencesDocument() { DocumentPath = doc.DocumentPath, EventOccurrence = newOccurrence }; newOccurrence.EventOccurrencesDocuments.Add(newDoc); } //event occurrence dates foreach (var dateItem in item.EventOccurrenceDates) { newOccurrence.AddOccurrenceDate(dateItem.StartDate, dateItem.EndDate); } objectContext.SaveChanges(); return newOccurrence; }
/// <summary> /// Adds the given entity to the context. /// </summary> public static void AddObject(this ObjectContext context, object entity) { context.AddObject(context.GetEntitySetName(entity.GetType()), entity); }