public void Intercept(IInvocation invocation)
{
var methodInfo = invocation.Method;
Object[] attributes = methodInfo.GetCustomAttributes(true);
var directoryAttri = attributes.SingleOrDefault(a => a is DirectoryAttribute) as DirectoryAttribute;
var clusterAttri = attributes.SingleOrDefault(a => a is ClusterAttribute) as ClusterAttribute;
var loadBalanceAttri = attributes.SingleOrDefault(a => a is LoadBalanceAttribute) as LoadBalanceAttribute;
var protocolAttri = attributes.SingleOrDefault(a => a is ProtocolAttribute) as ProtocolAttribute;
ConstructorInfo constr = protocolAttri.ContextType.GetConstructors()[0];
ParameterInfo[] parameters = constr.GetParameters();
object[] constrParamters = new Object[parameters.Length];
constrParamters[0] = new DirectoryContext(directoryAttri.Path, directoryAttri.Directory);
constrParamters[1] = new ClusterContext(clusterAttri.Name);
constrParamters[2] = new LoadBalanceContext(loadBalanceAttri.Name);
for (var i = 3; i < parameters.Length; i++)
{
Object value = PropertyHelper.GetPropertyValue(protocolAttri.GetType(), protocolAttri, parameters[i].Name);
constrParamters[i] = value;
}
var invokeContext = Activator.CreateInstance(protocolAttri.ContextType, constrParamters) as InvokerContext;
invocation.SetArgumentValue(invocation.Arguments.Length - 1, invokeContext);
invocation.Proceed();
}
public override NT_STATUS GetAttributes(UserContext UserContext, string PathName, out DirectoryContext data) //, SearchFlag SF)
{
//FIXME: attributes? what attributes?
data = new DirectoryContext();
string FileName = root + PathName;
DateTime dd = new DateTime(2007, 1, 1);
if (phone.Exists(FileName) && !phone.IsDirectory(FileName))
{
data.Attrib = FileAttributes.Normal;
data.CreationTime = dd;
data.LastAccessTime = dd;
data.LastWriteTime = dd;
data.FileSize = (long)phone.FileSize(FileName); // data.AllocationSize willbe set to the same value
data.Name = Path.GetFileName(FileName);
data.ShortName = ""; //GetShortName(PathName);
return(NT_STATUS.OK);
}
if (phone.Exists(FileName) && phone.IsDirectory(FileName))
{
data.Attrib = FileAttributes.Directory;
data.CreationTime = dd;
data.LastAccessTime = dd;
data.LastWriteTime = dd;
data.FileSize = (long)phone.FileSize(FileName);
string[] DirName = PathName.Split("/\\".ToCharArray());
data.Name = (DirName.Length > 0)?DirName[DirName.Length - 1]:"/";
data.ShortName = "";//GetShortName(FileName);
return(NT_STATUS.OK);
}
// Now we know that the object is not there, let's see if the path (=UpperDir) is valid
if (!Directory.Exists(root + Path.GetDirectoryName(PathName)))
{
return(NT_STATUS.OBJECT_PATH_NOT_FOUND);
}
return(NT_STATUS.OBJECT_NAME_NOT_FOUND);
}
// Methods
public static ActiveDirectorySite FindByName(DirectoryContext context, string siteName) {}
public ReplicationConnection(DirectoryContext context, string name, DirectoryServer sourceServer, ActiveDirectorySchedule schedule)
{
}
public static ActiveDirectorySiteLinkBridge FindByName(DirectoryContext context, string bridgeName, ActiveDirectoryTransportType transport) {}
public static ActiveDirectorySchemaProperty FindByName(DirectoryContext context, string ldapDisplayName) {}
public static DomainControllerCollection FindAll(DirectoryContext context) {}
// Methods
public static DomainController GetDomainController(DirectoryContext context) {}
protected override void InternalExecute()
{
Stopwatch stopwatch = Stopwatch.StartNew();
//////////////////////////////////////////////////
string exportPath;
string assPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
exportPath = Path.Combine(Path.GetDirectoryName(assPath), "export-pic");
if (!Directory.Exists(exportPath))
{
Directory.CreateDirectory(exportPath);
}
TeamFoundationIdentity SIDS = ims2.ReadIdentity(IdentitySearchFactor.AccountName, "Team Foundation Valid Users", MembershipQuery.Expanded, ReadIdentityOptions.None);
Trace.WriteLine(string.Format("Found {0}", SIDS.Members.Count()));
var itypes = (from IdentityDescriptor id in SIDS.Members select id.IdentityType).Distinct();
foreach (string item in itypes)
{
var infolks = (from IdentityDescriptor id in SIDS.Members where id.IdentityType == item select id);
Trace.WriteLine(string.Format("Found {0} of {1}", infolks.Count(), item));
}
var folks = (from IdentityDescriptor id in SIDS.Members where id.IdentityType == "System.Security.Principal.WindowsIdentity" select id);
DirectoryContext objContext = new DirectoryContext(DirectoryContextType.Domain, config.Domain, config.Username, config.Password);
Domain objDomain = Domain.GetDomain(objContext);
string ldapName = string.Format("LDAP://{0}", objDomain.Name);
int current = folks.Count();
foreach (IdentityDescriptor id in folks)
{
try
{
TeamFoundationIdentity i = ims2.ReadIdentity(IdentitySearchFactor.Identifier, id.Identifier, MembershipQuery.Direct, ReadIdentityOptions.None);
if (!(i == null) && i.IsContainer == false)
{
DirectoryEntry d = new DirectoryEntry(ldapName, config.Username, config.Password);
DirectorySearcher dssearch = new DirectorySearcher(d);
dssearch.Filter = string.Format("(sAMAccountName={0})", i.UniqueName.Split(char.Parse(@"\"))[1]);
SearchResult sresult = dssearch.FindOne();
WebClient webClient = new WebClient();
webClient.Credentials = CredentialCache.DefaultNetworkCredentials;
if (sresult != null)
{
string newImage = Path.Combine(exportPath, string.Format("{0}.jpg", i.UniqueName.Replace(@"\", "-")));
if (!File.Exists(newImage))
{
DirectoryEntry deUser = new DirectoryEntry(sresult.Path, config.Username, config.Password);
Trace.WriteLine(string.Format("{0} [PROCESS] {1}: {2}", current, deUser.Name, newImage));
string empPic = string.Format(config.PictureEmpIDFormat, deUser.Properties["employeeNumber"].Value);
try
{
webClient.DownloadFile(empPic, newImage);
}
catch (Exception ex)
{
Trace.WriteLine(string.Format(" [ERROR] {0}", ex.ToString()));
}
}
else
{
Trace.WriteLine(string.Format("{0} [SKIP] Exists {1}", current, newImage));
}
}
webClient.Dispose();
}
}
catch (Exception ex)
{
Trace.WriteLine(string.Format(" [ERROR] {0}", ex.ToString()));
}
current--;
}
//////////////////////////////////////////////////
stopwatch.Stop();
Trace.WriteLine(string.Format(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed));
}
internal ActiveDirectoryPartition(DirectoryContext context, string name)
{
this.context = context;
this.partitionName = name;
}
public void GetDomainController_InvalidIPV6_ThrowsInvalidCastException()
{
var context = new DirectoryContext(DirectoryContextType.DirectoryServer, "[::1]:port");
Assert.Throws <InvalidCastException>(() => DomainController.GetDomainController(context));
}
public void GetDomainController_InvalidName_ThrowsActiveDirectoryObjectNotFoundException(string name)
{
var context = new DirectoryContext(DirectoryContextType.DirectoryServer, name);
Assert.Throws <ActiveDirectoryObjectNotFoundException>(() => DomainController.GetDomainController(context));
}
public void FindAll_NullName_ThrowsActiveDirectoryOperationException()
{
var context = new DirectoryContext(DirectoryContextType.Domain);
Assert.Throws <ActiveDirectoryOperationException>(() => DomainController.FindAll(context));
}
public CommandHandler(DirectoryContext directory)
{
_directory = directory;
}
public QueryHandler(DirectoryContext directory)
{
_directory = directory;
}
public ActiveDirectorySubnet(DirectoryContext context, string subnetName, string siteName) {}
public static ConfigurationSet GetConfigurationSet(DirectoryContext context) {}
public CommandHandler(DirectoryContext dbContext)
{
_dbContext = dbContext;
}
public static DomainController FindOne(DirectoryContext context, string siteName) {}
public static GlobalCatalog FindOne(DirectoryContext context, string siteName)
{
}
public static GlobalCatalog FindOne(DirectoryContext context, string siteName, LocatorOptions flag)
{
}
public static GlobalCatalogCollection FindAll(DirectoryContext context)
{
}
// Constructors
public ActiveDirectorySiteLinkBridge(DirectoryContext context, string bridgeName) {}
public static GlobalCatalogCollection FindAll(DirectoryContext context, string siteName)
{
}
public ReplicationConnection(DirectoryContext context, string name, DirectoryServer sourceServer, ActiveDirectorySchedule schedule, ActiveDirectoryTransportType transport)
{
}
// Methods
public static GlobalCatalog GetGlobalCatalog(DirectoryContext context)
{
}
public WebApiInvokerContext(DirectoryContext directoryContext, ClusterContext clusterContext, LoadBalanceContext loadBalanceContext, string method = "POST", string contentType = "application/json")
: base(directoryContext, clusterContext, loadBalanceContext)
{
this.Method = method;
this.ContentType = contentType;
}
public static GlobalCatalog FindOne(DirectoryContext context)
{
}
// Methods
public static ApplicationPartition GetApplicationPartition(DirectoryContext context) {}
// Methods
public static ActiveDirectorySubnet FindByName(DirectoryContext context, string subnetName)
{
}
public InvokerContext(DirectoryContext directoryContext, ClusterContext clusterContext, LoadBalanceContext loadBalanceContext)
{
this.Directory = directoryContext;
this.Cluster = clusterContext;
this.LoadBalance = loadBalanceContext;
}
public ActiveDirectorySubnet(DirectoryContext context, string subnetName, string siteName)
{
}
// Methods
public static ActiveDirectorySubnet FindByName(DirectoryContext context, string subnetName) {}
public static void ReadRemoteHostFQDN(string hostname, out string hostFQDN)
{
hostFQDN = string.Empty; string domain = string.Empty;
uint error = CNetlogon.GetCurrentDomain(out domain);
if (error != 0 && String.IsNullOrEmpty(domain))
{
return;
}
string[] rootDNcom = domain.Split('.');
string rootDN = ""; string errorMessage = "";
foreach (string str in rootDNcom)
{
string temp = string.Concat("dc=", str, ",");
rootDN = string.Concat(rootDN, temp);
}
rootDN = rootDN.Substring(0, rootDN.Length - 1);
try
{
DirectoryContext dirContext = DirectoryContext.CreateDirectoryContext
(domain,
rootDN,
null,
null,
389,
false,
out errorMessage);
if (!String.IsNullOrEmpty(errorMessage))
{
Logger.ShowUserError(errorMessage);
}
if (dirContext == null)
{
return;
}
List <LdapEntry> ldapEntries = new List <LdapEntry>();
string[] attrs = { "name", "dNSHostName", null };
int ret = dirContext.ListChildEntriesSynchronous
(rootDN,
LdapAPI.LDAPSCOPE.SUB_TREE,
string.Format("(&(objectClass=computer)(cn={0}))", hostname),
attrs,
false,
out ldapEntries);
if (ldapEntries == null)
{
return;
}
LdapEntry ldapNextEntry = ldapEntries[0];
string[] attrsList = ldapNextEntry.GetAttributeNames();
Logger.Log("The number of attributes are " + attrsList.Length, Logger.ldapLogLevel);
if (attrsList != null)
{
foreach (string attr in attrsList)
{
if (attr.Trim().Equals("dNSHostName"))
{
LdapValue[] attrValues = ldapNextEntry.GetAttributeValues(attr, dirContext);
if (attrValues != null && attrValues.Length > 0)
{
hostFQDN = attrValues[0].stringData;
break;
}
}
}
}
}
catch (Exception ex)
{
hostFQDN = string.Empty;
Logger.LogException("EventAPI.ReadRemoteHostFQDN", ex);
}
}
public static DomainControllerCollection FindAll(DirectoryContext context, string siteName) {}
public CommunicationTypeRepository(DirectoryContext directoryContext)
{
_directoryContext = directoryContext;
}
public static DomainController FindOne(DirectoryContext context) {}
public async Task ActiveBrothers_AreInCorrectOrder()
{
await _dbContext.Database.EnsureDeletedAsync();
_dbContext.SaveChanges();
DateTime sameDate = DateTime.Now;
List <Brother> brotherList = new List <Brother> {
// Should be 1 (Zeta number)
new Brother {
FirstName = "FName", LastName = "LName", ExpectedGraduation = DateTime.MaxValue, ZetaNumber = 1
},
// Should be 2 (Zeta number)
new Brother {
FirstName = "FName1", LastName = "LName1", ExpectedGraduation = DateTime.MaxValue, ZetaNumber = 2
},
// Should be 3 (Join date)
new Brother {
FirstName = "FName2", LastName = "LName2", ExpectedGraduation = DateTime.MaxValue, DateJoined = sameDate.AddDays(-5)
},
// Should be 4 (Join date)
new Brother {
FirstName = "FName3", LastName = "LName3", ExpectedGraduation = DateTime.MaxValue, DateJoined = sameDate.AddDays(-3)
},
// Should be 5 (Last name)
new Brother {
FirstName = "ZFirst", LastName = "ALast", ExpectedGraduation = DateTime.MaxValue, DateJoined = sameDate
},
// Should be 6 (First name)
new Brother {
FirstName = "AFirst", LastName = "ZLast", ExpectedGraduation = DateTime.MaxValue, DateJoined = sameDate
},
// Should be 7 (First name)
new Brother {
FirstName = "ZFirst", LastName = "ZLast", ExpectedGraduation = DateTime.MaxValue, DateJoined = sameDate
}
};
DirectoryContext dbContext = new DirectoryContext(new DbContextOptionsBuilder <DirectoryContext>()
.UseInMemoryDatabase("directory")
.Options);
await dbContext.Brother.AddRangeAsync(brotherList);
await dbContext.SaveChangesAsync();
BrotherController controller = new BrotherController(dbContext, new ClaimsPrincipal(), Mock.Of <ILogger <BrotherController> >());
Assert.Multiple(() => {
OkObjectResult result = controller.GetBrothers() as OkObjectResult;
Assert.That(result, Is.Not.Null);
IEnumerable <MinimalBrother> brothers = (result.Value as ContentModel <MinimalBrother>)?.Content;
Assert.That(brothers, Is.Not.Null);
Assert.That(brothers.Count(), Is.EqualTo(7));
for (int i = 0; i < brotherList.Count; i++)
{
MinimalBrother actual = brothers.ElementAt(i);
Brother expected = brotherList[i];
Assert.That(actual.LastName, Is.EqualTo(expected.LastName));
Assert.That(actual.FirstName, Is.EqualTo(expected.FirstName));
Assert.That(actual.ZetaNumber, Is.EqualTo(expected.ZetaNumber));
Assert.That(actual.DateJoined, Is.EqualTo(expected.DateJoined));
}
});
}
public static DomainController FindOne(DirectoryContext context, string siteName, LocatorOptions flag) {}
protected override void InternalProcessRecord()
{
bool flag;
if ("Exchange Control Panel".Equals(base.Host.Name, StringComparison.OrdinalIgnoreCase))
{
flag = ServerCache.Instance.InitializeIfNeeded(HostId.ECPApplicationPool);
}
else
{
flag = ServerCache.Instance.InitializeIfNeeded(HostId.PowershellApplicationPool);
}
if (!flag)
{
Utils.HandleError(this, "Cannot initialize AD configuration", CoreStrings.TrackingErrorFailedToInitialize, this.BypassDelegateChecking, false, ErrorCategory.ObjectNotFound, null);
}
DirectoryContext directoryContext = null;
int num = 0;
MessageTrackingReport messageTrackingReport = null;
TrackingEventBudget trackingEventBudget = null;
try
{
TrackingEventBudget.AcquireThread();
if (this.TraceLevel == TraceLevel.High)
{
CommonDiagnosticsLogTracer traceWriter = new CommonDiagnosticsLogTracer();
TraceWrapper.SearchLibraryTracer.Register(traceWriter);
BaseTrace.CurrentThreadSettings.EnableTracing();
}
if (base.ExchangeRunspaceConfig == null)
{
ExTraceGlobals.TaskTracer.TraceError((long)this.GetHashCode(), "Get-MessageTrackingReport permissions cannot be retrieved because the ExchangeRunspaceConfiguration is null");
base.WriteError(new TrackingSearchException(CoreStrings.TrackingSearchNotAuthorized), ErrorCategory.InvalidOperation, this.Identity);
}
ReportConstraints reportConstraints = new ReportConstraints();
SmtpAddress[] recipientPathFilter = null;
if (base.Fields.Contains("RecipientPathFilter"))
{
recipientPathFilter = new SmtpAddress[]
{
this.RecipientPathFilter
};
}
reportConstraints.BypassDelegateChecking = this.BypassDelegateChecking;
reportConstraints.DetailLevel = this.DetailLevel;
reportConstraints.DoNotResolve = this.DoNotResolve;
reportConstraints.RecipientPathFilter = recipientPathFilter;
reportConstraints.Recipients = this.Recipients;
reportConstraints.ReportTemplate = this.ReportTemplate;
reportConstraints.ResultSize = this.ResultSize;
reportConstraints.TrackingAsSender = this.Identity.IsSender;
reportConstraints.Sender = SmtpAddress.Empty;
ReportConstraints reportConstraints2 = reportConstraints;
_DeliveryStatus? deliveryStatus = this.status;
int?num2 = (deliveryStatus != null) ? new int?((int)deliveryStatus.GetValueOrDefault()) : null;
reportConstraints2.Status = ((num2 != null) ? new DeliveryStatus?((DeliveryStatus)num2.GetValueOrDefault()) : null);
reportConstraints.ReturnQueueEvents = this.ShouldReturnQueueEvents();
if (this.Identity.IsSender)
{
ADRecipient adrecipient = base.TenantGlobalCatalogSession.FindByExchangeGuid(this.Identity.UserGuid);
if (adrecipient != null)
{
reportConstraints.Sender = adrecipient.PrimarySmtpAddress;
}
}
MultiValuedProperty <CultureInfo> executingUserLanguages = base.ExchangeRunspaceConfig.ExecutingUserLanguages;
CultureInfo clientCulture = (executingUserLanguages != null && executingUserLanguages.Count > 0) ? executingUserLanguages[0] : CultureInfo.InvariantCulture;
ClientContext clientContext = null;
ClientSecurityContext clientSecurityContext = null;
bool flag2 = false;
try
{
clientSecurityContext = Utils.GetSecurityContextForUser(base.ExchangeRunspaceConfig.SecurityAccessToken, base.ExchangeRunspaceConfig.DelegatedPrincipal, this.trackedUser.ADUser);
clientContext = ClientContext.Create(clientSecurityContext, base.CurrentOrganizationId, null, null, clientCulture, null);
OrganizationId currentOrganizationId = base.TenantGlobalCatalogSession.SessionSettings.CurrentOrganizationId;
TrackingErrorCollection errors = new TrackingErrorCollection();
TimeSpan timeout = Utils.GetTimeout(this.BypassDelegateChecking);
trackingEventBudget = new TrackingEventBudget(errors, timeout);
directoryContext = new DirectoryContext(clientContext, currentOrganizationId, base.GlobalConfigSession, this.ConfigurationSession, base.TenantGlobalCatalogSession, trackingEventBudget, SearchMessageTrackingReport.GetDiagnosticsLevel(this.TraceLevel, base.Fields.IsModified("TraceLevel")), errors, false);
directoryContext.Acquire();
flag2 = true;
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Task, Names <DeliveryReportsTask> .Map[1]);
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.OpType, Names <OpType> .Map[0]);
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Mid, this.Identity.ToString());
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Data1, Names <ReportTemplate> .Map[(int)this.ReportTemplate]);
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Usr, this.trackedUser.SmtpAddress.ToString());
if (this.BypassDelegateChecking)
{
ADObjectId adobjectId;
if (base.TryGetExecutingUserId(out adobjectId))
{
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.ExUser, adobjectId.Name);
}
else
{
ExTraceGlobals.TaskTracer.TraceDebug((long)this.GetHashCode(), "ExecutingUserId is null.");
}
}
directoryContext.DiagnosticsContext.WriteEvent();
LogCache logCache = new LogCache(DateTime.MinValue, DateTime.MaxValue, directoryContext.TrackingBudget);
this.getMessageTrackingReport = new GetMessageTrackingReportImpl(directoryContext, SearchScope.World, this.Identity.InternalMessageTrackingReportId, logCache, reportConstraints);
MessageTrackingReport messageTrackingReport2 = this.getMessageTrackingReport.Execute();
MultiValuedProperty <CultureInfo> userLanguages;
if (this.executingUser != null)
{
userLanguages = (this.executingUser[ADUserSchema.Languages] as MultiValuedProperty <CultureInfo>);
}
else
{
userLanguages = new MultiValuedProperty <CultureInfo>(Thread.CurrentThread.CurrentUICulture);
}
bool flag3 = false;
if (messageTrackingReport2 == null)
{
base.WriteError(new TrackingExceptionNoResultsDueToLogsExpired(), ErrorCategory.ObjectNotFound, this.Identity);
}
else
{
if (messageTrackingReport2.HasHandedOffPaths && !this.Identity.IsSender)
{
flag3 = true;
bool flag4 = this.TryGetReportForRecipientOrganization(directoryContext, logCache, reportConstraints, userLanguages, out messageTrackingReport2);
if (flag4 && messageTrackingReport2 == null)
{
base.WriteError(new TrackingExceptionNoResultsDueToUntrackableMessagePath(), ErrorCategory.ObjectNotFound, this.Identity);
}
else if (!flag4)
{
base.WriteError(new TrackingExceptionNoResultsDueToLogsNotFound(), ErrorCategory.ObjectNotFound, this.Identity);
}
}
messageTrackingReport = MessageTrackingReport.Create(this.ConfigurationSession, base.TenantGlobalCatalogSession, userLanguages, this.ReportTemplate == ReportTemplate.Summary, this.DetailLevel == MessageTrackingDetailLevel.Verbose, this.Identity.IsSender, messageTrackingReport2, this.DoNotResolve, this.getMessageTrackingReport.Errors.Errors.Count == 0);
if (messageTrackingReport == null)
{
ExTraceGlobals.TaskTracer.TraceDebug <int>((long)this.GetHashCode(), "Report is null while internalReport is not null and has {0} events", (messageTrackingReport2.RecipientTrackingEvents == null) ? 0 : messageTrackingReport2.RecipientTrackingEvents.Length);
base.WriteError(new TrackingExceptionNoResultsDueToLogsNotFound(), ErrorCategory.ObjectNotFound, this.Identity);
}
else
{
num = ((messageTrackingReport.RecipientTrackingEvents == null) ? 0 : messageTrackingReport.RecipientTrackingEvents.Length);
messageTrackingReport = this.FilterReport(messageTrackingReport);
if (messageTrackingReport == null && !flag3 && !this.Identity.IsSender)
{
bool flag5 = this.TryGetReportForRecipientOrganization(directoryContext, logCache, reportConstraints, executingUserLanguages, out messageTrackingReport2);
if (!flag5)
{
base.WriteError(new TrackingExceptionNoResultsDueToLogsNotFound(), ErrorCategory.ObjectNotFound, this.Identity);
}
else if (flag5 && messageTrackingReport2 == null)
{
base.WriteError(new TrackingExceptionNoResultsDueToUntrackableMessagePath(), ErrorCategory.ObjectNotFound, this.Identity);
}
else
{
messageTrackingReport = MessageTrackingReport.Create(this.ConfigurationSession, base.TenantGlobalCatalogSession, userLanguages, this.ReportTemplate == ReportTemplate.Summary, this.DetailLevel == MessageTrackingDetailLevel.Verbose, this.Identity.IsSender, messageTrackingReport2, this.DoNotResolve, this.getMessageTrackingReport.Errors.Errors.Count == 0);
messageTrackingReport = this.FilterReport(messageTrackingReport);
if (messageTrackingReport == null)
{
base.WriteError(new TrackingExceptionNoResultsDueToUntrackableMessagePath(), ErrorCategory.ObjectNotFound, this.Identity);
}
}
}
if (messageTrackingReport != null)
{
if (base.NeedSuppressingPiiData)
{
Utils.RedactRecipientTrackingEvents(messageTrackingReport.RecipientTrackingEvents, this);
}
this.WriteResult(messageTrackingReport);
}
}
}
}
catch (AuthzException)
{
base.WriteError(new TrackingSearchException(CoreStrings.TrackingSearchNotAuthorized), ErrorCategory.InvalidOperation, this.Identity);
}
finally
{
if (directoryContext != null && flag2)
{
directoryContext.Yield();
}
if (clientContext != null)
{
clientContext.Dispose();
}
if (clientSecurityContext != null)
{
clientSecurityContext.Dispose();
}
}
}
catch (TrackingTransientException ex)
{
Utils.HandleTrackingException(directoryContext, ex, this, false, this.BypassDelegateChecking);
}
catch (TrackingFatalException ex2)
{
Utils.HandleTrackingException(directoryContext, ex2, this, false, this.BypassDelegateChecking);
}
catch (DataSourceOperationException ex3)
{
Utils.HandleError(this, ex3.ToString(), ex3.LocalizedString, this.BypassDelegateChecking, false, ErrorCategory.InvalidData, null);
}
catch (DataValidationException ex4)
{
Utils.HandleError(this, ex4.ToString(), ex4.LocalizedString, this.BypassDelegateChecking, false, ErrorCategory.InvalidData, null);
}
catch (TransientException ex5)
{
Utils.HandleError(this, ex5.ToString(), ex5.LocalizedString, this.BypassDelegateChecking, true, ErrorCategory.InvalidData, null);
}
finally
{
if ((this.BypassDelegateChecking || this.ReportTemplate == ReportTemplate.RecipientPath || messageTrackingReport == null || messageTrackingReport.RecipientTrackingEvents == null || messageTrackingReport.RecipientTrackingEvents.Length == 0) && this.getMessageTrackingReport != null)
{
Utils.WriteWarnings(this, directoryContext, this.BypassDelegateChecking, this.getMessageTrackingReport.Errors.Errors);
}
if (trackingEventBudget != null)
{
trackingEventBudget.Dispose();
}
if (directoryContext != null)
{
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Task, Names <DeliveryReportsTask> .Map[1]);
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.OpType, Names <OpType> .Map[1]);
directoryContext.DiagnosticsContext.AddProperty(DiagnosticProperty.Cnt, num);
directoryContext.DiagnosticsContext.WriteEvent();
Utils.WriteDiagnostics(this, directoryContext.DiagnosticsContext, base.NeedSuppressingPiiData);
}
if (this.TraceLevel == TraceLevel.High)
{
TraceWrapper.SearchLibraryTracer.Unregister();
BaseTrace.CurrentThreadSettings.DisableTracing();
}
TrackingEventBudget.ReleaseThread();
if (directoryContext == null || Utils.AreAnyErrorsLocalToThisForest(directoryContext.Errors.Errors))
{
PerfCounterData.ResultCounter.AddFailure();
}
else
{
PerfCounterData.ResultCounter.AddSuccess();
}
if (ServerCache.Instance.HostId == HostId.ECPApplicationPool)
{
InfoWorkerMessageTrackingPerformanceCounters.MessageTrackingFailureRateTask.RawValue = (long)PerfCounterData.ResultCounter.FailurePercentage;
}
}
}
// Constructors
public ActiveDirectorySchemaClass(DirectoryContext context, string ldapDisplayName) {}
/// <summary>
///
/// </summary>
/// <param name="entry"></param>
/// <param name="scope"></param>
/// <param name="context"></param>
public EntrySetCollectionQueryProvider(EntryObject entry, SearchScope scope, DirectoryContext context) : base(context)
{
_entry = entry;
_scope = scope;
}
// Methods
public static Domain GetDomain(DirectoryContext context) {}
public static void CreateNewConnection(string sourceServer, string targetServer, string connectionName)
{
try
{
// set a directory server context for the source server
DirectoryContext sourceContext = new DirectoryContext(
DirectoryContextType.DirectoryServer,
sourceServer);
// set a directory server context for the target server
DirectoryContext targetContext = new DirectoryContext(
DirectoryContextType.DirectoryServer,
targetServer);
// bind to a specific domain controller to serve as the
// source of a replication connection
DomainController sourceDc =
DomainController.GetDomainController(sourceContext);
ReplicationConnection connection = new ReplicationConnection(
targetContext,
connectionName,
sourceDc);
// set change notification status
connection.ChangeNotificationStatus = NotificationStatus.IntraSiteOnly;
// create a customized replication schedule
ActiveDirectorySchedule schedule = new ActiveDirectorySchedule();
schedule.SetDailySchedule(HourOfDay.Twelve,
MinuteOfHour.Zero,
HourOfDay.Fifteen,
MinuteOfHour.Zero);
schedule.SetSchedule(DayOfWeek.Sunday,
HourOfDay.Eight,
MinuteOfHour.Zero,
HourOfDay.Eleven,
MinuteOfHour.Zero);
schedule.SetSchedule(DayOfWeek.Saturday,
HourOfDay.Seven,
MinuteOfHour.Zero,
HourOfDay.Ten,
MinuteOfHour.Zero);
connection.ReplicationSchedule = schedule;
connection.ReplicationScheduleOwnedByUser = true;
// save the new connection to the directory
connection.Save();
Console.WriteLine("\nNew replication connection created successfully\n" +
"from server {0} to {1}.\n The connection appears in the NTDS " +
"settings of {1}", sourceServer, targetServer);
}
catch (Exception e)
{
Console.WriteLine("\r\nUnexpected exception occured:\n{0}:{1}",
e.GetType().Name, e.Message);
}
}
public ActionResult SearchResultsRead([DataSourceRequest] DataSourceRequest request)
{
EmployeeSearchAdditionalData employeeSearchAdditionalData = new EmployeeSearchAdditionalData();
TryUpdateModel(employeeSearchAdditionalData);
int searchType = FindSearchType(employeeSearchAdditionalData);
if (searchType == 0)
{
return null;
}
string domain = ConfigurationManager.AppSettings["LDAPDomain"];
string serviceUser = ConfigurationManager.AppSettings["ServiceUser"];
string servicePassword = ConfigurationManager.AppSettings["ServicePassword"];
LdapDirectoryIdentifier ldapDirectoryIdentifier = new LdapDirectoryIdentifier(domain);
NetworkCredential myCredentials = new NetworkCredential(serviceUser, servicePassword);
LdapConnection connection = new LdapConnection(ldapDirectoryIdentifier, myCredentials, AuthType.Basic);
connection.SessionOptions.ProtocolVersion = 3;
DirectoryContext context = new DirectoryContext(connection);
var orders = context.Query<User>();
switch (searchType)
{
case 1:
orders = orders.Where(u => (u.FirstName.Contains(employeeSearchAdditionalData.Keyword)) || (u.LastName.Contains(employeeSearchAdditionalData.Keyword)));
break;
case 2:
orders = orders.Where(u => (u.CountryCode == employeeSearchAdditionalData.CountryCode1));
break;
case 3:
orders = orders.Where(u => ((u.FirstName.Contains(employeeSearchAdditionalData.Keyword)) || (u.LastName.Contains(employeeSearchAdditionalData.Keyword)))
&& (u.CountryCode == employeeSearchAdditionalData.CountryCode1));
break;
case 4:
if(!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.FirstName))
{
orders = orders.Where(u => (u.FirstName.Contains(employeeSearchAdditionalData.FirstName)));
}
if (!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.LastName))
{
orders = orders.Where(u => (u.LastName.Contains(employeeSearchAdditionalData.LastName)));
}
if (!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.CountryCode2))
{
orders = orders.Where(u => (u.CountryCode == employeeSearchAdditionalData.CountryCode2));
}
if (!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.Location))
{
orders = orders.Where(u => (u.Location == employeeSearchAdditionalData.Location));
}
if (!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.PositionTitle))
{
orders = orders.Where(u => (u.PositionTitle.Contains(employeeSearchAdditionalData.PositionTitle)));
}
if (!String.IsNullOrWhiteSpace(employeeSearchAdditionalData.FunctionalArea))
{
orders = orders.Where(u => (u.FunctionalArea == employeeSearchAdditionalData.FunctionalArea));
}
break;
}
orders = orders.Where(c => (c.Status == "Actif"));
var total = orders.Count();
orders = orders.ApplyOrdersSorting(request.Groups, request.Sorts);
var x = orders.ApplyOrdersPaging(request.Page, request.PageSize, total);
var result = new DataSourceResult()
{
Data = x,
Total = total
};
return Json(result);
}
public void GetForest_InvalidContextType_ThrowsArgumentException(DirectoryContextType contextType)
{
var context = new DirectoryContext(contextType, "Name");
AssertExtensions.Throws <ArgumentException>("context", () => Forest.GetForest(context));
}
// Methods
public static ActiveDirectorySiteLinkBridge FindByName(DirectoryContext context, string bridgeName) {}
public void FindAll_EmptySiteName_ThrowsArgumentException()
{
var context = new DirectoryContext(DirectoryContextType.Domain);
AssertExtensions.Throws <ArgumentException>("siteName", () => DomainController.FindAll(context, string.Empty));
}
public static Forest GetForest(DirectoryContext context) {}
public void FindAll_InvalidName_ThrowsActiveDirectoryOperationException()
{
var context = new DirectoryContext(DirectoryContextType.Domain, "server:port");
Assert.Throws <ActiveDirectoryOperationException>(() => DomainController.FindAll(context, "siteName"));
}
// Constructors
public ReplicationConnection(DirectoryContext context, string name, DirectoryServer sourceServer)
{
}
public void GetDomainController_InvalidContextType_ThrowsArgumentException(DirectoryContextType contextType)
{
var context = new DirectoryContext(contextType, "name");
AssertExtensions.Throws <ArgumentException>("context", () => DomainController.GetDomainController(context));
}
// Methods
public static ReplicationConnection FindByName(DirectoryContext context, string name)
{
}
int DokanOperations.CreateFile(
string path,
FileAccess access,
FileShare share,
FileMode mode,
FileOptions options,
DokanFileInfo info)
{
mLog.DebugFormat(
"CreateFile - mode: {0, 5} - options: {1, 5} - {2}",
mode, options, path);
Node tree = GetRoot();
Node node = WalkTree.Find(tree, path);
if (node == null)
{
int error;
bool bIsDirectory;
int handle = CreateNew.Create(
path,
access,
share,
mode,
options,
tree,
mFileCache,
mHandles,
mPlasticApi,
mLocalFiles,
mHistoryDirectories,
out bIsDirectory,
out error);
if (error != 0)
{
return(error);
}
if (bIsDirectory)
{
DirectoryContext.Set(info);
}
else
{
FileContext.Set(info, handle);
}
return(0);
}
if (mHistoryDirectories.OpenExisting(node))
{
DirectoryContext.Set(info);
return(0);
}
if (node.IsDirectory())
{
DirectoryContext.Set(info);
return(0);
}
IVirtualFile virtualFile;
if ((virtualFile = mVirtualFiles.Get(node.GetNodeId())) != null)
{
int handle = virtualFile.CreateFile(access, share, mode, options);
FileContext.Set(info, handle);
return(0);
}
#warning here me must handle CreateNew which I think should delete the existing file or fail
if (node.IsControlledAndReadOnly())
{
string fileToOpen = mFileCache.GetFile(
node.GetRepSpec(),
node.CloneRevisionInfo(),
path,
mPlasticApi);
if (OpenForRead(access))
{
int handle = mHandles.OpenFile(
fileToOpen,
path,
access, share, mode, options);
if (handle == -1)
{
return(-1);
}
FileContext.Set(info, handle);
return(0);
}
// then we need to check it out and copy the content
// of the file to the writable storage
mLog.DebugFormat("**Doing CHECKOUT**");
string writablePath = mLocalFiles.GetPathForFile(node.GetNodeId());
File.Copy(fileToOpen, writablePath);
Checkout(node, path, mChangesTreeOperations);
}
// return the existing private file
int fhandle = LocalFile.OpenExisting(
node.GetNodeId(),
path,
access,
share,
mode,
options,
mLocalFiles);
if (fhandle == -1)
{
return(-DokanNet.ERROR_FILE_NOT_FOUND);
}
FileContext.Set(info, fhandle);
return(fhandle);
}
// Constructors
public ActiveDirectorySite(DirectoryContext context, string siteName) {}
public QueryHandler(DirectoryContext dbContext)
{
_dbContext = dbContext;
}
public ApplicationPartition(DirectoryContext context, string distinguishedName, string objectClass) {}
public ActiveDirectorySiteLink(DirectoryContext context, string siteLinkName, ActiveDirectoryTransportType transport, ActiveDirectorySchedule schedule) {}
public static ApplicationPartition FindByName(DirectoryContext context, string distinguishedName) {}
public override NT_STATUS GetAttributes(UserContext UserContext, FileContext FileObject, out DirectoryContext data)
{
//FIXME: attributes? what attributes?
//Should be implemented very fast, is called quit often
data = new DirectoryContext();
string FileName = root + FileObject.Name;
DateTime dd = new DateTime(2007, 1, 1);
if (phone.Exists(FileName) && !phone.IsDirectory(FileName))
{
data.Attrib = FileAttributes.Normal;
data.CreationTime = dd;
data.LastAccessTime = dd;
data.LastWriteTime = dd;
data.FileSize = (long)phone.FileSize(FileName); // data.AllocationSize willbe set to the same value
data.Name = FileObject.Name;
data.ShortName = ""; //GetShortName(FileObject.Name);
return(NT_STATUS.OK);
}
if (phone.Exists(FileName) && phone.IsDirectory(FileName))
{
data.Attrib = FileAttributes.Directory;
data.CreationTime = dd;
data.LastAccessTime = dd;
data.LastWriteTime = dd;
data.FileSize = (long)phone.FileSize(FileName);
data.Name = FileObject.Name;
data.ShortName = "";//GetShortName(FileName);
return(NT_STATUS.OK);
}
// Now we know that the object is not there, let's see if the path (=UpperDir) is valid
if (!Directory.Exists(root + Path.GetDirectoryName(FileObject.Name)))
{
return(NT_STATUS.OBJECT_PATH_NOT_FOUND);
}
return(NT_STATUS.OBJECT_NAME_NOT_FOUND);
}
