public async Task <CoapMessage> PutAsync(CoapMessage message)
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
//EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated
//if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted))
if (EventValidator.Validate(false, uri.Resource, channel, graphManager).Validated)
{
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (coapObserved.ContainsKey(uri.Resource) || coapUnobserved.Contains(uri.Resource))
{
//resource previously subscribed
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.NotAcceptable, message.Token));
}
//this point the resource is not being observed, so we can
// #1 subscribe to it
// #2 add to unobserved resources (means not coap observed)
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
coapUnobserved.Add(uri.Resource);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
/// <summary>
/// Initializes a new instance of the ResponseMessage by using the
/// specified response text and type.
/// </summary>
/// <param name="response">The text associated with the response.</param>
/// <param name="type">The type of the response.</param>
/// <exception cref="ArgumentNullException"><paramref name="response"/>
/// is null.</exception>
public ResponseMessage(string response, ResponseMessageType type) {
if (response == null)
throw new ArgumentNullException("response");
type_ = type;
response_ = response;
}
/// <summary>
/// Verify whether the response is a valid response message and extract the ResponseClass and ResponseCode.
/// </summary>
/// <param name="baseResponseMessage">The response message.</param>
private void VerifyResponseMessage(BaseResponseMessageType baseResponseMessage)
{
this.InitializeCollections();
Site.Assert.IsNotNull(baseResponseMessage, @"The response should not be null.");
Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages, @"The ResponseMessages in response should not be null.");
Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages.Items, @"The items of ResponseMessages in response should not be null.");
Site.Assert.IsTrue(baseResponseMessage.ResponseMessages.Items.Length > 0, @"The items of ResponseMessages in response should not be null.");
int messageCount = baseResponseMessage.ResponseMessages.Items.Length;
for (int i = 0; i < messageCount; i++)
{
ResponseMessageType responseMessage = baseResponseMessage.ResponseMessages.Items[i];
this.ResponseClass.Add(responseMessage.ResponseClass);
if (responseMessage.ResponseCodeSpecified)
{
this.responseCode.Add(responseMessage.ResponseCode);
}
if (responseMessage.ResponseClass == ResponseClassType.Success && !(baseResponseMessage is DeleteItemResponseType))
{
ItemInfoResponseMessageType itemInfo = responseMessage as ItemInfoResponseMessageType;
Site.Assert.IsNotNull(itemInfo.Items, @"The items of ResponseMessages in response should not be null.");
Site.Assert.IsNotNull(itemInfo.Items.Items, @"The task items in response should not be null.");
Site.Assert.IsTrue(itemInfo.Items.Items.Length > 0, @"There is one task item at least in response.");
foreach (ItemType item in itemInfo.Items.Items)
{
Site.Assert.IsNotNull(item.ItemId, @"The task item id in response should not be null.");
}
}
}
}
private void ProcessResponse(UpdateGroupMailboxResponseType response)
{
using (new StopwatchPerformanceTracker("UpdateGroupMailboxViaEWS.ProcessResponse", GenericCmdletInfoDataLogger.Instance))
{
if (response == null || response.ResponseMessages == null || response.ResponseMessages.Items == null || response.ResponseMessages.Items.Length == 0)
{
UpdateGroupMailboxViaEWS.Tracer.TraceError((long)this.GetHashCode(), "Empty Response");
base.Error = "Empty Response";
}
else
{
ResponseMessageType responseMessageType = response.ResponseMessages.Items[0];
if (responseMessageType.ResponseClass == ResponseClassType.Success)
{
UpdateGroupMailboxViaEWS.Tracer.TraceDebug <string, string>((long)this.GetHashCode(), "UpdateGroupMailbox succeeded. Group={0}, MessageText={1}", this.group.ExternalDirectoryObjectId, responseMessageType.MessageText);
}
else
{
UpdateGroupMailboxViaEWS.Tracer.TraceError <ResponseClassType, ResponseCodeType, string>((long)this.GetHashCode(), "UpdateGroupMailbox failed. ResponseClass={0}, ResponseCode={1}, MessageText={2}", responseMessageType.ResponseClass, responseMessageType.ResponseCode, responseMessageType.MessageText);
base.Error = responseMessageType.MessageText;
base.ResponseCode = new ResponseCodeType?(responseMessageType.ResponseCode);
}
}
}
}
public async Task <CoapMessage> DeleteAsync(CoapMessage message)
{
Exception error = null;
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
try
{
await adapter.UnsubscribeAsync(uri.Resource);
coapObserved.Remove(uri.Resource);
}
catch (Exception ex)
{
Trace.TraceError("{0} - CoAP Delete fault '{1}' ", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), ex.Message);
error = ex;
}
if (error == null)
{
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Deleted, message.Token));
}
else
{
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
}
public Response AddMessage(string key, string message, ResponseMessageType type)
{
Messages.Add(new ResponseMessage {
Key = key, Message = message, MessageType = type
});
return(this);
}
private UserConfigurationType HandleGetUserConfigurationResponse(BaseResponseMessageType response, out bool itemNotFound)
{
itemNotFound = false;
ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response);
if (responseMessageType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration returned NULL responseType.");
return(null);
}
if (responseMessageType.ResponseCode == ResponseCodeType.ErrorItemNotFound)
{
itemNotFound = true;
return(null);
}
if (responseMessageType.ResponseCode != ResponseCodeType.NoError)
{
Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode);
return(null);
}
GetUserConfigurationResponseMessageType getUserConfigurationResponseMessageType = responseMessageType as GetUserConfigurationResponseMessageType;
if (getUserConfigurationResponseMessageType == null || getUserConfigurationResponseMessageType.UserConfiguration == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration web request returned NULL UserConfiguration.");
return(null);
}
return(getUserConfigurationResponseMessageType.UserConfiguration);
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
await logger?.LogWarningAsync($"CoAP observe received without Observe flag and will return RST for {session.Identity}");
await logger?.LogDebugAsync($"Returning RST because GET needs to be observe/unobserve for {session.Identity}");
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
ValidatorResult result = EventValidator.Validate(false, uri.Resource, channel, graphManager);
if (!result.Validated)
{
await logger?.LogErrorAsync($"{result.ErrorMessage} for {session.Identity}");
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
await logger?.LogInformationAsync($"CoAP unobserve '{message.ResourceUri.ToString()}' for {session.Identity}.");
await adapter.UnsubscribeAsync(uri.Resource);
await logger?.LogDebugAsync($"CoAP unsubscribed '{message.ResourceUri.ToString()} for {session.Identity}'.");
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
await logger?.LogInformationAsync($"CoAP subscribed '{message.ResourceUri.ToString()}' for {session.Identity}");
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
await logger?.LogDebugAsync("Key added to observable resource.");
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
/// <summary>
/// Initializes a new instance of the ResponseMessage by using the
/// specified response text and type.
/// </summary>
/// <param name="response">The text associated with the response.</param>
/// <param name="type">The type of the response.</param>
/// <exception cref="ArgumentNullException"><paramref name="response"/>
/// is null.</exception>
public ResponseMessage(string response, ResponseMessageType type)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
type_ = type;
response_ = response;
}
/// <summary>
/// 根据请求消息类型得到一个对应的格式化器。
/// </summary>
/// <param name="responseMessageType">响应消息类型。</param>
/// <returns>一个可用消息格式化器。</returns>
/// <exception cref="NotSupportedException">响应消息的类型不被支持。</exception>
public IMessageFormatter GetFormatter(ResponseMessageType responseMessageType)
{
var formatter = ResponseMessageFormatterDictionary[responseMessageType];
if (formatter == null)
{
throw new NotSupportedException(string.Format("不支持的响应消息类型：{0}。", responseMessageType));
}
return(formatter);
}
private ItemType[] HandleGetItemResponse(BaseResponseMessageType response)
{
ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response);
ItemInfoResponseMessageType itemInfoResponseMessageType = responseMessageType as ItemInfoResponseMessageType;
if (itemInfoResponseMessageType == null || itemInfoResponseMessageType.Items == null || itemInfoResponseMessageType.Items.Items == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem web request returned NULL ItemType.");
return(null);
}
return(itemInfoResponseMessageType.Items.Items);
}
public static ResponseMessage ResponseMessage(this Enum enumCode,
ResponseMessageType type = ResponseMessageType.Validation,
string entityName = "",
string propertyName = "", params object[] args)
{
return(new ResponseMessage
{
Code = enumCode.ToString(),
Message = enumCode.GetDescription().Replace("{EntityName}", entityName.SplitCamelCase()).Replace("{PropertyName}", propertyName.SplitCamelCase()),
Args = args ?? new object[0]
});
}
public async Task <CoapMessage> PostAsync(CoapMessage message)
{
try
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
EventMetadata metadata = await GraphManager.GetPiSystemMetadataAsync(uri.Resource);
if (!await adapter.CanPublishAsync(metadata, channel.IsEncrypted))
{
if (metadata.Audit)
{
await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements"));
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream";
EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit);
if (!string.IsNullOrEmpty(uri.CacheKey))
{
msg.CacheKey = uri.CacheKey;
}
if (uri.Indexes == null)
{
await adapter.PublishAsync(msg);
}
else
{
List <KeyValuePair <string, string> > indexes = new List <KeyValuePair <string, string> >(uri.Indexes);
Task task = Retry.ExecuteAsync(async() =>
{
await adapter.PublishAsync(msg, indexes);
});
task.LogExceptions();
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
catch (Exception ex)
{
Trace.TraceError("{0} - CoAP publish error on channel '{1}'", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
throw ex;
}
}
public Task <CoapMessage> PostAsync(CoapMessage message)
{
TaskCompletionSource <CoapMessage> tcs = new TaskCompletionSource <CoapMessage>();
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
registry.GetAction("POST", uri.Resource)?.Invoke(MediaTypeConverter.ConvertFromMediaType(message.ContentType), message.Payload);
CoapMessage response = new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token);
tcs.SetResult(response);
return(tcs.Task);
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
Trace.TraceWarning("{0} - CoAP observe received without Observe flag set on channel '{1}', returning RST", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted))
{
//not authorized
Trace.TraceWarning("{0} - CoAP observe not authorized on channel '{1}'", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
Trace.TraceWarning("{0} - CoAP observe with value on channel '{1}', unsubscribing.", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
await adapter.UnsubscribeAsync(uri.Resource);
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
public async Task <CoapMessage> PostAsync(CoapMessage message)
{
try
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
EventMetadata metadata = await graphManager.GetPiSystemMetadataAsync(uri.Resource);
ValidatorResult result = EventValidator.Validate(true, metadata, null, graphManager);
if (!result.Validated)
{
if (metadata.Audit)
{
await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements")).LogExceptions(logger);
}
logger?.LogErrorAsync(result.ErrorMessage);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream";
EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit);
if (!string.IsNullOrEmpty(uri.CacheKey))
{
msg.CacheKey = uri.CacheKey;
}
if (uri.Indexes == null)
{
await adapter.PublishAsync(msg);
}
else
{
List <KeyValuePair <string, string> > indexes = GetIndexes(uri);
await adapter.PublishAsync(msg, indexes);
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"CoAP POST fault for {session.Identity}.");
throw ex;
}
}
private bool MakeResponseMessage(ResponseMessageType oResponseMessageType)
{
bool bRet = false;
MessageBody oMessageBody = new MessageBody("----\r\n");
ResponseMessage oResponseMessage = null;
string sWindowTitle = string.Empty;
try
{
if (oResponseMessageType == ResponseMessageType.Reply)
{
_EmailMessage.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
oResponseMessage = _EmailMessage.CreateReply(false);
sWindowTitle = "Reply Message";
}
if (oResponseMessageType == ResponseMessageType.ReplyAll)
{
_EmailMessage.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
oResponseMessage = _EmailMessage.CreateReply(true);
sWindowTitle = "Reply All Message";
}
if (oResponseMessageType == ResponseMessageType.Forward)
{
_EmailMessage.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
oResponseMessage = _EmailMessage.CreateForward();
sWindowTitle = "Forward Message";
}
//oResponseMessage.BodyPrefix = "===========\r\n";
// Save as drafts AND set as new current message.
_EmailMessage.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
_EmailMessage = oResponseMessage.Save(WellKnownFolderName.Drafts);
_EmailMessage.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
_EmailMessage.Load();
SetFormFromMessage(_EmailMessage, true, true, false);
bRet = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error creating message");
bRet = false;
}
return(bRet);
}
private ResponseMessageType HandleBaseResponseMessage(BaseResponseMessageType response)
{
if (response.ResponseMessages == null || response.ResponseMessages.Items == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessages.");
return(null);
}
ResponseMessageType responseMessageType = response.ResponseMessages.Items[0];
if (responseMessageType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessageType.");
return(null);
}
return(responseMessageType);
}
private T ExecuteWebMethodSingleResponse<T>(Func<BaseResponseMessageType> webMethodDelegate) where T : ResponseMessageType
{
ResponseMessageType[] array = this.ExecuteWebMethod(webMethodDelegate);
if (array.Length != 1)
{
ExchangeService.Tracer.TraceError<ExchangeService, string, int>((long)this.GetHashCode(), "{0}: Request for {1} did return unexpected number of items when only one was expected: {2}.", this, webMethodDelegate.Method.Name, array.Length);
throw new UnexpectedRemoteDataException(array);
}
ResponseMessageType responseMessageType = array[0];
if (responseMessageType == null)
{
ExchangeService.Tracer.TraceError<ExchangeService, string>((long)this.GetHashCode(), "{0}: Request for {1} did return not return item.", this, webMethodDelegate.Method.Name);
throw new UnexpectedRemoteDataException(new ResponseMessageType[]
{
responseMessageType
});
}
if (responseMessageType.ResponseClass == ResponseClassType.Error || responseMessageType.ResponseCode == ResponseCodeType.ErrorCrossSiteRequest)
{
ExchangeService.Tracer.TraceError<ExchangeService, string>((long)this.GetHashCode(), "{0}: Request for {1} failed because wrong CAS server.", this, webMethodDelegate.Method.Name);
throw new FailedCommunicationException();
}
if (responseMessageType.ResponseClass != ResponseClassType.Success || responseMessageType.ResponseCode != ResponseCodeType.NoError)
{
ExchangeService.Tracer.TraceError((long)this.GetHashCode(), "{0}: Request for {1} failed. ResponseClass={2}, ResponseCode={3}.", new object[]
{
this,
webMethodDelegate.Method.Name,
responseMessageType.ResponseClass,
responseMessageType.ResponseCode
});
throw new UnexpectedRemoteDataException(new ResponseMessageType[]
{
responseMessageType
});
}
T t = responseMessageType as T;
if (t == null)
{
ExchangeService.Tracer.TraceError<ExchangeService, T, Type>((long)this.GetHashCode(), "{0}: response item {1} is not of expected type: {2}", this, t, typeof(T));
throw new UnexpectedRemoteDataException(new ResponseMessageType[]
{
responseMessageType
});
}
return t;
}
public override void Decode(byte[] message)
{
int index = 0;
byte header = message[index++];
if (header >> 0x06 != 1)
{
throw new CoapVersionMismatchException("Coap Version 1 is only supported version for Coap response.");
}
ResponseType = (ResponseMessageType)Convert.ToInt32((header >> 0x04) & 0x03);
TokenLength = Convert.ToByte(header & 0x0F);
byte code = message[index++];
ResponseCode = (ResponseCodeType)((code >> 0x05) * 100 + (code & 0x1F));
MessageId = (ushort)((message[index++] << 0x08) | message[index++]);
byte[] tokenBytes = new byte[TokenLength];
Buffer.BlockCopy(message, index, tokenBytes, 0, TokenLength);
Token = tokenBytes;
index += TokenLength;
int previous = 0;
bool marker = (message[index] & 0xFF) == 0xFF;
while (!marker)
{
int delta = message[index] >> 0x04;
CoapOption CoapOption = CoapOption.Decode(message, index, previous, out index);
Options.Add(CoapOption);
previous += delta;
marker = (message[index] & 0xFF) == 0xFF;
}
if (marker)
{
index++;
Payload = new byte[message.Length - index];
Buffer.BlockCopy(message, index, Payload, 0, Payload.Length);
}
Error = !Options.ContainsContentFormat();
ReadOptions(this);
}
private void UpdateCalendarItem(ItemChangeType[] changes)
{
UpdateItemType updateItemRequest = new UpdateItemType();
updateItemRequest.ConflictResolution = ConflictResolutionType.AlwaysOverwrite;
updateItemRequest.ItemChanges = changes;
updateItemRequest.SendMeetingInvitationsOrCancellations = CalendarItemUpdateOperationType.SendToNone;
updateItemRequest.SendMeetingInvitationsOrCancellationsSpecified = true;
UpdateItemResponseType response = Service.UpdateItem(updateItemRequest);
ResponseMessageType responseMessage = response.ResponseMessages.Items[0];
if (responseMessage.ResponseCode != ResponseCodeType.NoError)
{
throw new Exception("UpdateItem failed with response code " + responseMessage.ResponseCode);
}
}
public ApiException(string message,
ResponseMessageType messageType = ResponseMessageType.BadRequest,
object data = null,
int statusCode = 400) :
base(message)
{
this.StatusCode = statusCode;
this.Messages = new List <ResponseMessage>
{
new ResponseMessage
{
Message = message,
ResponseMessageType = messageType,
Data = data
}
};
}
/// <summary>
/// Delete a specific message.
/// </summary>
/// <param name="messageId">The Id of the message to be deleted.</param>
/// <returns>True if the delete operation success, otherwise false.</returns>
protected bool DeleteMessage(string messageId)
{
DeleteItemType deleteItemRequest = new DeleteItemType()
{
DeleteType = DisposalType.HardDelete,
ItemIds = new BaseItemIdType[]
{
new ItemIdType()
{
Id = messageId
}
}
};
DeleteItemResponseType deleteItemResponse = this.COREAdapter.DeleteItem(deleteItemRequest);
ResponseMessageType responseMessage = deleteItemResponse.ResponseMessages.Items[0] as ResponseMessageType;
return(responseMessage.ResponseClass == ResponseClassType.Success);
}
/// <summary>
/// Inserts the specified appointment.
/// </summary>
/// <param name="owner">The owner RadScheduler instance.</param>
/// <param name="appointmentToInsert">The appointment to insert.</param>
public override void Insert(RadScheduler owner, Appointment appointmentToInsert)
{
CreateRecurrenceExceptionContext createExceptionContext = owner.ProviderContext as CreateRecurrenceExceptionContext;
if (createExceptionContext != null)
{
Debug.Assert(appointmentToInsert.RecurrenceState == RecurrenceState.Exception);
InsertRecurrenceException(owner, appointmentToInsert, createExceptionContext.RecurrenceExceptionDate);
return;
}
CalendarItemType calendarItem = CreateCalendarItem(owner, appointmentToInsert);
CreateItemType createItemRequest = new CreateItemType();
DistinguishedFolderIdType destFolder = new DistinguishedFolderIdType();
destFolder.Id = DistinguishedFolderIdNameType.calendar;
EmailAddressType emailAddressType = new EmailAddressType();
emailAddressType.EmailAddress = this.CalendarNames;
destFolder.Mailbox = emailAddressType;
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
createItemRequest.SavedItemFolderId.Item = destFolder;
createItemRequest.SendMeetingInvitations = CalendarItemCreateOrDeleteOperationType.SendToNone;
createItemRequest.SendMeetingInvitationsSpecified = true;
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new CalendarItemType[] { calendarItem };
CreateItemResponseType response = Service.CreateItem(createItemRequest);
ResponseMessageType responseMessage = response.ResponseMessages.Items[0];
if (responseMessage.ResponseCode != ResponseCodeType.NoError)
{
throw new Exception("CreateItem failed with response code " + responseMessage.ResponseCode);
}
}
private T[] ExecuteWebMethodMultiResponse<T>(Func<BaseResponseMessageType> webMethodDelegate) where T : ResponseMessageType
{
ResponseMessageType[] array = this.ExecuteWebMethod(webMethodDelegate);
List<T> list = new List<T>(array.Length);
for (int i = 0; i < array.Length; i++)
{
ResponseMessageType responseMessageType = array[i];
if (responseMessageType == null)
{
ExchangeService.Tracer.TraceError<ExchangeService, int>((long)this.GetHashCode(), "{0}: response item {1} is not present", this, i);
}
else if (responseMessageType.ResponseClass != ResponseClassType.Success)
{
ExchangeService.Tracer.TraceError((long)this.GetHashCode(), "{0}: response item {1} failed: ResponseClass={2}, ResponseCode={3}, MessageText={4}", new object[]
{
this,
i,
responseMessageType.ResponseClass,
responseMessageType.ResponseCode,
responseMessageType.MessageText
});
}
else
{
T t = responseMessageType as T;
if (t == null)
{
ExchangeService.Tracer.TraceError<ExchangeService, int, ResponseMessageType>((long)this.GetHashCode(), "{0}: response item {1} is not of expected type: {2}", this, i, responseMessageType);
}
else
{
list.Add(t);
}
}
}
if (list.Count == 0)
{
ExchangeService.Tracer.TraceError<ExchangeService, string>((long)this.GetHashCode(), "{0}: Request for {1} did not return any successful items.", this, webMethodDelegate.Method.Name);
throw new UnexpectedRemoteDataException(array);
}
return list.ToArray();
}
public CoapResponse(ushort messageId, ResponseMessageType type, ResponseCodeType code, byte[] token, MediaType?contentType, byte[] payload)
{
this.MessageId = messageId;
this.ResponseType = type;
this.ResponseCode = code;
this.Code = (CodeType)code;
if (token != null)
{
this.Token = token;
}
if (contentType.HasValue)
{
this.ContentType = contentType;
}
this.Payload = payload;
this._options = new CoapOptionCollection();
}
private static string ResponseMessageTypeToString(ResponseMessageType item)
{
if (item == null)
{
return("<null>");
}
XmlSerializer xmlSerializer = new XmlSerializer(item.GetType());
string result;
using (MemoryStream memoryStream = new MemoryStream())
{
xmlSerializer.Serialize(memoryStream, item);
memoryStream.Seek(0L, SeekOrigin.Begin);
using (StreamReader streamReader = new StreamReader(memoryStream))
{
result = streamReader.ReadToEnd();
}
}
return(result);
}
public void Route(string response)
{
ResponseMessageType respType = GetMessageType(response);
switch (respType)
{
case ResponseMessageType.OK:
break;
case ResponseMessageType.PRAMETER:
break;
case ResponseMessageType.STATUS:
Process_Status(response);
break;
default:
break;
}
}
private void DeleteItem(BaseItemIdType itemId)
{
DeleteItemType deleteItemRequest = new DeleteItemType();
deleteItemRequest.DeleteType = DisposalType.HardDelete;
deleteItemRequest.AffectedTaskOccurrences = AffectedTaskOccurrencesType.SpecifiedOccurrenceOnly;
deleteItemRequest.AffectedTaskOccurrencesSpecified = true;
deleteItemRequest.SendMeetingCancellations = CalendarItemCreateOrDeleteOperationType.SendToNone;
deleteItemRequest.SendMeetingCancellationsSpecified = true;
deleteItemRequest.ItemIds = new BaseItemIdType[] { itemId };
DeleteItemResponseType response = Service.DeleteItem(deleteItemRequest);
ResponseMessageType responseMessage = response.ResponseMessages.Items[0];
if (responseMessage.ResponseCode != ResponseCodeType.NoError)
{
throw new Exception("DeleteItem failed with response code " + responseMessage.ResponseCode);
}
}
private ClientIntentType HandleGetClientIntentResponse(ResponseMessageType responseType)
{
if (responseType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetClientIntent returned NULL responseType.");
return(null);
}
if (responseType.ResponseCode != ResponseCodeType.NoError)
{
Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseType.ResponseCode);
return(null);
}
GetClientIntentResponseMessageType getClientIntentResponseMessageType = responseType as GetClientIntentResponseMessageType;
if (getClientIntentResponseMessageType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetClientIntent web request returned NULL GetClientIntentResponseMessageType.");
return(null);
}
return(getClientIntentResponseMessageType.ClientIntent);
}
public async Task <CoapMessage> DeleteAsync(CoapMessage message)
{
Exception error = null;
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
try
{
await adapter.UnsubscribeAsync(uri.Resource);
await logger?.LogDebugAsync($"CoAP delete unsubscribe '{uri.Resource}' for {session.Identity}.");
coapObserved.Remove(uri.Resource);
await logger?.LogDebugAsync($"CoAP delete removed '{uri.Resource}' for {session.Identity}.");
}
catch (Exception ex)
{
await logger?.LogErrorAsync(ex, $"CoAP delete fault during unsubscribe process for {session.Identity}");
error = ex;
}
if (error == null)
{
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
await logger?.LogDebugAsync($"CoAP delete returning response for '{uri.Resource}' with {rmt.ToString()} for {session.Identity}.");
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Deleted, message.Token));
}
else
{
await logger?.LogDebugAsync($"CoAP delete returning response for '{uri.Resource}' with {ResponseCodeType.EmptyMessage.ToString()} for {session.Identity}.");
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
}
public ResponseDomainBasic(ResponseMessageType msgType)
{
this.MsgType = msgType;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResponseMessage"/> class
/// that has the default type and a text associated with it.
/// </summary>
/// <remarks>The default reponse type is
/// <see cref="ResponseMessageType.TextMessage"/></remarks>
public ResponseMessage(string response) {
type_ = ResponseMessageType.TextMessage;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResponseMessage"/> class
/// that has the specified type and no text associated with it.
/// </summary>
/// <param name="type">The type of the response message.</param>
/// <remarks>This constructor sets the value of the response text to a
/// empty string.</remarks>
public ResponseMessage(ResponseMessageType type) {
type_ = type;
response_ = string.Empty;
}
/// <summary>
/// 根据请求消息类型得到一个对应的格式化器。
/// </summary>
/// <param name="responseMessageType">响应消息类型。</param>
/// <returns>一个可用消息格式化器。</returns>
/// <exception cref="NotSupportedException">响应消息的类型不被支持。</exception>
public IMessageFormatter GetFormatter(ResponseMessageType responseMessageType)
{
var formatter = ResponseMessageFormatterDictionary[responseMessageType];
if (formatter == null)
throw new NotSupportedException(string.Format("不支持的响应消息类型：{0}。", responseMessageType));
return formatter;
}
