示例#1
0
        // Token: 0x060019E8 RID: 6632 RVA: 0x0005D538 File Offset: 0x0005B738
        protected override GetAttachmentDataProviderItemsResponse InternalExecute()
        {
            UserContext            userContext = UserContextManager.GetUserContext(base.CallContext.HttpContext, base.CallContext.EffectiveCaller, true);
            AttachmentDataProvider provider    = userContext.AttachmentDataProviderManager.GetProvider(base.CallContext, this.request.AttachmentDataProviderId);

            return(provider.GetItems(this.request.Paging, this.request.Scope, base.MailboxIdentityMailboxSession));
        }
示例#2
0
 public AttachmentDataProvider AddProvider(CallContext callContext, AttachmentDataProvider attachmentDataProvider)
 {
     this.EnsureAttachmentDataProviders(callContext);
     attachmentDataProvider.Id = Guid.NewGuid().ToString();
     this.AddProviderInternal(callContext, new PolymorphicConfiguration <AttachmentDataProvider>(), attachmentDataProvider);
     return(attachmentDataProvider);
 }
        // Token: 0x060019CC RID: 6604 RVA: 0x0005C200 File Offset: 0x0005A400
        protected override CreateAttachmentResponse InternalExecute()
        {
            UserContext             userContext             = UserContextManager.GetUserContext(base.CallContext.HttpContext, base.CallContext.EffectiveCaller, true);
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken       token = cancellationTokenSource.Token;

            if (this.cancellationId != null && userContext.CancelAttachmentManager.OnCreateAttachment(this.cancellationId, cancellationTokenSource))
            {
                return(null);
            }
            CreateAttachmentResponse createAttachmentResponse = null;

            try
            {
                AttachmentDataProvider provider = userContext.AttachmentDataProviderManager.GetProvider(base.CallContext, this.attachmentDataProviderId);
                createAttachmentResponse = CreateReferenceAttachmentFromAttachmentDataProvider.AttachReferenceAttachment(provider, userContext, this.location, this.dataProviderItemId, this.itemId.Id, base.IdConverter, this.dataProviderParentItemId, this.providerEndpointUrl);
            }
            finally
            {
                if (this.cancellationId != null)
                {
                    AttachmentIdType attachmentIdFromCreateAttachmentResponse = CreateAttachmentHelper.GetAttachmentIdFromCreateAttachmentResponse(createAttachmentResponse);
                    if (attachmentIdFromCreateAttachmentResponse != null)
                    {
                        userContext.CancelAttachmentManager.CreateAttachmentCompleted(this.cancellationId, attachmentIdFromCreateAttachmentResponse);
                    }
                    else
                    {
                        userContext.CancelAttachmentManager.CreateAttachmentCancelled(this.cancellationId);
                    }
                }
            }
            return(createAttachmentResponse);
        }
        // Token: 0x060019EE RID: 6638 RVA: 0x0005D5FC File Offset: 0x0005B7FC
        protected override string InternalExecute()
        {
            UserContext            userContext = UserContextManager.GetUserContext(base.CallContext.HttpContext, base.CallContext.EffectiveCaller, true);
            AttachmentDataProvider defaultUploadDataProvider = userContext.AttachmentDataProviderManager.GetDefaultUploadDataProvider(base.CallContext);

            if (defaultUploadDataProvider is OneDriveProAttachmentDataProvider)
            {
                return(((OneDriveProAttachmentDataProvider)defaultUploadDataProvider).GetUploadFolderName(userContext));
            }
            return(null);
        }
        // Token: 0x060019CD RID: 6605 RVA: 0x0005C2F0 File Offset: 0x0005A4F0
        internal static CreateAttachmentResponse AttachReferenceAttachment(AttachmentDataProvider attachmentDataProvider, UserContext userContext, string location, string dataProviderItemId, string parentItemId, IdConverter idConverter, string dataProviderParentItemId = null, string providerEndpointUrl = null)
        {
            CreateAttachmentResponse result = null;

            if (!userContext.IsDisposed)
            {
                if (string.IsNullOrEmpty(providerEndpointUrl))
                {
                    providerEndpointUrl = attachmentDataProvider.GetEndpointUrlFromItemLocation(location);
                }
                string linkingUrl = attachmentDataProvider.GetLinkingUrl(userContext, location, providerEndpointUrl, dataProviderItemId, dataProviderParentItemId);
                string text       = Path.GetFileName(HttpUtility.UrlDecode(linkingUrl));
                if (OneDriveProUtilities.IsDurableUrlFormat(text))
                {
                    text = text.Substring(0, text.LastIndexOf("?", StringComparison.InvariantCulture));
                }
                try
                {
                    userContext.LockAndReconnectMailboxSession();
                    IdAndSession            idAndSession            = new IdAndSession(StoreId.EwsIdToStoreObjectId(parentItemId), userContext.MailboxSession);
                    ReferenceAttachmentType referenceAttachmentType = new ReferenceAttachmentType
                    {
                        Name = text,
                        AttachLongPathName  = linkingUrl,
                        ProviderEndpointUrl = providerEndpointUrl,
                        ProviderType        = attachmentDataProvider.Type.ToString()
                    };
                    if (!userContext.IsGroupUserContext)
                    {
                        referenceAttachmentType.ContentId   = Guid.NewGuid().ToString();
                        referenceAttachmentType.ContentType = "image/png";
                    }
                    AttachmentHierarchy attachmentHierarchy = new AttachmentHierarchy(idAndSession, true, true);
                    using (AttachmentBuilder attachmentBuilder = new AttachmentBuilder(attachmentHierarchy, new AttachmentType[]
                    {
                        referenceAttachmentType
                    }, idConverter, true))
                    {
                        ServiceError serviceError;
                        Attachment   attachment = attachmentBuilder.CreateAttachment(referenceAttachmentType, out serviceError);
                        if (serviceError == null)
                        {
                            attachmentHierarchy.SaveAll();
                        }
                        result = CreateAttachmentHelper.CreateAttachmentResponse(attachmentHierarchy, attachment, referenceAttachmentType, idAndSession, serviceError);
                    }
                }
                finally
                {
                    userContext.UnlockAndDisconnectMailboxSession();
                }
            }
            return(result);
        }
