示例#1
0
 private string GetDatabaseIdentityString(DatabaseId databaseId)
 {
     this.DisposeCheck();
     if (null == databaseId)
     {
         throw new ArgumentNullException("databaseId");
     }
     if (string.IsNullOrEmpty(databaseId.DatabaseName))
     {
         try
         {
             MdbStatus databaseStatus = this.GetDatabaseStatus(databaseId, false);
             if (databaseStatus == null)
             {
                 ExTraceGlobals.MapiSessionTracer.TraceError <DatabaseId>((long)this.GetHashCode(), "Cannot get status for database '{0}'", databaseId);
             }
             else
             {
                 databaseId = new DatabaseId(databaseId.MapiEntryId, databaseStatus.VServerName, databaseStatus.MdbName, databaseId.Guid);
             }
         }
         catch (MapiTransientException ex)
         {
             ExTraceGlobals.MapiSessionTracer.TraceError <DatabaseId, string>((long)this.GetHashCode(), "Getting status for database '{0}' caught an exception: '{1}'", databaseId, ex.Message);
         }
         catch (MapiOperationException ex2)
         {
             ExTraceGlobals.MapiSessionTracer.TraceError <DatabaseId, string>((long)this.GetHashCode(), "Getting status for database '{0}' caught an exception: '{1}'", databaseId, ex2.Message);
         }
     }
     return(databaseId.ToString());
 }
示例#2
0
        protected sealed override void UpdateIdentity(MapiObject.UpdateIdentityFlags flags)
        {
            MapiEntryId mapiEntryId             = this.Identity.MapiEntryId;
            DatabaseId  mailboxDatabaseId       = this.Identity.MailboxDatabaseId;
            Guid        mailboxGuid             = this.Identity.MailboxGuid;
            string      mailboxExchangeLegacyDn = this.Identity.MailboxExchangeLegacyDn;

            this.Identity = new MailboxId(mapiEntryId, mailboxDatabaseId, mailboxGuid, mailboxExchangeLegacyDn);
        }
示例#3
0
 public MdbStatus GetDatabaseStatus(DatabaseId databaseId, bool basicInformation)
 {
     MdbStatus[] databaseStatus = this.GetDatabaseStatus(new DatabaseId[]
     {
         databaseId
     }, basicInformation);
     if (databaseStatus.Length != 0)
     {
         return(databaseStatus[0]);
     }
     return(null);
 }
示例#4
0
        protected sealed override void UpdateIdentity(MapiObject.UpdateIdentityFlags flags)
        {
            bool        flag                    = MapiObject.UpdateIdentityFlags.Nop == (MapiObject.UpdateIdentityFlags.SkipIfExists & flags);
            MapiEntryId mapiEntryId             = this.Identity.MapiEntryId;
            DatabaseId  mailboxDatabaseId       = this.Identity.MailboxDatabaseId;
            Guid        mailboxGuid             = this.Identity.MailboxGuid;
            string      mailboxExchangeLegacyDn = this.Identity.MailboxExchangeLegacyDn;

            if ((MapiObject.UpdateIdentityFlags.LegacyDistinguishedName & flags) != MapiObject.UpdateIdentityFlags.Nop && (string.IsNullOrEmpty(this.Identity.MailboxExchangeLegacyDn) || flag))
            {
                mailboxExchangeLegacyDn = (string)this[LogonStatisticsSchema.FullMailboxDirectoryName];
            }
            this.Identity = new MailboxId(mapiEntryId, mailboxDatabaseId, mailboxGuid, mailboxExchangeLegacyDn);
        }
示例#5
0
        protected override void UpdateIdentity(MapiObject.UpdateIdentityFlags flags)
        {
            bool        flag                    = MapiObject.UpdateIdentityFlags.Nop == (MapiObject.UpdateIdentityFlags.SkipIfExists & flags);
            MapiEntryId entryId                 = this.Identity.MapiEntryId;
            DatabaseId  mailboxDatabaseId       = this.Identity.MailboxDatabaseId;
            Guid?       guid                    = new Guid?(this.Identity.MailboxGuid);
            string      mailboxExchangeLegacyDn = this.Identity.MailboxExchangeLegacyDn;

            if ((MapiObject.UpdateIdentityFlags.EntryIdentity & flags) != MapiObject.UpdateIdentityFlags.Nop && (null == this.Identity.MapiEntryId || flag))
            {
                entryId = (MapiEntryId)this[MapiPropertyDefinitions.EntryId];
            }
            if ((MapiObject.UpdateIdentityFlags.MailboxGuid & flags) != MapiObject.UpdateIdentityFlags.Nop && (Guid.Empty == this.Identity.MailboxGuid || flag))
            {
                guid = (Guid?)this[MapiPropertyDefinitions.MailboxGuid];
            }
            if ((MapiObject.UpdateIdentityFlags.LegacyDistinguishedName & flags) != MapiObject.UpdateIdentityFlags.Nop && (string.IsNullOrEmpty(this.Identity.MailboxExchangeLegacyDn) || flag))
            {
                mailboxExchangeLegacyDn = (string)this[MapiPropertyDefinitions.LegacyDN];
            }
            this.Identity = new MailboxId(entryId, mailboxDatabaseId, guid ?? Guid.Empty, mailboxExchangeLegacyDn);
        }
