private void DeleteUser(DtDelta delta) { var adusername = sqlService.GetUserForId(delta.DataForDelete).AdUsername; adservice.DeleteUser(adusername); sqlService.RemoveUserRecord(delta.DataForDelete); }
private void DeleteGroup(DtDelta delta) { var username = sqlService.GetGroupnameForId(delta.DataForDelete); adservice.DeleteGroup(username); sqlService.RemoveGroupRecord(username); }
private void InsertDedupeDeltaAction(DtDelta rootDelta, DtDelta latestDelta, List <DeltaAction> result) { if (rootDelta.Seq == latestDelta.Seq) { //if rootDelta == latestDelta, then there are no later sequenced deltas. //but there may be prior ones in the results. // check if rootDelta exists as new delta. if not, then add if (!result.Exists(d => d.NewDelta.Seq == rootDelta.Seq)) { result.Add(new DeltaAction(rootDelta, latestDelta)); } //else can ignore, as will be picked up by resolver } else { if (result.Exists(d => d.NewDelta.Seq == latestDelta.Seq)) { //if latestDelta exists as new delta //then old delta should be identical. check, then set oldest as rootDelta. var existing = result.First(d => d.NewDelta.Seq == latestDelta.Seq); if (existing.OldDelta.Seq > rootDelta.Seq) { result.Remove(existing); result.Add(new DeltaAction(rootDelta, latestDelta)); } } else { result.Add(new DeltaAction(rootDelta, latestDelta)); } } }
private List <DeltaAction> PairGroupDeltas(IEnumerable <DtDelta> deltas) { var inserts = deltas.Where(d => !d.IsDelete); var deletes = deltas.Where(d => d.IsDelete); var result = new List <DeltaAction>(); //old values, new values foreach (var rootDelta in deltas) { //this is the root entry //recurse through other entries to find final related entry var foundEnd = false; var latestDelta = rootDelta; do { DtDelta temp = null; temp = FindNextRelatedGroupDelta(latestDelta, inserts, deletes); if (temp != null) { latestDelta = temp; } else { foundEnd = true; } } while (!foundEnd); InsertDedupeDeltaAction(rootDelta, latestDelta, result); } return(result); }
private void CreateUser(DtDelta delta) { var user = delta.DataAsUser; adservice.CreateUser(ref user); sqlService.CreateUserRecord(user); //removed autoemail //emailservice.SendWelcomeEmail(user); }
private void UpdateUser(DtDelta delta) { var userData = delta.DataAsUser; var savedUser = sqlService.GetUserForId(userData.Id); userData.AdUsername = savedUser.AdUsername; if (adservice.UpdateUser(delta.DataAsUser)) { sqlService.UpdateUserRecord(userData); } }
private DtDelta FindNextRelatedGroupDelta(DtDelta rootDtDelta, IEnumerable <DtDelta> allInserts, IEnumerable <DtDelta> allDeletes) { DtDelta result = null; if (rootDtDelta.Action == DtDelta.DeleteAction) { //get username for this deletion id var groupnameToDelete = string.Empty; var earlierInsert = allInserts. FirstOrDefault(i => i.Seq < rootDtDelta.Seq && i.DataAsGroup.Id == rootDtDelta.DataForDelete); if (earlierInsert != null) { groupnameToDelete = earlierInsert.DataAsGroup.Name; } //if there's no value in the array, there may be one in the db if (string.IsNullOrWhiteSpace(groupnameToDelete)) { groupnameToDelete = sqlService.GetGroupnameForId(rootDtDelta.DataForDelete); } //if you can't find a record for this Id, you can't proceed. Something is wrong with data. if (string.IsNullOrWhiteSpace(groupnameToDelete)) { throw new Exception(string.Format("No role insert record found for this id: {0}", rootDtDelta.DataForDelete)); } //search for next insert for same username as delete var insertsForGroupname = allInserts. Where(i => i.Seq > rootDtDelta.Seq && i.DataAsGroup.Name == groupnameToDelete) .OrderBy(a => a.Seq); if (insertsForGroupname.Any()) { result = insertsForGroupname.First(); } } else if (rootDtDelta.Action == DtDelta.InsertAction) { //search for delete action for same id var deletesForId = allDeletes. Where(i => i.Seq > rootDtDelta.Seq && i.DataForDelete == rootDtDelta.DataAsGroup.Id); if (deletesForId.Any()) { result = deletesForId.First(); } } return(result); }
private DtDelta FindSubsequentUserRoleDeletion(DtDelta rootDtDelta, IEnumerable <DtDelta> allDeletes) { DtDelta result = null; if (!rootDtDelta.IsDelete) { //search for delete action for same id result = allDeletes. FirstOrDefault(i => i.Seq > rootDtDelta.Seq && i.DataForDelete == rootDtDelta.DataAsUserGroup.Id); } return(result); }
public IEnumerable <DtDelta> GetDeltas(string documentName, int currentDelta) { var offset = 0; var hasMore = true; var result = new List <DtDelta>(); do { var docString = client.GetDelta(documentName, offset, ReadLimit, currentDelta); var jarray = JsonConvert.DeserializeObject <JArray>(docString); if (jarray == null) { hasMore = false; continue; } if (jarray.Count == 1) { if (jarray[0].Type != JTokenType.Object) { hasMore = false; continue; } } foreach (var delta in jarray) { var datowniaDelta = new DtDelta().FromContentRow(delta); result.Add(datowniaDelta); } if (jarray.Count < ReadLimit) { hasMore = false; } else { offset += ReadLimit; } } while (hasMore); return(result); }
private List <DtDelta> RemoveRedundantDeltas(IEnumerable <DtDelta> deltas) { //normally, we follow the chain of alternate deletes and inserts //resulting in: //a delete then insert => this is an update //or a delete then delete (via one or more inserts) => this is a delete of the old value //or an insert then delete => cancels out //or an insert then insert (via one or more deletes) => only insert the latest value //BUT //in this case, we need to do this: //if it's a delete we can't check for subsequent inserts, due to compound key. // we cannot find a chain. this means we process the delete on AD individually. //if it's an insert, we can look for a corresponding deletion and ignore both // if no deletion is found, then we're looking at a standalone insertion. process as such. var deletes = deltas.Where(d => d.IsDelete); var result = new List <DtDelta>(); //old values, new values foreach (var rootDelta in deltas) { DtDelta nextDelta = null; if (rootDelta.IsDelete) { //it is a delete. result.Add(rootDelta); } else { nextDelta = FindSubsequentUserRoleDeletion(rootDelta, deletes); if (nextDelta == null) { //data is an insert. result.Add(rootDelta); } //else the insert gets deleted so can be ignored } } return(result); }
private void ResolveUserGroupDelta(DtDelta action) { if (action.IsDelete) { //remove from AD var userRole = sqlService.GetUserGroupForId(action.DataForDelete); if (userRole != null) { var user = sqlService.GetUserByUsername(userRole.Username); if (user != null) { var adUsername = user.AdUsername; adservice.RemoveUserGroup(adUsername, userRole.Group); } //remove from sql sqlService.RemoveUserGroupRecord(action.DataForDelete); } } else { //add to AD var userRole = action.DataAsUserGroup; var userByUsername = sqlService.GetUserByUsername(userRole.Username); if (userByUsername == null) { Trace.WriteLine("Could not find user related to group"); return; } var adUsername = userByUsername.AdUsername; adservice.AddUserGroup(adUsername, userRole.Group); //insert into sql sqlService.CreateUserGroupRecord(userRole); } }
private void CreateGroup(DtDelta delta) { adservice.CreateGroup(delta.DataAsGroup); sqlService.CreateGroupRecord(delta.DataAsGroup); }