学步园

           现今人们可以在电子设备中输入重要的约会信息，一旦到了时间，设备会进行事件提醒，这是一个很不错的功能，MS Office就为我们提供了这样的功能。它可以向人们展示由天、周或月的活动日历。Office的数字助理提供了优秀的功能支持。要实现日历功能，搭建一台可靠稳定的日历服务器是不小的任务。所幸，Exchange为我们提供了Web Service(EWS)作为日历服务器交互的协作平台。通过EWS我们可以对日历进行二次开发。

　　　　一、创建一个日历项：

　　　　

 

 1 public static ItemIdType CreateCalendarItem(ExchangeServiceBinding binding)
{
  CalendarItemType newCalendarItem = new CalendarItemType();
  newCalendarItem.Subject = "新建一个日历项";
  CreateItemType createItemRequest = new CreateItemType();

  // 当使用CreateItem 方法创建一个日历项, 必须对 SendMeetingInviations 属性赋值  //
   createItemRequest.SendMeetingInvitations =
          CalendarItemCreateOrDeleteOperationType.SendToNone;
  createItemRequest.SendMeetingInvitationsSpecified = true;

  createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
  createItemRequest.Items.Items = new CalendarItemType[1];
  createItemRequest.Items.Items[0] = newCalendarItem;
  // 创建一个请求  //
   CreateItemResponseType response = binding.CreateItem(createItemRequest);
  ItemInfoResponseMessageType responseMessage = response.ResponseMessages.Items[0] as
        ItemInfoResponseMessageType;
  if (responseMessage.ResponseCode != ResponseCodeType.NoError)
  {
    throw new Exception("CreateCalendarItem failed with response code " +
             responseMessage.ResponseCode.ToString());
  }
  return responseMessage.Items.Items[0].ItemId;
}
 

  

　　　　二、日历项的三个概念：

　　　　Recurrences

　　　　Meetings

　　　　Free/Busy 状态

 

　　　　Recurrences:

　　　　　　 一个日历项去遵循不同的模式，是由一个定期序列确定的。你可以设置一个定期序列，如每周一早上9点开个例会；表示按规定时间复发事件；

　　　　　　当创建了一个定期序列，日历项明确已知的，每次发生的，给予指定人的日历项；

　　　　　　定期序列需注意定期时间和时区问题；

　　　　Meetings:

　　　　　　日历项可以定义一个或多个会议预约，在Exchange Web Service，这些预约都会提醒与会者；

　　　　　　与会者存在在一个日历项三个不同的邀请人字段中，分类收集他们的日历项目并检查IsMeeting属性判断是否是会议；

　　　　Free/Busy状态：

　　　　　　每个日历项会消耗用户日历的时间，随着时间槽的变化，应用到一定的时间，显示空闲或忙碌的状态，如一个会议在2~3点开，当2点半时，其他同事提起一个会议会发现你正在忙碌；

 

　　　　三、查看相邻日历和冲突日历

　　　　用户使用日历的习惯：

　　　　1.看看今天的日程安排；

　　　　2.看看是否有一些时间可以挤进更多的预约；

　　　　

　　　　查某一区间的会议

　　　　

 1 public static void FunWithDateTimeKind()
{
  DateTime dateTime = new DateTime(2010, 07, 29, 08, 15, 00,
                                   DateTimeKind.Unspecified);

  CalendarItemType calItemUnspecified = new CalendarItemType();
  calItemUnspecified.Start = dateTime;
  calItemUnspecified.End = calItemUnspecified.Start.AddHours(1);
  calItemUnspecified.StartSpecified = true;
  calItemUnspecified.EndSpecified = true;
  SerializeToConsole("DateTimeKind.Unspecified", calItemUnspecified);

  CalendarItemType calItemLocal = new CalendarItemType();
  calItemLocal.Start = dateTime.ToLocalTime();
  calItemLocal.End = calItemLocal.Start.AddHours(1);
  calItemLocal.StartSpecified = calItemLocal.EndSpecified = true;
  SerializeToConsole("DateTimeKind.Local", calItemLocal);

  CalendarItemType calItemUTC = new CalendarItemType();
  calItemUTC.Start = dateTime.ToUniversalTime();
  calItemUTC.End = calItemUTC.Start.AddHours(1);
  calItemUTC.StartSpecified = calItemUTC.EndSpecified = true;
  SerializeToConsole("DateTimeKind.UTC", calItemUTC);

}


 public static void SerializeToConsole(string header, CalendarItemType calendarItem)
{
  XmlSerializer serializer = new XmlSerializer(typeof(CalendarItemType));

  Console.WriteLine(header);
  Console.WriteLine("--------------------------");
  using (Stream outStream = Console.OpenStandardOutput())
  {
    serializer.Serialize(outStream, calendarItem);
  }
  Console.WriteLine();
  Console.WriteLine();
}
 

 

 

　　　　 四、创建一个会议邀请

　　　　

