public void DoAction(SynchronizeContext synchronizeContext)
		{
			using (DirectoryEntry parentEntry = synchronizeContext.ADHelper.NewEntry(parentDn))
			{
				using (DirectoryEntry targetObject = SynchronizeHelper.GetSearchResultByID(this.targetObjectID).GetDirectoryEntry())
				{
					try
					{
						targetObject.MoveTo(parentEntry);
					}
					catch (DirectoryServicesCOMException comEx)
					{
						switch (comEx.ErrorCode)
						{
							case -2147019886:
								//重名
								SynchronizeHelper.SolveConflictAboutMove(oguObject, targetObject, parentEntry);
								break;
							default:
								WriteLog(synchronizeContext, comEx.Message);
								break;
						}
					}
				}
			}
		}
        public void DoAction(SynchronizeContext synchronizeContext)
        {
            using (DirectoryEntry parentEntry = synchronizeContext.ADHelper.NewEntry(parentDn))
            {
                using (DirectoryEntry targetObject = SynchronizeHelper.GetSearchResultByID(this.targetObjectID).GetDirectoryEntry())
                {
                    try
                    {
                        targetObject.MoveTo(parentEntry);
                    }
                    catch (DirectoryServicesCOMException comEx)
                    {
                        switch (comEx.ErrorCode)
                        {
                        case -2147019886:
                            //重名
                            SynchronizeHelper.SolveConflictAboutMove(oguObject, targetObject, parentEntry);
                            break;

                        default:
                            WriteLog(synchronizeContext, comEx.Message);
                            break;
                        }
                    }
                }
            }
        }
		private static void ModifyGroups(KeyedOguObjectCollection groups, SynchronizeContext context)
		{
			for (int i = 0; i < groups.Count / SynchronizeHelper.ADQueryBatchSize; i++)
				ModifyBatchGroups(groups, (i * SynchronizeHelper.ADQueryBatchSize), SynchronizeHelper.ADQueryBatchSize, context);

			ModifyBatchGroups(groups, groups.Count / SynchronizeHelper.ADQueryBatchSize, groups.Count % SynchronizeHelper.ADQueryBatchSize, context);
		}
Esempio n. 4
0
        /// <summary>
        /// 执行Action操作
        /// </summary>
        /// <param stringValue="context"></param>
        public void DoActions(SynchronizeContext context)
        {
            for (int i = 0; i < this.Count; i++)
            {
                SynchronizeContext.Current.ExtendLockTime();

                this[i].DoAction(context);
            }

            this.Clear();
        }