示例#6
0
        internal static void DownloadAndAttachFile(Guid operationId, AttachmentDataProvider attachmentDataProvider, UserContext userContext, string location, string dataProviderItemId, string parentItemId, string subscriptionId, IdConverter idConverter, string channelId, string dataProviderParentItemId, string providerEndpointUrl, CancellationToken cancellationToken, string cancellationId)
        {
            AttachmentResultCode errorCode    = AttachmentResultCode.GenericFailure;
            Exception            exception    = null;
            AttachmentIdType     attachmentId = null;

            try
            {
                OwaDiagnostics.SendWatsonReportsForGrayExceptions(async delegate()
                {
                    try
                    {
                        DownloadItemAsyncResult downloadItemResult = await attachmentDataProvider.DownloadItemAsync(location, dataProviderItemId, dataProviderParentItemId, providerEndpointUrl, cancellationToken).ConfigureAwait(false);
                        CreateAttachmentNotificationPayload result = new CreateAttachmentNotificationPayload
                        {
                            SubscriptionId = subscriptionId,
                            Id             = operationId.ToString(),
                            Bytes          = downloadItemResult.Bytes,
                            Item           = downloadItemResult.Item,
                            ResultCode     = downloadItemResult.ResultCode
                        };
                        attachmentId = CreateAttachmentHelper.CreateAttachmentAndSendPendingGetNotification(userContext, parentItemId, result.Bytes, result.Item.Name, result, idConverter, channelId);
                    }
                    catch (OperationCanceledException exception)
                    {
                        errorCode = AttachmentResultCode.Cancelled;
                        exception = exception;
                        if (cancellationId != null)
                        {
                            userContext.CancelAttachmentManager.CreateAttachmentCancelled(cancellationId);
                        }
                    }
                });
            }
            catch (GrayException ex)
            {
                ExTraceGlobals.AttachmentHandlingTracer.TraceError <string>(0L, "CreateAttachmentFromAttachmentDataProvider.DownloadAndAttachFile Exception while trying to download and attach file async : {0}", ex.StackTrace);
                exception = ex;
            }
            finally
            {
                if (cancellationId != null)
                {
                    userContext.CancelAttachmentManager.CreateAttachmentCompleted(cancellationId, attachmentId);
                }
                if (exception != null)
                {
                    CreateAttachmentHelper.SendFailureNotification(userContext, subscriptionId, operationId.ToString(), errorCode, channelId, exception);
                }
            }
        }
 // Token: 0x06001AF7 RID: 6903 RVA: 0x000663EC File Offset: 0x000645EC
 public Implementation(AttachmentDataProvider provider, IXSOFactory factory, IStoreSession attachmentSession, ModernGroupObjectType attachmentSessionModernGroupType, IItem rootItem, IAttachment attachment, string attachmentId, IMailboxSession draftAttachmentSession, StoreObjectId draftObjectId, bool isEdit, string userDisplayName, Func <IStoreSession, StoreId, AttachmentId, string> idConverter)
 {
     this.provider = provider;
     this.factory  = factory;
     this.originalAttachmentSession      = attachmentSession;
     this.originalSessionModernGroupType = attachmentSessionModernGroupType;
     this.originalAttachmentRootItem     = rootItem;
     this.originalAttachment             = attachment;
     this.originalAttachmentId           = attachmentId;
     this.draftAttachmentSession         = draftAttachmentSession;
     this.draftObjectId   = draftObjectId;
     this.isEdit          = isEdit;
     this.userDisplayName = userDisplayName;
     this.idConverter     = idConverter;
 }