public static ItemIdType CreateNewMeetingAndInviteAttendees(
    ExchangeServiceBinding binding,
    DateTime meetingStartTime,
    DateTime meetingEndTime,
    TimeZoneType meetingTimeZone,
    EmailAddressType[] requiredAttendees,
    EmailAddressType[] optionalAttendees,
    EmailAddressType meetingRoom)
 {
// 日历项信息
//
    CalendarItemType newCalendarItem = new CalendarItemType();
    newCalendarItem.Start = meetingStartTime;
    newCalendarItem.StartSpecified = true;
    newCalendarItem.End = meetingEndTime;
    newCalendarItem.EndSpecified = true;
    newCalendarItem.MeetingTimeZone = meetingTimeZone;
// 设置会议室名
//
    newCalendarItem.Location = meetingRoom.Name;
    newCalendarItem.Subject = "Meeting in room " + meetingRoom.Name;

// 创建一个实例并为每个EmailAddreesType增加与会者    //
    newCalendarItem.RequiredAttendees = new
        AttendeeType[requiredAttendees.Length];
for (int x = 0; x < requiredAttendees.Length; x++)
    {
        newCalendarItem.RequiredAttendees[x] = new AttendeeType();
        newCalendarItem.RequiredAttendees[x].Mailbox = requiredAttendees[x];
    }

    newCalendarItem.OptionalAttendees = new
        AttendeeType[optionalAttendees.Length];
for (int x = 0; x < optionalAttendees.Length; x++)
    {
        newCalendarItem.OptionalAttendees[x] = new AttendeeType();
        newCalendarItem.OptionalAttendees[x].Mailbox = optionalAttendees[x];
    }

    newCalendarItem.Resources = new AttendeeType[1];
    newCalendarItem.Resources[0] = new AttendeeType();
    newCalendarItem.Resources[0].Mailbox = meetingRoom;

// 创建请求--关键步骤！
//
    CreateItemType createItemRequest = new CreateItemType();
    createItemRequest.SendMeetingInvitations =
        CalendarItemCreateOrDeleteOperationType.SendOnlyToAll;
    createItemRequest.SendMeetingInvitationsSpecified = true;
    createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
    createItemRequest.Items.Items = new CalendarItemType[] { newCalendarItem };

    CreateItemResponseType response = binding.CreateItem(createItemRequest);
    ItemInfoResponseMessageType responseMessage =
        response.ResponseMessages.Items[0] as
          ItemInfoResponseMessageType;

if (responseMessage.ResponseCode != ResponseCodeType.NoError)
    {
throw new Exception(String.Format(
"Unable to create a new meeting\r\n{0}\r\n{1}",
            responseMessage.ResponseCode,
            responseMessage.MessageText));
    }
return responseMessage.Items.Items[0].ItemId;
}

 流程如图：

 

　　　　五、响应一个会议请求

　　　　

 1 public static ItemIdType RespondToMeetingRequest(
    ExchangeServiceBinding binding,
    ItemIdType meetingMessageOrCalendarItemId,
    ResponseTypeType responseToRegister,
    string meetingResponseBody,
    bool requestDeliveryReceipt,
    bool requestReadReceipt)
 {
    WellKnownResponseObjectType meetingResponseObject;
    switch (responseToRegister)
    {
        case ResponseTypeType.Accept:
            meetingResponseObject = new AcceptItemType();
            break;
        case ResponseTypeType.Tentative:
            meetingResponseObject = new TentativelyAcceptItemType();
            break;
        case ResponseTypeType.Decline:
            meetingResponseObject = new DeclineItemType();
            break;
        default:
            throw new ArgumentException("ResponseTypeType value of "
                + responseToRegister + " is not a valid meeting " +
                "registration response.");
    }

    meetingResponseObject.ReferenceItemId = meetingMessageOrCalendarItemId;
    meetingResponseObject.IsDeliveryReceiptRequested =
        requestDeliveryReceipt;
    meetingResponseObject.IsDeliveryReceiptRequestedSpecified = true;
    meetingResponseObject.IsReadReceiptRequested =
        requestReadReceipt;
    meetingResponseObject.IsReadReceiptRequestedSpecified = true;

    if (!String.IsNullOrEmpty(meetingResponseBody))
    {
        meetingResponseObject.Body = new BodyType();
        meetingResponseObject.Body.BodyType1 = BodyTypeType.Text;
        meetingResponseObject.Body.Value = meetingResponseBody;
    }

    CreateItemType createItemRequest = new CreateItemType();
    createItemRequest.MessageDisposition = MessageDispositionType.SendOnly;
    createItemRequest.MessageDispositionSpecified = true;
    createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
    createItemRequest.Items.Items =
        new WellKnownResponseObjectType[] { meetingResponseObject };

    CreateItemResponseType response = binding.CreateItem(createItemRequest);
    ItemInfoResponseMessageType responseMessage =
        response.ResponseMessages.Items[0] as ItemInfoResponseMessageType;

    if (responseMessage.ResponseCode != ResponseCodeType.NoError)
    {
        throw new Exception(String.Format(
            "Unable to register for meeting\r\n{0}\r\n{1}",
            responseMessage.ResponseCode,
            responseMessage.MessageText));
    }

    if (responseMessage.Items.Items != null)
    {
        return responseMessage.Items.Items[0].ItemId;
    }
    else
    {
        return null;
    }
}

 

 

　　　　六、取消一个会议

 1 public static void RemoveACancelledMeeting(
    ExchangeServiceBinding binding,
    ItemIdType meetingCancellationId)
 {

    RemoveItemType removeItem = new RemoveItemType();
    removeItem.ReferenceItemId = meetingCancellationId;

    CreateItemType createItemRequest = new CreateItemType();
    createItemRequest.MessageDisposition = MessageDispositionType.SendOnly;
    createItemRequest.MessageDispositionSpecified = true;
    createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
    createItemRequest.Items.Items =
        new RemoveItemType[] { removeItem };

    CreateItemResponseType response = binding.CreateItem(createItemRequest);
    ItemInfoResponseMessageType responseMessage =
        response.ResponseMessages.Items[0] as ItemInfoResponseMessageType;
    if (responseMessage.ResponseCode != ResponseCodeType.NoError)
    {
        throw new Exception(String.Format(
            "Unable to remove the meeting and/or " +
            "meeting cancellation message\r\n{0}\r\n{1}",
            responseMessage.ResponseCode,
            responseMessage.MessageText));
    }
}

 

 

　　上述内容简单了讲述了通过代码编程实现会议、日历项的一些功能，下节我们将通过一个实例，讲述在实际项目中如何应用。