Esempio n. 5
0
 public void WriteLog(SynchronizeContext context)
 {
     context.ExceptionCount++;
     SynchronizeHelper.WithDirectoryEntry(context.ADHelper, this.adObjectID, targetObject =>
     {
         LogHelper.WriteSynchronizeDBLogDetail(SynchronizeContext.Current.SynchronizeID, "重命名", oguObject.ID, oguObject.Name,
                                               context.ADHelper.GetPropertyStrValue("objectGuid", targetObject),
                                               context.ADHelper.GetPropertyStrValue("distinguishedName", targetObject),
                                               string.Format("延迟修改:登录名修改执行错误 AD对象:{0},权限中心对象:{1}。", targetObject.Name, this.oguObject.Name));
     }, null);
 }
 public void WriteLog(SynchronizeContext context, string message)
 {
     context.ExceptionCount++;
     SynchronizeHelper.WithDirectoryEntry(this.targetObjectID, targetObject =>
     {
         LogHelper.WriteDBLogDetail(SynchronizeContext.Current.SynchronizeID, "移动对象", this.oguObject.ID, this.oguObject.Name,
                                    context.ADHelper.GetPropertyStrValue("objectGuid", targetObject),
                                    context.ADHelper.GetPropertyStrValue("distinguishedName", targetObject),
                                    string.Format("无法移动{0}到{1},错误消息{2}。", this.oguObject.Name, this.parentDn, message));
     }, null);
 }
		public void WriteLog(SynchronizeContext context, string message)
		{
			context.ExceptionCount++;
			SynchronizeHelper.WithDirectoryEntry(this.targetObjectID, targetObject =>
			{
				LogHelper.WriteDBLogDetail(SynchronizeContext.Current.SynchronizeID, "移动对象", this.oguObject.ID, this.oguObject.Name,
								 context.ADHelper.GetPropertyStrValue("objectGuid", targetObject),
								 context.ADHelper.GetPropertyStrValue("distinguishedName", targetObject),
								 string.Format("无法移动{0}到{1},错误消息{2}。", this.oguObject.Name, this.parentDn, message));

			}, null);
		}
		public void WriteLog(SynchronizeContext context)
		{
			context.ExceptionCount++;
			SynchronizeHelper.WithDirectoryEntry(context.ADHelper, this.adObjectID, targetObject =>
			{
				LogHelper.WriteSynchronizeDBLogDetail(SynchronizeContext.Current.SynchronizeID, "重命名", oguObject.ID, oguObject.Name,
								 context.ADHelper.GetPropertyStrValue("objectGuid", targetObject),
								 context.ADHelper.GetPropertyStrValue("distinguishedName", targetObject),
								 string.Format("延迟修改:重命名{0}为{1}未能执行。", targetObject.Name, this.oguObject.Name));

			}, null);
		}
		public void DoAction(SynchronizeContext context)
		{
			try
			{
				var result = SynchronizeHelper.GetSearchResultByID(context.ADHelper, this.adObjectID);
				using (System.DirectoryServices.DirectoryEntry ent = result.GetDirectoryEntry())
				{
					ent.Rename(oguObject.ObjectType.SchemaTypeToPrefix() + "=" + ADHelper.EscapeString(oguObject.Name));
					ent.CommitChanges();
				}
			}
			catch
			{
				this.WriteLog(context);
			}
		}
Esempio n. 10
0
 public void DoAction(SynchronizeContext context)
 {
     try
     {
         var result = SynchronizeHelper.GetSearchResultByID(context.ADHelper, this.adObjectID);
         using (System.DirectoryServices.DirectoryEntry ent = result.GetDirectoryEntry())
         {
             ent.Properties[this.adPropertyName].Value = oguObject.Properties[oguPropertyName];
             ent.CommitChanges();
         }
     }
     catch
     {
         this.WriteLog(context);
     }
 }
Esempio n. 11
0
 public void DoAction(SynchronizeContext context)
 {
     try
     {
         var result = SynchronizeHelper.GetSearchResultByID(context.ADHelper, this.adObjectID);
         using (System.DirectoryServices.DirectoryEntry ent = result.GetDirectoryEntry())
         {
             ent.Rename(oguObject.ObjectType.SchemaTypeToPrefix() + "=" + ADHelper.EscapeString(oguObject.Name));
             ent.CommitChanges();
         }
     }
     catch
     {
         this.WriteLog(context);
     }
 }
		public void DoAction(SynchronizeContext context)
		{
			try
			{
				var result = SynchronizeHelper.GetSearchResultByID(context.ADHelper, this.adObjectID);
				using (System.DirectoryServices.DirectoryEntry ent = result.GetDirectoryEntry())
				{
					ent.Properties[this.adPropertyName].Value = oguObject.Properties[oguPropertyName];
					ent.CommitChanges();
				}
			}
			catch
			{
				this.WriteLog(context);
			}
		}