示例#8
0
        protected override string InternalExecute()
        {
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken       token       = cancellationTokenSource.Token;
            UserContext             userContext = UserContextManager.GetUserContext(base.CallContext.HttpContext, base.CallContext.EffectiveCaller, true);

            if (this.cancellationId != null && userContext.CancelAttachmentManager.OnCreateAttachment(this.cancellationId, cancellationTokenSource))
            {
                return(null);
            }
            AttachmentDataProvider provider = userContext.AttachmentDataProviderManager.GetProvider(base.CallContext, this.attachmentDataProviderId);
            Guid operationId = Guid.NewGuid();

            CreateAttachmentFromAttachmentDataProvider.DownloadAndAttachFile(operationId, provider, userContext, this.location, this.dataProviderItemId, this.draftEmailId.Id, this.subscriptionId, base.IdConverter, this.channelId, this.dataProviderParentItemId, this.providerEndpointUrl, token, this.cancellationId);
            return(operationId.ToString());
        }
示例#9
0
 private void ProviderChanged(AttachmentDataProvider provider, AttachmentDataProviderChangedEventArgs args)
 {
     if (this.dataProviders.ContainsKey(provider.Id))
     {
         lock (this.lockObject)
         {
             if (this.dataProviders.ContainsKey(provider.Id))
             {
                 PolymorphicConfiguration <AttachmentDataProvider> polymorphicConfiguration = new PolymorphicConfiguration <AttachmentDataProvider>();
                 foreach (AttachmentDataProvider item in this.dataProviders.Values)
                 {
                     polymorphicConfiguration.Entries.Add(item);
                     polymorphicConfiguration.Save(args.MailboxSession);
                 }
             }
         }
     }
 }
示例#10
0
        public GetAttachmentDataProviderItemsResponse GetGroups(CallContext callContext, MailboxSession mailboxSession)
        {
            AttachmentDataProvider attachmentDataProvider = this.GetDefaultUploadDataProvider(callContext);
            GetAttachmentDataProviderItemsResponse getAttachmentDataProviderItemsResponse;

            if (attachmentDataProvider is OneDriveProAttachmentDataProvider)
            {
                OneDriveProAttachmentDataProvider oneDriveProAttachmentDataProvider = (OneDriveProAttachmentDataProvider)attachmentDataProvider;
                getAttachmentDataProviderItemsResponse = oneDriveProAttachmentDataProvider.GetGroups(mailboxSession);
            }
            else
            {
                getAttachmentDataProviderItemsResponse                = new GetAttachmentDataProviderItemsResponse();
                getAttachmentDataProviderItemsResponse.Items          = new AttachmentDataProviderItem[0];
                getAttachmentDataProviderItemsResponse.TotalItemCount = 0;
                getAttachmentDataProviderItemsResponse.ResultCode     = AttachmentResultCode.GenericFailure;
            }
            return(getAttachmentDataProviderItemsResponse);
        }