示例#6
0
        internal override IEnumerable <T> FindPaged <T>(QueryFilter filter, MapiObjectId root, QueryScope scope, SortBy sort, int pageSize, int maximumResultsSize)
        {
            if (!base.GetType().IsAssignableFrom(typeof(T)))
            {
                throw new ArgumentException("T");
            }
            DatabaseId databaseId = root as DatabaseId;

            if (!(null != databaseId))
            {
                throw new NotSupportedException(Strings.ExceptionIdentityTypeInvalid);
            }
            if (MapiObject.RetrievePropertiesScope.Database != this.RetrievePropertiesScopeForFinding && this.RetrievePropertiesScopeForFinding != MapiObject.RetrievePropertiesScope.Instance)
            {
                yield break;
            }
            if (QueryScope.SubTree != scope)
            {
                throw new ArgumentException("scope");
            }
            if (sort != null)
            {
                throw new ArgumentException("sort");
            }
            if (0 > maximumResultsSize)
            {
                throw new ArgumentException("maximumResultsSize");
            }
            if (base.MapiSession == null)
            {
                throw new MapiInvalidOperationException(Strings.ExceptionSessionNull);
            }
            base.EnableDisposeTracking();
            PropTag[] tagsToRead;
            using (LogonStatisticsEntry logonStatisticsEntry = (LogonStatisticsEntry)((object)((default(T) == null) ? Activator.CreateInstance <T>() : default(T))))
            {
                tagsToRead = logonStatisticsEntry.GetPropertyTagsToRead();
            }
            if (tagsToRead == null || tagsToRead.Length == 0)
            {
                tagsToRead = new PropTag[]
                {
                    PropTag.MailboxDN
                };
            }
            MdbFlags[] flagsSetToBeTried = new MdbFlags[]
            {
                MdbFlags.Private | MdbFlags.System | MdbFlags.User,
                MdbFlags.Public | MdbFlags.System | MdbFlags.User
            };
            int count = 0;

            MdbFlags[] array = flagsSetToBeTried;
            for (int i = 0; i < array.Length; i++)
            {
                LogonStatisticsEntry.< > c__DisplayClass5 <T> CS$ < > 8__locals3 = new LogonStatisticsEntry.< > c__DisplayClass5 <T>();
                CS$ < > 8__locals3.flags = array[i];
                PropValue[][] entries = null;
                base.MapiSession.InvokeWithWrappedException(delegate()
                {
                    ExTraceGlobals.LogonStatisticsTracer.TraceDebug <DatabaseId, string, MdbFlags>((long)this.GetHashCode(), "To Find LogonStatistics from in the database '{0}' on server '{1}' with flag '{2}'.", databaseId, this.MapiSession.ServerName, CS$ < > 8__locals3.flags);
                    entries = this.MapiSession.Administration.GetLogonTable(CS$ < > 8__locals3.flags, databaseId.Guid, tagsToRead);
                }, Strings.ExceptionFindObject(typeof(T).Name, (null == root) ? Strings.ConstantNull : root.ToString()), databaseId);
                foreach (PropValue[] entry in entries)
                {
                    LogonStatisticsEntry logonStatisitcs = (LogonStatisticsEntry)((object)((default(T) == null) ? Activator.CreateInstance <T>() : default(T)));
                    try
                    {
                        logonStatisitcs.Instantiate(entry);
                        logonStatisitcs.MapiSession = base.MapiSession;
                        logonStatisitcs.UpdateIdentity(logonStatisitcs.UpdateIdentityFlagsForFinding);
                        logonStatisitcs.OriginatingServer = Fqdn.Parse(logonStatisitcs.MapiSession.ServerName);
                        logonStatisitcs.ResetChangeTrackingAndObjectState();
                    }
                    finally
                    {
                        logonStatisitcs.Dispose();
                    }
                    yield return((T)((object)logonStatisitcs));

                    count++;
                    if (0 < maximumResultsSize && count == maximumResultsSize)
                    {
                        yield break;
                    }
                }
                if (0 < count)
                {
                    break;
                }
            }
            yield break;
        }
