internal List <IMigrationAction> LoadPagedActions(IEnumerable <RTChangeAction> rtChangeActions) { List <IMigrationAction> realizedMigrationActions = new List <IMigrationAction>(); SqlChangeGroup parentChangeGroup = null; RTChangeGroup parentRTGroup = null; foreach (RTChangeAction rtChangeAction in rtChangeActions) { if (parentRTGroup == null) { parentChangeGroup = new SqlChangeGroup(this); rtChangeAction.ChangeGroupReference.Load(); parentRTGroup = rtChangeAction.ChangeGroup; } IMigrationAction migrationAction = parentChangeGroup.RealizeFromEDMWithSingleAction(parentRTGroup, rtChangeAction); if (null != migrationAction) { realizedMigrationActions.Add(migrationAction); } } return(realizedMigrationActions); }
public override ChangeGroup CreateForMigrationInstructionTable(ChangeGroup deltaTableChangeGroup) { ChangeGroup group = new SqlChangeGroup(this, (SqlChangeGroup)deltaTableChangeGroup); group.Status = ChangeStatus.PendingConflictDetection; return(group); }
public override IMigrationAction LoadSingleAction(long actionInternalId) { IMigrationAction retAction = null; using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { Guid sessionUniqueId = new Guid(Session.SessionUniqueId); var actions = (from ca in context.RTChangeActionSet where ca.ChangeActionId == actionInternalId select ca); if (actions.Count() > 0) { RTChangeAction rtChangeAction = actions.First(); rtChangeAction.ChangeGroupReference.Load(); RTChangeGroup parentRTGroup = rtChangeAction.ChangeGroup; SqlChangeGroup parentChangeGroup = new SqlChangeGroup(this); retAction = parentChangeGroup.RealizeFromEDMWithSingleAction(parentRTGroup, rtChangeAction); } } return(retAction); }
private static ChangeGroup realizeChangeGroup(SqlDataReader reader, ChangeGroupManager manager) { SqlChangeGroup group = null; if (reader != null && reader.HasRows) { if (reader.Read()) { loadOrdinalCache(reader); group = new SqlChangeGroup(manager); group.ChangeGroupId = reader.GetInt32(s_ordinalChangeGroupId); group.ChangeTimeUtc = reader.GetDateTime(s_ordinalChangeTime); group.Comment = reader.GetString(s_ordinalComment); group.ExecutionOrder = reader.GetInt64(s_ordinalExecutionOrder); group.Owner = reader.GetString(s_ordinalOwner); group.Status = (ChangeStatus)reader.GetInt32(s_ordinalStatus); group.SessionId = new Guid(reader.GetString(s_ordinalSessionId)); group.SourceId = reader.GetGuid(s_ordinalSourceId); // TODO DB changed neededgroup.Direction = (MigrationDirection)reader.GetInt32(s_ordinalDirection); group.Name = reader.GetString(s_ordinalName); } if (reader.Read()) { throw new MigrationException(MigrationToolkitResources.TooManyChangeGroupsReturned); } } return(group); }
public override ReadOnlyCollection <KeyValuePair <MigrationAction, MigrationAction> > DetectContentConflict() { List <KeyValuePair <MigrationAction, MigrationAction> > conflictActions = new List <KeyValuePair <MigrationAction, MigrationAction> >(); Dictionary <long, SqlChangeGroup> loadedChangeGroups = new Dictionary <long, SqlChangeGroup>(); using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { foreach (VCContentConflictResult contentConflictResults in context.QueryContentConflict(SourceId, new Guid(Session.SessionUniqueId))) { RTChangeAction migrationInstructionAction = context.RTChangeActionSet.Where(a => a.ChangeActionId == contentConflictResults.MigrationInstructionChangeActionId).First(); RTChangeAction deltaAction = context.RTChangeActionSet.Where(a => a.ChangeActionId == contentConflictResults.DeltaChangeActionId).First(); SqlMigrationAction conflictActionSource = SqlMigrationAction.RealizeFromDB(migrationInstructionAction); if (loadedChangeGroups.ContainsKey(migrationInstructionAction.ChangeGroupId)) { conflictActionSource.ChangeGroup = loadedChangeGroups[migrationInstructionAction.ChangeGroupId]; } else { RTChangeGroup migrationInstructionChangeGroup = context.RTChangeGroupSet.Where(c => c.Id == migrationInstructionAction.ChangeGroupId).First(); SqlChangeGroup conflictChangeGroupSource = new SqlChangeGroup(this); conflictChangeGroupSource.RealizeFromEDMWithSingleAction(migrationInstructionChangeGroup, migrationInstructionAction); loadedChangeGroups.Add(migrationInstructionAction.ChangeGroupId, conflictChangeGroupSource); conflictActionSource.ChangeGroup = conflictChangeGroupSource; } SqlMigrationAction conflictActionTarget = SqlMigrationAction.RealizeFromDB(deltaAction); if (loadedChangeGroups.ContainsKey(deltaAction.ChangeGroupId)) { conflictActionTarget.ChangeGroup = loadedChangeGroups[deltaAction.ChangeGroupId]; } else { RTChangeGroup deltaChangeGroup = context.RTChangeGroupSet.Where(c => c.Id == deltaAction.ChangeGroupId).First(); SqlChangeGroup conflictChangeGroupTarget = new SqlChangeGroup(this); conflictChangeGroupTarget.RealizeFromEDMWithSingleAction(deltaChangeGroup, deltaAction); loadedChangeGroups.Add(deltaAction.ChangeGroupId, conflictChangeGroupTarget); conflictActionTarget.ChangeGroup = conflictChangeGroupTarget; } conflictActions.Add(new KeyValuePair <MigrationAction, MigrationAction>(conflictActionSource, conflictActionTarget)); } } return(conflictActions.AsReadOnly()); }
/// <summary> /// constructor. Saves partial change group to db. /// </summary> /// <param name="manager"></param> /// <param name="copyFromGroup"></param> public SqlChangeGroup( ChangeGroupManager manager, SqlChangeGroup copyFromGroup) : base(manager) { Name = copyFromGroup.Name; ExecutionOrder = copyFromGroup.ExecutionOrder; Owner = copyFromGroup.Owner; ChangeTimeUtc = copyFromGroup.ChangeTimeUtc; Comment = copyFromGroup.Comment; RevisionTime = copyFromGroup.RevisionTime; ExecutionOrder = copyFromGroup.ExecutionOrder; Status = copyFromGroup.Status; ListenToDefaultActionCollectionChange(); }
private IEnumerable <ChangeGroup> GetChangeGroupTablePageByStatus( int pageNumber, int pageSize, Guid sessionUniqueId, ChangeStatus status, bool useOtherSideMigrationItemSerializers, bool includeGroupInBacklog) { List <ChangeGroup> deltaTableEntries = new List <ChangeGroup>(); using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { int statusVal = (int)status; IQueryable <RTChangeGroup> query; if (includeGroupInBacklog) { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && cg.Status == statusVal orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } else { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && cg.Status == statusVal && !cg.ContainsBackloggedAction orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } foreach (RTChangeGroup rtChangeGroup in query) { SqlChangeGroup changeGroup = new SqlChangeGroup(this); changeGroup.UseOtherSideMigrationItemSerializers = useOtherSideMigrationItemSerializers; changeGroup.RealizeFromEDM(rtChangeGroup); deltaTableEntries.Add(changeGroup); } } return(deltaTableEntries); }
internal void BatchSaveGroupedChangeActions(IList <IMigrationAction> page) { // note that we assume all IMigrationActions in page belongs to the same change group if (page.Count == 0) { return; } ChangeGroup changeGroup = page.First().ChangeGroup; Debug.Assert(null != changeGroup, "IMigrationAction does not have a parent ChangeGroup"); SqlChangeGroup sqlChangeGroup = changeGroup as SqlChangeGroup; Debug.Assert(null != sqlChangeGroup, "Cannot convert IMigrationAction.ChangeGroup to SqlChangeGroup"); sqlChangeGroup.BatchSaveChangeActions(page); }
/// <summary> /// Discard a migration instruction change group and reactivate the corresponding delta table entry /// </summary> /// <param name="migrationInstructionEntry"></param> /// <returns>The corresponding delta table entry</returns> internal override ChangeGroup DiscardMigrationInstructionAndReactivateDelta(ChangeGroup migrationInstructionEntry) { Debug.Assert(migrationInstructionEntry.ReflectedChangeGroupId.HasValue, "migrationInstructionEntry.ReflectedChangeGroupId does not have value"); RTChangeGroup rtChangeGroup = null; using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { long migrInstrId = migrationInstructionEntry.ChangeGroupId; var migrInstr = context.RTChangeGroupSet.Where(g => g.Id == migrInstrId); long deltaId = migrationInstructionEntry.ReflectedChangeGroupId.Value; var delta = context.RTChangeGroupSet.Where(g => g.Id == deltaId); if (migrInstr.Count() != 1 || delta.Count() != 1) { return(null); } migrInstr.First().Status = (int)ChangeStatus.Obsolete; rtChangeGroup = delta.First(); rtChangeGroup.Status = (int)ChangeStatus.DeltaPending; context.TrySaveChanges(); context.Detach(rtChangeGroup); } SqlChangeGroup changeGroup = new SqlChangeGroup(this); changeGroup.UseOtherSideMigrationItemSerializers = true; changeGroup.RealizeFromEDM(rtChangeGroup); return(changeGroup); }
public override ChangeGroup CreateForDeltaTable(string groupName) { ChangeGroup group = new SqlChangeGroup(this, groupName, ChangeStatus.Delta); return(group); }
public override ChangeGroup Create(string groupName) { ChangeGroup group = new SqlChangeGroup(this, groupName, ChangeStatus.AnalysisMigrationInstruction); return(group); }
internal override int PromoteAnalysisToPending(IMigrationTransaction trx) { return(SqlChangeGroup.PromoteAnalysisToPending(trx, Session.SessionUniqueId, SourceId)); }
public override IEnumerable <ChangeGroup> NextMigrationInstructionTablePage( int pageNumber, int pageSize, bool isInConflictDetectionState, bool includeGroupInBacklog) { Guid sessionUniqueId = new Guid(Session.SessionUniqueId); int pendingDetection = (int)ChangeStatus.PendingConflictDetection; int pending = (int)ChangeStatus.Pending; List <ChangeGroup> deltaTableEntries = new List <ChangeGroup>(); using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { IQueryable <RTChangeGroup> query; if (includeGroupInBacklog) { if (isInConflictDetectionState) { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && (cg.Status == pendingDetection || cg.Status == pending) orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } else { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && cg.Status == pending orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } } else { if (isInConflictDetectionState) { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && (cg.Status == pendingDetection || cg.Status == pending) && !cg.ContainsBackloggedAction orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } else { query = (from cg in context.RTChangeGroupSet where cg.SessionUniqueId.Equals(sessionUniqueId) && cg.SourceUniqueId.Equals(SourceId) && cg.Status == pending && !cg.ContainsBackloggedAction orderby cg.Id select cg).Skip(pageNumber * pageSize).Take(pageSize); } } foreach (RTChangeGroup rtChangeGroup in query) { SqlChangeGroup changeGroup = new SqlChangeGroup(this); changeGroup.UseOtherSideMigrationItemSerializers = true; changeGroup.RealizeFromEDM(rtChangeGroup); deltaTableEntries.Add(changeGroup); } } return(deltaTableEntries); }
public override int PromoteAnalysisToPending() { return(SqlChangeGroup.PromoteAnalysisToPending(Session.SessionUniqueId, SourceId)); }
public override ChangeGroup Next() { return(SqlChangeGroup.Next(this)); }