示例#11
0
 private void AddProviderInternal(CallContext callContext, PolymorphicConfiguration <AttachmentDataProvider> attachmentDataProvidersConfig, AttachmentDataProvider provider)
 {
     lock (this.lockObject)
     {
         this.dataProviders[provider.Id] = provider;
         if (attachmentDataProvidersConfig != null)
         {
             attachmentDataProvidersConfig.Entries.Add(provider);
             attachmentDataProvidersConfig.Save(callContext);
         }
     }
 }
        // Token: 0x06001AD5 RID: 6869 RVA: 0x00065E80 File Offset: 0x00064080
        private static WacAttachmentType GetResultForReferenceAttachment(CallContext callContext, UserContext userContext, GetWacAttachmentInfo.Implementation implementation, AttachmentDataProvider provider, string mailboxAddress, BaseItemId referenceItemId, string fileName, bool isEdit, string userDisplayName, string sessionId, RequestDetailsLogger logger)
        {
            GetWacAttachmentInfo.LogReferenceAttachmentProperties(logger, implementation.ResultAttachmentWebServiceUrl, GetWacAttachmentInfoMetadata.ResultReferenceAttachmentServiceUrl, implementation.ResultAttachmentContentUrl, GetWacAttachmentInfoMetadata.ResultReferenceAttachmentUrl);
            AttachmentIdType  ewsAttachmentIdType = GetWacAttachmentInfo.GetEwsAttachmentIdType(callContext, implementation.ResultItemId, implementation.ResultAttachmentId);
            WacAttachmentType result = GetWacAttachmentInfo.CreateWacAttachmentType(userContext.LogonIdentity, ewsAttachmentIdType, implementation.ResultAttachmentWebServiceUrl, implementation.ResultAttachmentContentUrl, isEdit, implementation.ResultIsInDraft);

            if (implementation.ResultAttachmentCreation == WacAttachmentCreationType.Upload)
            {
                try
                {
                    GetWacAttachmentInfo.PostUploadMessage(mailboxAddress, userContext.LogonIdentity.PrimarySmtpAddress.ToString(), userDisplayName, referenceItemId, fileName, implementation.ResultAttachmentContentUrl, implementation.ResultAttachmentProviderType, implementation.ResultAttachmentWebServiceUrl, sessionId);
                }
                catch (Exception value)
                {
                    logger.Set(GetWacAttachmentInfoMetadata.HandledException, value);
                }
            }
            return(result);
        }
示例#13
0
        internal static void UploadAndAttachReferenceAttachment(Guid operationId, UserContext userContext, CallContext callContext, ItemId itemId, string fileName, byte[] fileContent, IdConverter idConverter, string subscriptionId, string channelId, CancellationToken cancellationToken, string cancellationId)
        {
            AttachmentResultCode errorCode    = AttachmentResultCode.GenericFailure;
            AttachmentIdType     attachmentId = null;
            Exception            exception    = null;

            try
            {
                OwaDiagnostics.SendWatsonReportsForGrayExceptions(async delegate()
                {
                    try
                    {
                        AttachmentDataProvider attachmentDataProvider = userContext.AttachmentDataProviderManager.GetDefaultUploadDataProvider(callContext);
                        if (attachmentDataProvider == null)
                        {
                            throw new InvalidOperationException("The user has no default data provider");
                        }
                        UploadItemAsyncResult uploadResult = await attachmentDataProvider.UploadItemAsync(fileContent, fileName, cancellationToken, callContext).ConfigureAwait(false);
                        CreateAttachmentNotificationPayload notificationPayload = new CreateAttachmentNotificationPayload
                        {
                            SubscriptionId = subscriptionId,
                            Id             = operationId.ToString(),
                            Item           = uploadResult.Item,
                            ResultCode     = uploadResult.ResultCode
                        };
                        if (uploadResult.ResultCode == AttachmentResultCode.Success)
                        {
                            notificationPayload.Response = CreateReferenceAttachmentFromAttachmentDataProvider.AttachReferenceAttachment(attachmentDataProvider, userContext, uploadResult.Item.Location, string.Empty, itemId.Id, idConverter, null, uploadResult.Item.ProviderEndpointUrl);
                            attachmentId = CreateAttachmentHelper.GetAttachmentIdFromCreateAttachmentResponse(notificationPayload.Response);
                        }
                        if (!userContext.IsDisposed)
                        {
                            try
                            {
                                userContext.LockAndReconnectMailboxSession();
                                CreateAttachmentHelper.SendPendingGetNotification(userContext, notificationPayload, channelId);
                            }
                            finally
                            {
                                userContext.UnlockAndDisconnectMailboxSession();
                            }
                        }
                    }
                    catch (OperationCanceledException exception)
                    {
                        errorCode = AttachmentResultCode.Cancelled;
                        exception = exception;
                        if (cancellationId != null)
                        {
                            userContext.CancelAttachmentManager.CreateAttachmentCancelled(cancellationId);
                        }
                    }
                });
            }
            catch (GrayException ex)
            {
                ExTraceGlobals.AttachmentHandlingTracer.TraceError <string>(0L, "CreateReferenceAttachmentFromLocalFile.UploadAndAttachReferenceAttachment Exception while trying to upload and attach file async : {0}", ex.StackTrace);
                exception = ex;
            }
            finally
            {
                if (cancellationId != null)
                {
                    userContext.CancelAttachmentManager.CreateAttachmentCompleted(cancellationId, attachmentId);
                }
                if (exception != null)
                {
                    CreateAttachmentHelper.SendFailureNotification(userContext, subscriptionId, operationId.ToString(), errorCode, channelId, exception);
                }
            }
        }