示例#7
0
 internal static void ThrowWrappedException(LocalizedException exception, LocalizedString message, MapiObjectId source, MapiSession mapiSession)
 {
     if (exception is MapiExceptionNotFound)
     {
         if (source is PublicFolderId)
         {
             throw new PublicFolderNotFoundException(source.ToString(), exception);
         }
         if (source is MailboxId)
         {
             mapiSession.AnalyzeMailboxNotFoundAndThrow((MailboxId)source, exception);
         }
         throw new MapiObjectNotFoundException(message, exception);
     }
     else if (exception is MapiExceptionLogonFailed)
     {
         if (source is PublicFolderId)
         {
             throw new PublicStoreLogonFailedException(mapiSession.ServerName, exception);
         }
         if (source is MailboxId)
         {
             mapiSession.AnalyzeMailboxLogonFailedAndThrow((MailboxId)source, exception);
         }
         throw new MapiLogonFailedException(Strings.LogonFailedExceptionError(message, mapiSession.ServerName), exception);
     }
     else
     {
         if (exception is MapiExceptionSessionLimit)
         {
             throw new MapiLogonFailedException(Strings.SessionLimitExceptionError, exception);
         }
         if (exception is MapiExceptionUnknownMailbox)
         {
             if (source is MailboxId)
             {
                 mapiSession.AnalyzeMailboxNotFoundAndThrow((MailboxId)source, exception);
             }
             throw new MapiObjectNotFoundException(message, exception);
         }
         if (exception is MapiExceptionMdbOffline)
         {
             if (mapiSession == null)
             {
                 throw new DatabaseUnavailableException(Strings.DatabaseUnavailableExceptionErrorSimple, exception);
             }
             DatabaseId databaseId = null;
             if (source is MailboxId && null != ((MailboxId)source).MailboxDatabaseId)
             {
                 databaseId = ((MailboxId)source).MailboxDatabaseId;
             }
             else if (source is DatabaseId)
             {
                 databaseId = (DatabaseId)source;
             }
             if (null == databaseId)
             {
                 throw new DatabaseUnavailableException(Strings.DatabaseUnavailableExceptionError(mapiSession.ServerName), exception);
             }
             throw new DatabaseUnavailableException(Strings.DatabaseUnavailableByIdentityExceptionError(mapiSession.GetDatabaseIdentityString(databaseId), mapiSession.ServerName), exception);
         }
         else
         {
             if (exception is MapiExceptionPartialCompletion)
             {
                 throw new MapiPartialCompletionException(message, exception);
             }
             if (exception is MapiExceptionNetworkError)
             {
                 if (mapiSession != null)
                 {
                     throw new MapiNetworkErrorException(Strings.MapiNetworkErrorExceptionError(mapiSession.ServerName), exception);
                 }
                 throw new MapiNetworkErrorException(Strings.MapiNetworkErrorExceptionErrorSimple, exception);
             }
             else if (exception is MapiExceptionNoAccess)
             {
                 if (null != source)
                 {
                     throw new MapiAccessDeniedException(Strings.MapiAccessDeniedExceptionError(source.ToString()), exception);
                 }
                 throw new MapiAccessDeniedException(Strings.MapiAccessDeniedExceptionErrorSimple, exception);
             }
             else
             {
                 if (exception is MapiRetryableException)
                 {
                     throw new MapiTransientException(message, exception);
                 }
                 if (exception is MapiPermanentException)
                 {
                     throw new MapiOperationException(message, exception);
                 }
                 if (exception is MapiInvalidOperationException)
                 {
                     throw new MapiOperationException(message, exception);
                 }
                 return;
             }
         }
     }
 }
示例#8
0
 public MdbStatus GetDatabaseStatus(DatabaseId databaseId)
 {
     return(this.GetDatabaseStatus(databaseId, true));
 }
示例#9
0
 internal MailboxId(MapiEntryId entryId, DatabaseId mailboxDatabaseId, Guid mailboxGuid, string mailboxExchangeLegacyDn) : base(entryId)
 {
     this.mailboxDatabaseId       = mailboxDatabaseId;
     this.mailboxGuid             = mailboxGuid;
     this.mailboxExchangeLegacyDn = mailboxExchangeLegacyDn;
 }
示例#10
0
 public MailboxId(DatabaseId mailboxDatabaseId, Guid mailboxGuid)
 {
     this.mailboxDatabaseId = mailboxDatabaseId;
     this.mailboxGuid       = mailboxGuid;
 }