Esempio n. 13
0
		private static void ModifyBatchGroups(KeyedOguObjectCollection groups, int startIndex, int batchSize, SynchronizeContext context)
		{
			//Key是AD Guid,Value是Ogu ID
			Dictionary<string, string> adToOguMapping = GetADToOguMappingFromGroups(groups, startIndex, batchSize, context);

			string[] propertiesToGet = { "objectguid", "member" };
			IEnumerable<SearchResult> adGroups = SynchronizeHelper.GetSearchResultsByIDs(context.ADHelper, adToOguMapping.Keys, propertiesToGet, batchSize);

			foreach (SearchResult adGroup in adGroups)
			{
				SynchronizeContext.Current.ExtendLockTime();

				string guid = AttributeHelper.Hex((byte[])adGroup.Properties["objectguid"][0]);

				ADGroupMemberCollection adGroupMembers = new ADGroupMemberCollection(adGroup.Properties["member"], new string[] { "objectGUID" });

				Dictionary<string, ADObjectWrapper> adMemberDict = adGroupMembers.ToDictionary(o => o.NativeGuid);
				IGroup oguGroup = (IGroup)groups[adToOguMapping[guid]];

				if (IsSameMembers(oguGroup.Members, adMemberDict) == false)
					SyncGroupMembers(oguGroup, adGroup, context);
			}
		}
Esempio n. 14
0
		private static void SyncGroupMembers(IGroup oguGroup, SearchResult adGroup, SynchronizeContext context)
		{
			using (DirectoryEntry adEntry = adGroup.GetDirectoryEntry())
			{
				try
				{
					var members = adEntry.Properties["member"];
					members.Clear();

					AddGroupMembers(oguGroup.Members.ToIDList(), members, context);

					adEntry.CommitChanges();
				}
				catch (Exception ex)
				{
					context.ExceptionCount++;

					LogHelper.WriteSynchronizeDBLogDetail(SynchronizeContext.Current.SynchronizeID, "修改群组成员", oguGroup.ID, oguGroup.Name,
									 context.ADHelper.GetPropertyStrValue("objectGuid", adEntry),
									 context.ADHelper.GetPropertyStrValue("distinguishedName", adEntry),
									 string.Format("修改群组成员时出错:" + ex.Message));
				}
			}
		}
Esempio n. 15
0
		private static void FillGroupMembersByOguIDs(IEnumerable<string> oguObjectIDs, PropertyValueCollection adGroupMembers, SynchronizeContext context)
		{
			IEnumerable<SearchResult> result = SynchronizeHelper.GetSearchResultsByIDs(context.ADHelper, context.IDMapper.GetMappedADObjectIDs(oguObjectIDs),
				new string[] { "distinguishedName" }, oguObjectIDs.Count());

			foreach (SearchResult sr in result)
			{
				SynchronizeContext.Current.ExtendLockTime();

				adGroupMembers.Add(sr.Properties["distinguishedName"][0]);
			}
		}
Esempio n. 16
0
		private static Dictionary<string, string> GetADToOguMappingFromGroups(KeyedOguObjectCollection groups, int startIndex, int batchSize, SynchronizeContext context)
		{
			Dictionary<string, string> result = new Dictionary<string, string>();

			for (int i = startIndex; i < startIndex + batchSize; i++)
			{
				SynchronizeContext.Current.ExtendLockTime();

				IDMapping mapping = context.IDMapper.GetAdObjectMapping(groups[i].ID);

				result.Add(mapping.ADObjectGuid, mapping.SCObjectID);
			}

			return result;
		}
Esempio n. 17
0
		private static void AddGroupMembers(IList<string> oguMemberIDs, PropertyValueCollection adGroupMembers, SynchronizeContext context)
		{
			for (int i = 0; i < oguMemberIDs.Count / SynchronizeHelper.ADQueryBatchSize; i++)
			{
				SynchronizeContext.Current.ExtendLockTime();

				FillGroupMembersByOguIDs(CopyPartOfList(oguMemberIDs, i * SynchronizeHelper.ADQueryBatchSize, SynchronizeHelper.ADQueryBatchSize), adGroupMembers, context);
			}

			FillGroupMembersByOguIDs(CopyPartOfList(oguMemberIDs,
				(oguMemberIDs.Count / SynchronizeHelper.ADQueryBatchSize) * SynchronizeHelper.ADQueryBatchSize,
				oguMemberIDs.Count % SynchronizeHelper.ADQueryBatchSize),
				adGroupMembers, context);
		}