Esempio n. 1
0
        public bool UploadItems(FolderIdType parentFolderId, IEnumerable <ItemInformation> items, bool alwaysCreateNew)
        {
            UploadItemsType  itemsType        = new UploadItemsType();
            CreateActionType createActionType = alwaysCreateNew ? CreateActionType.CreateNew : CreateActionType.UpdateOrCreate;

            itemsType.Items = (from item in items
                               select new UploadItemType
            {
                CreateAction = createActionType,
                ItemId = new ItemIdType
                {
                    Id = item.Id
                },
                Data = item.Data,
                ParentFolderId = parentFolderId
            }).ToArray <UploadItemType>();
            int successCount = 0;

            this.CallEwsWithRetries((LID)0U, () => this.binding.UploadItems(itemsType), delegate(ResponseMessageType responseMessage, int messageIndex)
            {
                UploadItemsResponseMessageType uploadItemsResponseMessageType = responseMessage as UploadItemsResponseMessageType;
                if (uploadItemsResponseMessageType != null && uploadItemsResponseMessageType.ResponseClass == ResponseClassType.Success)
                {
                    successCount++;
                    if (this.IsTraceEnabled(TraceType.DebugTrace))
                    {
                        this.Tracer.TraceDebug(0L, "Items uploaded successfully");
                    }
                }
                return(false);
            }, null);
            return(successCount == itemsType.Items.Length);
        }
Esempio n. 2
0
        // Token: 0x06000581 RID: 1409 RVA: 0x0002AA2C File Offset: 0x00028C2C
        public List <ElcEwsItem> UploadItems(FolderIdType parentFolderId, IList <ElcEwsItem> items, bool alwaysCreateNew)
        {
            UploadItemsType uploadItems = new UploadItemsType();

            uploadItems.Items = (from item in items
                                 select new UploadItemType
            {
                CreateAction = (alwaysCreateNew ? CreateActionType.CreateNew : CreateActionType.UpdateOrCreate),
                ItemId = new ItemIdType
                {
                    Id = item.Id
                },
                Data = item.Data,
                ParentFolderId = parentFolderId
            }).ToArray <UploadItemType>();
            List <ElcEwsItem> returnedItems = new List <ElcEwsItem>(uploadItems.Items.Length);
            int startIndex = 0;

            this.CallService(() => this.ServiceBinding.UploadItems(uploadItems), delegate(ResponseMessageType responseMessage, int messageIndex)
            {
                UploadItemsResponseMessageType uploadItemsResponseMessageType = (UploadItemsResponseMessageType)responseMessage;
                ElcEwsItem elcEwsItem = items[startIndex + messageIndex];
                if (uploadItemsResponseMessageType.ResponseClass == ResponseClassType.Error)
                {
                    ElcEwsClient.Tracer.TraceError <ResponseCodeType>(0L, "ElcEwsClient.UploadItems: UploadItems with error response message. ResponseCode : {0}", uploadItemsResponseMessageType.ResponseCode);
                    if (uploadItemsResponseMessageType.ResponseCode == ResponseCodeType.ErrorQuotaExceeded)
                    {
                        throw new ElcEwsException(ElcEwsErrorType.TargetOutOfSpace, uploadItemsResponseMessageType.ResponseCode.ToString());
                    }
                    returnedItems.Add(new ElcEwsItem
                    {
                        Id              = elcEwsItem.Id,
                        Data            = elcEwsItem.Data,
                        Error           = new ElcEwsException(ElcEwsErrorType.FailedToUploadItem, uploadItemsResponseMessageType.ResponseCode.ToString()),
                        StorageItemData = elcEwsItem.StorageItemData
                    });
                }
                else if (uploadItemsResponseMessageType.ResponseClass == ResponseClassType.Warning)
                {
                    ElcEwsClient.Tracer.TraceWarning <ResponseCodeType, string>(0L, "ElcEwsClient.UploadItems: Message response warning. ResponseCode:{0}; MessageText:'{1}'", uploadItemsResponseMessageType.ResponseCode, uploadItemsResponseMessageType.MessageText);
                    if (uploadItemsResponseMessageType.ResponseCode == ResponseCodeType.ErrorBatchProcessingStopped)
                    {
                        ElcEwsClient.Tracer.TraceWarning <int, int>(0L, "ElcEwsClient.UploadItems: Hitting ErrorBatchProcessingStopped, startIndex:{0}; messageIndex={1}", startIndex, messageIndex);
                        if (messageIndex == 0)
                        {
                            throw new RetryException(new ElcEwsException(ElcEwsErrorType.FailedToUploadItem, "Internal Error: Hitting ErrorBatchProcessingStopped as the first response."), false);
                        }
                        startIndex       += messageIndex;
                        uploadItems.Items = uploadItems.Items.Skip(messageIndex).ToArray <UploadItemType>();
                        throw new RetryException(new ElcEwsException(ElcEwsErrorType.FailedToUploadItem, "Hitting ErrorBatchProcessingStopped"), true);
                    }
                    else
                    {
                        returnedItems.Add(new ElcEwsItem
                        {
                            Id              = elcEwsItem.Id,
                            Data            = null,
                            Error           = new ElcEwsException(ElcEwsErrorType.FailedToUploadItem, uploadItemsResponseMessageType.ResponseCode.ToString()),
                            StorageItemData = elcEwsItem.StorageItemData
                        });
                    }
                }
                else
                {
                    returnedItems.Add(new ElcEwsItem
                    {
                        Id              = uploadItemsResponseMessageType.ItemId.Id,
                        Data            = elcEwsItem.Data,
                        Error           = null,
                        StorageItemData = elcEwsItem.StorageItemData
                    });
                }
                return(true);
            }, (Exception exception) => ElcEwsClient.WrapElcEwsException(ElcEwsErrorType.FailedToUploadItem, exception));
            return(returnedItems);
        }