示例#1
0
        /// <summary>
        /// Get a single mailbox folder path
        /// </summary>
        /// <param name="service">The active EWs connection</param>
        /// <param name="ID">The mailbox folder Id</param>
        /// <returns>A string containing the current mailbox folder path</returns>
        public static string GetFolderPath(ExchangeService service, FolderId ID)
        {
            try
            {
                var FolderPathProperty = new ExtendedPropertyDefinition(0x66B5, MapiPropertyType.String);

                PropertySet psset1 = new PropertySet(BasePropertySet.FirstClassProperties);
                psset1.Add(FolderPathProperty);

                Folder FolderwithPath = Folder.Bind(service, ID, psset1);
                Object FolderPathVal  = null;

                if (FolderwithPath.TryGetProperty(FolderPathProperty, out FolderPathVal))
                {
                    // because the FolderPath contains characters we don't want, we need to fix it
                    string FolderPathTemp = FolderPathVal.ToString();
                    if (FolderPathTemp.Contains("￾"))
                    {
                        return(FolderPathTemp.Replace("￾", "\\"));
                    }
                    else
                    {
                        return(FolderPathTemp);
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error("Failed to get folder path", ex);
            }

            return("");
        }
示例#2
0
        /// <summary>
        /// SendEmailAsync
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <SendMailResponse> SendEmailAsync(ISendMailRequest request)
        {
            var messageResponse = new SendMailResponse();

            var             requestedServerVersion = (ExchangeVersion)_clientConfig.HostClientRequestInfo.Port;
            ExchangeService service = new ExchangeService(requestedServerVersion);

            service.Credentials = _webCrendential;
            service.Url         = new Uri(_clientConfig.HostClientRequestInfo.Host);

            EmailMessage message = new EmailMessage(service)
            {
                From    = new EmailAddress(request.FromName, request.From),
                Subject = request.Subject
            };

            message.ToRecipients.Add(request.Recipients.First());
            message.Body = request.Message;

            ExtendedPropertyDefinition customHeaders;

            foreach (var header in request.Headers)
            {
                if (header.Key.Equals("List-Unsubscribe", StringComparison.OrdinalIgnoreCase))
                {
                    customHeaders = new ExtendedPropertyDefinition(DefaultExtendedPropertySet.InternetHeaders,
                                                                   header.Key,
                                                                   MapiPropertyType.String);
                    var splitValues = header.Value.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
                    if (splitValues.Length > 1)
                    {
                        message.SetExtendedProperty(customHeaders, splitValues[0]);
                    }
                    else
                    {
                        message.SetExtendedProperty(customHeaders, header.Value);
                    }
                }
                else
                {
                    customHeaders = new ExtendedPropertyDefinition(DefaultExtendedPropertySet.InternetHeaders,
                                                                   header.Key,
                                                                   MapiPropertyType.String);
                    message.SetExtendedProperty(customHeaders, header.Value);
                }
            }

            try
            {
                await message.SendAndSaveCopy();

                messageResponse.IsSuccess = true;
            }
            catch (Exception ex)
            {
                messageResponse.ErrorMessage = ex.Message;
            }

            return(messageResponse);
        }
示例#3
0
        public List <EWSCalendar> GetCalendarsAsync(int maxFoldersToRetrive)
        {
            var service = GetExchangeService(null);

            // Create a new folder view, and pass in the maximum number of folders to return.
            var view = new FolderView(1000);

            // Create an extended property definition for the PR_ATTR_HIDDEN property,
            // so that your results will indicate whether the folder is a hidden folder.
            var isHiddenProp = new ExtendedPropertyDefinition(0x10f4, MapiPropertyType.Boolean);

            // As a best practice, limit the properties returned to only those required.
            // In this case, return the folder ID, DisplayName, and the value of the isHiddenProp
            // extended property.
            view.PropertySet = new PropertySet(BasePropertySet.FirstClassProperties, FolderSchema.DisplayName,
                                               isHiddenProp);

            // Indicate a Traversal value of Deep, so that all subfolders are retrieved.
            view.Traversal = FolderTraversal.Deep;

            // Call FindFolders to retrieve the folder hierarchy, starting with the MsgFolderRoot folder.
            // This method call results in a FindFolder call to EWS.
            var findFolderResults = service.FindFolders(WellKnownFolderName.MsgFolderRoot, view);

            var ewsCalendars = new List <EWSCalendar>();

            foreach (var searchFolder in findFolderResults.Folders)
            {
                GetCalendars(searchFolder, ewsCalendars, view);
            }
            return(ewsCalendars);
        }
示例#4
0
        private static ExtendedPropertySettings FromXmlVersion3Schema(XmlElement element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            // load...
            ExtendedPropertySettings settings = new ExtendedPropertySettings();

            // load the extended properties
            foreach (XmlElement propertyElement in element.SelectNodes("ExtendedProperties/ExtendedProperty"))
            {
                settings.Properties.Add(ExtendedPropertyDefinition.FromXml(propertyElement));
            }

            // load the extended lookups
            foreach (XmlElement lookupElement in element.SelectNodes("Lookups/Lookup"))
            {
                settings.Lookups.Add(ExtendedLookupDefinition.FromXml(lookupElement));
            }

            // return...
            return(settings);
        }
示例#5
0
        //gavdcodeend 12

        //gavdcodebegin 13
        private static void ImportEmail(ExchangeService ExService)
        {
            EmailMessage emailToImport = new EmailMessage(ExService);

            string emlFileName = @"C:\Temporary\myEmail.eml";

            using (FileStream myStream = new FileStream(
                       emlFileName, FileMode.Open, FileAccess.Read))
            {
                byte[] mailBytes   = new byte[myStream.Length];
                int    bytesToRead = (int)myStream.Length;
                int    bytesRead   = 0;
                while (bytesToRead > 0)
                {
                    int myBlock = myStream.Read(mailBytes, bytesRead, bytesToRead);
                    if (myBlock == 0)
                    {
                        break;
                    }
                    bytesRead   += myBlock;
                    bytesToRead -= myBlock;
                }
                emailToImport.MimeContent = new MimeContent("UTF-8", mailBytes);
            }

            ExtendedPropertyDefinition PR_MESSAGE_FLAGS_msgflag_read = new
                                                                       ExtendedPropertyDefinition(3591, MapiPropertyType.Integer);

            emailToImport.SetExtendedProperty(PR_MESSAGE_FLAGS_msgflag_read, 1);

            emailToImport.Save(WellKnownFolderName.Inbox);
        }
示例#6
0
        public static GuidNamePropertyDefinition CreateStorePropertyDefinition(EwsStoreObjectPropertyDefinition ewsStorePropertyDefinition)
        {
            ExtendedPropertyDefinition extendedPropertyDefinition = (ExtendedPropertyDefinition)ewsStorePropertyDefinition.StorePropertyDefinition;
            Type propertyType = ((ewsStorePropertyDefinition.PropertyDefinitionFlags & PropertyDefinitionFlags.MultiValued) == PropertyDefinitionFlags.MultiValued) ? ewsStorePropertyDefinition.Type.MakeArrayType() : ewsStorePropertyDefinition.Type;

            return(GuidNamePropertyDefinition.InternalCreate(ewsStorePropertyDefinition.Name, propertyType, MailboxDiscoverySearchRequestSchema.GetMapiPropType(extendedPropertyDefinition.MapiType), extendedPropertyDefinition.PropertySetId.Value, extendedPropertyDefinition.Name, PropertyFlags.None, NativeStorePropertyDefinition.TypeCheckingFlag.DisableTypeCheck, false, PropertyDefinitionConstraint.None));
        }
示例#7
0
        /// <summary>
        /// Creates a custom  extended property on an email message. This uses a custom property set identifier.
        /// </summary>
        /// <param name="service">An ExchangeService object with credentials and the EWS URL.</param>
        private static void CreateCustomExtendedProperties(ExchangeService service)
        {
            // Create the GUID for the property set.
            Guid MyPropertySetId = new Guid("{C11FF724-AA03-4555-9952-8FA248A11C3E}");

            // Create a definition for the extended property.
            ExtendedPropertyDefinition extendedPropertyDefinition = new ExtendedPropertyDefinition(MyPropertySetId,
                                                                                                   "Expiration Date",
                                                                                                   MapiPropertyType.String);

            // Create an email message that you will add the extended property to.
            EmailMessage message = new EmailMessage(service);

            message.Subject = "Saved with custom ExtendedPropertyDefinition.";
            message.Body    = "The expiration date is contained within the extended property.";
            message.ToRecipients.Add("*****@*****.**");

            // Add the extended property to an email message object.
            message.SetExtendedProperty(extendedPropertyDefinition, DateTime.Now.AddDays(2).ToString());

            try
            {
                // Save the email message as a draft. This results in a CreateItem call to
                // EWS.
                message.Save();
                Console.WriteLine("Saved email with custom extended property.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: {0}", ex.Message);
            }
        }
示例#8
0
        private static IEnumerable <Item> GetConversationItemsSingleConversation(ExchangeService service, FolderId folderId, ConversationId conversationId)
        {
            var conversationIdProperty = new ExtendedPropertyDefinition(0x3013, MapiPropertyType.Binary);
            var cidBinary = Convert.FromBase64String(conversationId.UniqueId);
            var cidGuid   = new byte[16];

            Array.Copy(cidBinary, 43, cidGuid, 0, 16);

            var conversationIdValue = Convert.ToBase64String(cidGuid);
            var itempropertyset     = new PropertySet(BasePropertySet.FirstClassProperties)
            {
                RequestedBodyType = BodyType.Text
            };
            var itemview = new ItemView(100)
            {
                PropertySet = itempropertyset
            };

            // {
            // PropertySet = new PropertySet(
            // BasePropertySet.IdOnly,
            // ItemSchema.DateTimeReceived,
            // ItemSchema.LastModifiedName,
            // ItemSchema.DisplayTo,
            // ItemSchema.DisplayCc,
            // ItemSchema.Subject)
            // };
            var conversationFilter = new SearchFilter.IsEqualTo(conversationIdProperty, conversationIdValue);
            var items = service.FindItems(folderId, conversationFilter, itemview);

            return(items);
        }
示例#9
0
        public override void Execute()
        {
            ItemView view = new ItemView(100);
            FindItemsResults <Item> sentItems = this.proxy.ExchangeService.FindItems(WellKnownFolderName.SentItems, view);

            ExtendedPropertyDefinition pdApxIDSave = new ExtendedPropertyDefinition(DefaultExtendedPropertySet.PublicStrings, "ApxIDSave", MapiPropertyType.String);
            ExtendedPropertyDefinition pdApxID     = new ExtendedPropertyDefinition(DefaultExtendedPropertySet.PublicStrings, "ApxID", MapiPropertyType.String);

            PropertySet ps = new PropertySet(pdApxIDSave, pdApxID);

            foreach (Item item in sentItems)
            {
                Console.WriteLine(item.Subject);
                item.Load(ps);
                if (item.ExtendedProperties.Count > 0)
                {
                    foreach (ExtendedProperty p in item.ExtendedProperties)
                    {
                        Console.WriteLine("{0}={1}", p.PropertyDefinition.Name, p.Value);
                    }
                }
            }

            Console.ReadKey();
        }
示例#10
0
        //gavdcodeend 08

        //gavdcodebegin 10
        static void HideOneFolder(ExchangeService ExService)
        {
            Folder rootFolder = Folder.Bind(ExService, WellKnownFolderName.JunkEmail);

            rootFolder.Load();
            SearchFilter.ContainsSubstring subjectFilter =
                new SearchFilter.ContainsSubstring(
                    FolderSchema.DisplayName,
                    "my custom folder",
                    ContainmentMode.Substring,
                    ComparisonMode.IgnoreCase);

            FolderId myFolderId = null;

            foreach (Folder oneFolder in rootFolder.FindFolders(
                         subjectFilter, new FolderView(1)))
            {
                myFolderId = oneFolder.Id;
            }

            ExtendedPropertyDefinition isHiddenProp = new
                                                      ExtendedPropertyDefinition(0x10f4, MapiPropertyType.Boolean);
            PropertySet propSet = new PropertySet(isHiddenProp);

            Folder folderToHide = Folder.Bind(ExService, myFolderId, propSet);

            folderToHide.SetExtendedProperty(isHiddenProp, true);
            folderToHide.Update();
        }
示例#11
0
        //public IReadOnlyList<ServiceAgent> GetUserFreeBusy(IReadOnlyList<string> agentIDs, string targetTimeZone, TimeSpan shiftStartTime, TimeSpan shiftEndTime, DateTime startDate, DateTime endDate)
        //{
        //    try
        //    {
        //        RequestedTimeWindow = new TimeWindow(startDate, endDate);
        //        List<string> missedAgentIDs = new List<string>();
        //        Collection<TimeSlot> lstTimeSlot;
        //        Collection<ServiceAgent> lstServiceAgent = new Collection<ServiceAgent>();
        //        // Create a list of attendees.
        //        Collection<AttendeeInfo> attendees = new Collection<AttendeeInfo>();
        //        Collection<AttendeeInfo> attendeesInternal = new Collection<AttendeeInfo>();
        //        bool exchangeDataRetrival = true;
        //        int exchangeRehit = 0;
        //        int count = 0;
        //        int totalcount = 0;
        //        if (agentIDs != null || agentIDs.Count > 0)
        //        {
        //            foreach (var agentID in agentIDs)
        //            {
        //                count += 1;
        //                totalcount += 1;
        //                attendees.Add(new AttendeeInfo()
        //                {
        //                    SmtpAddress = agentID,
        //                    AttendeeType = MeetingAttendeeType.Required
        //                });

        //                if ((count == 13) || (totalcount == agentIDs.Count))
        //                {
        //                    count = 0;
        //                    while (exchangeDataRetrival)
        //                    {
        //                        missedAgentIDs.Clear();
        //                        // Specify availability options.
        //                        AvailabilityOptions myOptions = new AvailabilityOptions();
        //                        myOptions.MeetingDuration = 30;
        //                        myOptions.RequestedFreeBusyView = FreeBusyViewType.FreeBusy;



        //                        // Return a set of free/busy times.
        //                        GetUserAvailabilityResults freeBusyResults = this.Exchange.GetUserAvailability(attendees,
        //                                                                                             this.RequestedTimeWindow,
        //                                                                                                 AvailabilityData.FreeBusy,
        //                                                                                              myOptions);
        //                        int i = 0;
        //                        foreach (AttendeeAvailability availability in freeBusyResults.AttendeesAvailability)
        //                        {
        //                            if (availability.WorkingHours != null)
        //                            {
        //                                ServiceAgent srAgent = new ServiceAgent();
        //                                srAgent.ServiceAgentEmail = attendees[i++].SmtpAddress;
        //                                ServiceAgentWorkingHours srAgntWorkingHours = new ServiceAgentWorkingHours();
        //                                srAgntWorkingHours.StartTime = availability.WorkingHours.StartTime;
        //                                srAgntWorkingHours.EndTime = availability.WorkingHours.EndTime;
        //                                srAgntWorkingHours.ServiceAgentTimeZone = targetTimeZone;
        //                                srAgent.ServiceWorkingHours = srAgntWorkingHours;
        //                                lstTimeSlot = new Collection<TimeSlot>();
        //                                foreach (CalendarEvent calendarItem in availability.CalendarEvents)
        //                                {
        //                                    if (calendarItem.FreeBusyStatus.ToString() != "Free")
        //                                    {
        //                                        TimeSlot tmSlot = new TimeSlot();
        //                                        tmSlot.StartTime = TimeZoneInfo.ConvertTimeFromUtc(calendarItem.StartTime, TimeZoneInfo.FindSystemTimeZoneById(targetTimeZone));
        //                                        tmSlot.EndTime = TimeZoneInfo.ConvertTimeFromUtc(calendarItem.EndTime, TimeZoneInfo.FindSystemTimeZoneById(targetTimeZone));
        //                                        tmSlot.FreeSlot = false;
        //                                        lstTimeSlot.Add(tmSlot);
        //                                    }
        //                                }
        //                                srAgent.BusyTimeSlotsCustomerTimeZone = lstTimeSlot;
        //                                lstServiceAgent.Add(srAgent);
        //                            }
        //                            else
        //                            {
        //                                missedAgentIDs.Add(attendees[i].SmtpAddress);
        //                                i++;
        //                            }
        //                        }

        //                        if (missedAgentIDs.Count > 0 && exchangeRehit == 0)
        //                        {
        //                            attendees.Clear();
        //                            foreach (var agentMissed in missedAgentIDs)
        //                            {
        //                                 attendees.Add(new AttendeeInfo()
        //                                    {
        //                                        SmtpAddress = agentMissed,
        //                                        AttendeeType = MeetingAttendeeType.Required
        //                                    });
        //                            }
        //                            exchangeRehit += 1;
        //                        }
        //                        else if (missedAgentIDs.Count > 0 && exchangeRehit !=0)
        //                        {
        //                            if (exchangeRehit > 2 && missedAgentIDs.Count == 1)
        //                            {
        //                                break;
        //                            }
        //                            else if (exchangeRehit > 2 && missedAgentIDs.Count > 1)
        //                            {
        //                                break;
        //                            }
        //                            attendees.Clear();
        //                            foreach (var agentMissed in missedAgentIDs)
        //                            {
        //                                attendees.Add(new AttendeeInfo()
        //                                {
        //                                    SmtpAddress = agentMissed,
        //                                    AttendeeType = MeetingAttendeeType.Required
        //                                });
        //                            }
        //                            exchangeRehit += 1;

        //                        }
        //                        else if (missedAgentIDs.Count == 0)
        //                        {
        //                            break;
        //                        }
        //                    }
        //                    attendees.Clear();
        //                }

        //            }
        //        }
        //        return lstServiceAgent;
        //    }
        //    catch
        //    {
        //        throw;
        //    }
        //}

        /// <summary>
        /// Gets the user free busy.
        /// </summary>
        /// <param name="agentIDs">The agent I ds.</param>
        /// <param name="targetTimeZone">The target time zone.</param>
        /// <param name="shiftStartTime">The shift start time.</param>
        /// <param name="shiftEndTime">The shift end time.</param>
        /// <param name="startDate">The start date.</param>
        /// <param name="endDate">The end date.</param>
        /// <returns>IReadOnlyList</returns>
        //public IReadOnlyList<ServiceAgent> GetUserFreeBusy(IReadOnlyList<string> agentIDs, string targetTimeZone, TimeSpan shiftStartTime, TimeSpan shiftEndTime,DateTime startDate,DateTime endDate)
        //{
        //    try
        //    {
        //        RequestedTimeWindow = new TimeWindow(startDate, endDate);
        //        List<string> missedAgentIDs = new List<string>();
        //        Collection<TimeSlot> lstTimeSlot;
        //        Collection<ServiceAgent> lstServiceAgent = new Collection<ServiceAgent>();
        //        // Create a list of attendees.
        //        Collection<AttendeeInfo> attendees = new Collection<AttendeeInfo>();
        //        int count = 0;
        //        int totalcount = 0;
        //        if (agentIDs != null || agentIDs.Count > 0)
        //        {
        //            foreach (var agentID in agentIDs)
        //            {
        //                count += 1;
        //                totalcount += 1;
        //                attendees.Add(new AttendeeInfo()
        //                {
        //                    SmtpAddress = agentID,
        //                    AttendeeType = MeetingAttendeeType.Required
        //                });

        //                if ((count == 6) || (totalcount == agentIDs.Count))
        //                {
        //                    count = 0;

        //                    // Specify availability options.
        //                    AvailabilityOptions myOptions = new AvailabilityOptions();
        //                    myOptions.MeetingDuration = 30;
        //                    myOptions.RequestedFreeBusyView = FreeBusyViewType.FreeBusy;



        //                    // Return a set of free/busy times.
        //                    GetUserAvailabilityResults freeBusyResults = this.Exchange.GetUserAvailability(attendees,
        //                                                                                         this.RequestedTimeWindow,
        //                                                                                             AvailabilityData.FreeBusy,
        //                                                                                          myOptions);
        //                    int i = 0;
        //                    foreach (AttendeeAvailability availability in freeBusyResults.AttendeesAvailability)
        //                    {
        //                        if (availability.WorkingHours != null)
        //                        {
        //                            ServiceAgent srAgent = new ServiceAgent();
        //                            srAgent.ServiceAgentEmail = attendees[i++].SmtpAddress;
        //                            ServiceAgentWorkingHours srAgntWorkingHours = new ServiceAgentWorkingHours();
        //                            srAgntWorkingHours.StartTime = availability.WorkingHours.StartTime;
        //                            srAgntWorkingHours.EndTime = availability.WorkingHours.EndTime;
        //                            srAgntWorkingHours.ServiceAgentTimeZone = targetTimeZone;
        //                            srAgent.ServiceWorkingHours = srAgntWorkingHours;
        //                            lstTimeSlot = new Collection<TimeSlot>();
        //                            foreach (CalendarEvent calendarItem in availability.CalendarEvents)
        //                            {
        //                                if (calendarItem.FreeBusyStatus.ToString() != "Free")
        //                                {
        //                                    TimeSlot tmSlot = new TimeSlot();
        //                                    tmSlot.StartTime = TimeZoneInfo.ConvertTimeFromUtc(calendarItem.StartTime, TimeZoneInfo.FindSystemTimeZoneById(targetTimeZone));
        //                                    tmSlot.EndTime = TimeZoneInfo.ConvertTimeFromUtc(calendarItem.EndTime, TimeZoneInfo.FindSystemTimeZoneById(targetTimeZone));
        //                                    tmSlot.FreeSlot = false;
        //                                    lstTimeSlot.Add(tmSlot);
        //                                }
        //                            }
        //                            srAgent.BusyTimeSlotsCustomerTimeZone = lstTimeSlot;
        //                            lstServiceAgent.Add(srAgent);
        //                        }
        //                        else
        //                        {
        //                            missedAgentIDs.Add(attendees[i++].SmtpAddress);
        //                        }
        //                    }
        //                    attendees.Clear();
        //                }

        //            }
        //        }
        //        return lstServiceAgent;
        //    }
        //    catch
        //    {
        //        throw;
        //    }
        //}

        ///// <summary>
        ///// Saves the appointment.
        ///// </summary>
        ///// <param name="appointmentInfo">The appointment info.</param>
        //public void SaveAppointment(AppointmentInfo appointmentInfo)
        //{
        //    try
        //    {
        //        Appointment appointment = new Appointment(Exchange);
        //        appointment.Subject = appointmentInfo.Subject;
        //        appointment.Body = appointmentInfo.Description;
        //        appointment.Body.BodyType = BodyType.HTML;
        //        appointment.Start = appointmentInfo.Start;
        //        appointment.End = appointmentInfo.End;
        //        appointment.ReminderMinutesBeforeStart = appointmentInfo.Reminder;
        //        appointment.RequiredAttendees.Add(appointmentInfo.AgentMailId, appointmentInfo.AgentMailId);
        //        appointment.RequiredAttendees.Add(appointmentInfo.CustomerMailId, appointmentInfo.CustomerMailId);
        //        appointment.Save(SendInvitationsMode.SendToAllAndSaveCopy);
        //    }
        //    catch
        //    {
        //        throw;
        //    }
        //}

        /// <summary>
        /// Saves the appointment.
        /// </summary>
        /// <param name="appointmentInfo">The appointment info.</param>
        public void SaveAppointment(AppointmentInfo appointmentInfo)
        {
            try
            {
                // Get the GUID for the property set.
                Guid MyPropertySetId = new Guid("{C11FF724-AA03-4555-9952-8FA248A11C3E}");
                // Create a definition for the extended property.
                ExtendedPropertyDefinition extendedPropertyDefinition =
                    new ExtendedPropertyDefinition(MyPropertySetId, "AppointmentID", MapiPropertyType.String);

                Appointment appointment = new Appointment(Exchange);
                appointment.Subject       = appointmentInfo.Subject;
                appointment.Body          = appointmentInfo.Description;
                appointment.Body.BodyType = BodyType.HTML;
                appointment.Start         = appointmentInfo.Start;
                appointment.End           = appointmentInfo.End;
                appointment.ReminderMinutesBeforeStart = appointmentInfo.Reminder;
                appointment.RequiredAttendees.Add(appointmentInfo.AgentMailId, appointmentInfo.AgentMailId);
                appointment.RequiredAttendees.Add(appointmentInfo.CustomerMailId, appointmentInfo.CustomerMailId);

                // SetGuidForAppointement(appointment);
                appointment.SetExtendedProperty(extendedPropertyDefinition, appointmentInfo.ID);

                appointment.Save(SendInvitationsMode.SendToAllAndSaveCopy);
            }
            catch
            {
                throw;
            }
        }
示例#12
0
 public ExtendedPropertyFilter(FilterOperator filterOperator, ExtendedPropertyDefinition extendedProperty, string value)
     : base(filterOperator)
 {
     ArgumentValidator.ThrowIfNull(extendedProperty, nameof(extendedProperty));
     this.ExtendedProperty = extendedProperty;
     this.Value            = value;
 }
示例#13
0
 public void CancelAppointment(AppointmentInfo appointmentInfo)
 {
     try
     {
         // Get the GUID for the property set.
         Guid MyPropertySetId = new Guid("{C11FF724-AA03-4555-9952-8FA248A11C3E}");
         // Create a definition for the extended property.
         ExtendedPropertyDefinition extendedPropertyDefinition = new ExtendedPropertyDefinition(MyPropertySetId, "AppointmentID", MapiPropertyType.String);
         ItemView view = new ItemView(50);
         view.PropertySet = new PropertySet(BasePropertySet.IdOnly, ItemSchema.Subject, extendedPropertyDefinition);
         // SearchFilter.IsGreaterThanOrEqualTo(ItemSchema.DateTimeCreated, DateTime.Today),
         FindItemsResults <Item> findResults = this.Exchange.FindItems(WellKnownFolderName.Calendar, new SearchFilter.IsLessThanOrEqualTo(ItemSchema.DateTimeCreated, appointmentInfo.CancelDate.Date), view);
         foreach (Appointment item in findResults.Items)
         {
             if (item.ExtendedProperties.Count > 0)
             {
                 // Display the extended name and value of the extended property.
                 foreach (ExtendedProperty extendedProperty in item.ExtendedProperties)
                 {
                     if (extendedProperty.Value.ToString() == appointmentInfo.ID)
                     {
                         item.CancelMeeting();
                     }
                 }
             }
         }
     }
     catch
     {
         throw;
     }
 }
        public EWSIncomingMessage(EmailMessage message, bool useConversationGuidOnly = false)
        {
            _message = message;
            _useConversationGuidOnly = useConversationGuidOnly;

            // Extended property for PidTagConversationId, which is the GUID portion of the ConversationIndex
            // See https://msdn.microsoft.com/en-us/library/cc433490(v=EXCHG.80).aspx and
            // https://msdn.microsoft.com/en-us/library/ee204279(v=exchg.80).aspx for more information
            ExtendedPropertyDefinition conversationId = new ExtendedPropertyDefinition(PidTagConversationIdTag, MapiPropertyType.Binary);

            message.Load(new PropertySet(
                             ItemSchema.Subject,
                             ItemSchema.Body,
                             EmailMessageSchema.ConversationIndex,
                             conversationId,
                             EmailMessageSchema.Sender,
                             EmailMessageSchema.From,
                             EmailMessageSchema.ToRecipients,
                             EmailMessageSchema.CcRecipients,
                             ItemSchema.MimeContent,
                             ItemSchema.DateTimeReceived,
                             ItemSchema.DateTimeSent,
                             EmailMessageSchema.ConversationTopic,
                             ItemSchema.Attachments,
                             ItemSchema.HasAttachments,
                             MeetingRequestSchema.Location,
                             MeetingRequestSchema.Start,
                             MeetingRequestSchema.End
                             ));

            message.TryGetProperty(conversationId, out _conversationId);

            Attachments = BuildAttachmentList(message);
        }
示例#15
0
//        public static void SetFolderHomePage(IEnumerable<string> pathFragments, string url, ExchangeService service)
        public static void SetFolderHomePage(string url, ExchangeService service, string Option)
        {
            var folderWebviewinfoProperty = new ExtendedPropertyDefinition(14047, MapiPropertyType.Binary);
            var root = Folder.Bind(service, WellKnownFolderName.Inbox);

            var targetFolder = root;

            //foreach (var fragment in pathFragments)
            //{
            // var result = service.FindFolders(targetFolder.Id, new SearchFilter.IsEqualTo(FolderSchema.DisplayName, fragment), new FolderView(1));
            //}


            targetFolder.SetExtendedProperty(folderWebviewinfoProperty, EncodeUrl(url));
            targetFolder.Update();
            if (Option == "Reset")
            {
                targetFolder.RemoveExtendedProperty(folderWebviewinfoProperty);
                targetFolder.Update();

                //targetFolder.Update();
                Console.WriteLine("delete Outlook Homepage url ok");
            }
            else
            {
                Console.WriteLine("Set Outlook Homepage url ok");
            }
        }
示例#16
0
        static void DelaySendEmail(ExchangeService service)
        {
            // Create a new email message.
            EmailMessage message = new EmailMessage(service);

            // Specify the email recipient and subject.
            message.ToRecipients.Add("*****@*****.**");
            message.Subject = "Test subject";

            // Identify the extended property that can be used to specify when to send the email.
            ExtendedPropertyDefinition PR_DEFERRED_SEND_TIME = new ExtendedPropertyDefinition(16367, MapiPropertyType.SystemTime);

            // Set the time that will be used to specify when the email is sent.
            // In this example, the email will be sent 1 minute after the next line executes,
            // provided that the message.SendAndSaveCopy request is processed by the server within 1 minute.
            string sendTime = DateTime.Now.AddMinutes(1).ToUniversalTime().ToString();

            // Specify when to send the email by setting the value of the extended property.
            message.SetExtendedProperty(PR_DEFERRED_SEND_TIME, sendTime);

            // Specify the email body.
            StringBuilder str = new StringBuilder();

            str.AppendLine("Client submitted the message.SendAndSaveCopy request at: " + DateTime.Now.ToUniversalTime().ToString() + ";");
            str.AppendLine(" email message will be sent at: " + sendTime + ".");
            message.Body = str.ToString();

            Console.WriteLine("");
            Console.WriteLine("Client submitted the message.SendAndSaveCopy request at: " + DateTime.Now.ToUniversalTime().ToString() + ".");
            Console.WriteLine("Email message will be sent at: " + sendTime + ".");

            // Submit the request to send the email message.
            message.SendAndSaveCopy();
        }
        /// <summary>
        /// Provision a custom X-header in a mailbox database in Exchange 2007, or
        /// for a single mailbox in versions of Exchange starting with Exchange 2010, including Exchange Online.
        /// </summary>
        /// <remarks>
        /// This creates a mapping between the named property and the X-header. The
        /// first time an unmapped X-header is received in a mailbox or database,
        /// the mapping is created and the header is not saved. Subsequent messages
        /// that contain the X-header will have the X-header saved.
        /// </remarks>
        /// <param name="service">An ExchangeService object with credentials and the EWS URL.</param>
        private static void ProvisionCustomXHeader(ExchangeService service)
        {
            // Create a definition for an extended property that will represent a custom X-Header.
            ExtendedPropertyDefinition xExperimentalHeader = new ExtendedPropertyDefinition(DefaultExtendedPropertySet.InternetHeaders,
                                                                                            "X-Experimental",
                                                                                            MapiPropertyType.String);
            // Create an item that is used to provision the custom X-header.
            EmailMessage item = new EmailMessage(service);

            item.SetExtendedProperty(xExperimentalHeader, "Provision X-Experimental Internent message header");

            try
            {
                item.Save(WellKnownFolderName.MsgFolderRoot);

                if (service.ServerInfo.MajorVersion == 12)
                {
                    Console.WriteLine("Provisioned the X-Experimental across the mailbox database that hosts the user's mailbox.");
                }
                else // For all versions after Exchange 2007.
                {
                    Console.WriteLine("Provisioned the X-Experimental for the user's mailbox. You will need to run this " +
                                      "for each mailbox that needs to process this X-Header.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: {0}", ex.Message);
            }
        }
        /// <summary>
        /// Tries to read element from XML.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>True if element was read.</returns>
        internal override bool TryReadElementFromXml(EwsServiceXmlReader reader)
        {
            switch (reader.LocalName)
            {
                case XmlElementNames.ExtendedFieldURI:
                    this.propertyDefinition = new ExtendedPropertyDefinition();
                    this.propertyDefinition.LoadFromXml(reader);
                    return true;
                case XmlElementNames.Value:
                    EwsUtilities.Assert(
                        this.PropertyDefinition != null,
                        "ExtendedProperty.TryReadElementFromXml",
                        "PropertyDefintion is missing");

                    string stringValue = reader.ReadElementValue();
                    this.value = MapiTypeConverter.ConvertToValue(this.PropertyDefinition.MapiType, stringValue);
                    return true;
                case XmlElementNames.Values:
                    EwsUtilities.Assert(
                        this.PropertyDefinition != null,
                        "ExtendedProperty.TryReadElementFromXml",
                        "PropertyDefintion is missing");

                    StringList stringList = new StringList(XmlElementNames.Value);
                    stringList.LoadFromXml(reader, reader.LocalName);
                    this.value = MapiTypeConverter.ConvertToValue(this.PropertyDefinition.MapiType, stringList);
                    return true;
                default:
                    return false;
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="ExtendedProperty"/> class.
        /// </summary>
        /// <param name="propertyDefinition">The definition of the extended property.</param>
        internal ExtendedProperty(ExtendedPropertyDefinition propertyDefinition)
            : this()
        {
            EwsUtilities.ValidateParam(propertyDefinition, "propertyDefinition");

            this.propertyDefinition = propertyDefinition;
        }
 public static EwsStoreObjectPropertyDefinition CreateEwsPropertyDefinition(ExtendedPropertyDefinition definition, object defaultValue = null)
 {
     if (defaultValue == null && definition.Type.IsValueType)
     {
         defaultValue = Activator.CreateInstance(definition.Type);
     }
     return(new EwsStoreObjectPropertyDefinition(definition.Name, ExchangeObjectVersion.Exchange2012, definition.Type, PropertyDefinitionFlags.ReturnOnBind, defaultValue, defaultValue, definition));
 }
示例#21
0
 internal void SetExtendedPropertyDefinition(ExtendedPropertyDefinition prop)
 {
     if (prop == null)
     {
         throw new ArgumentNullException("prop");
     }
     _extendedPropertyDefinition = prop;
 }
示例#22
0
        static Dictionary <string, Folder> GetSharedCalendarFolders(ExchangeService service, String searchIn = "My Calendars")
        {
            Dictionary <String, Folder> rtList = new Dictionary <string, Folder>();

            FolderId           rfRootFolderid = new FolderId(WellKnownFolderName.Root);//, mbMailboxname
            FolderView         fvFolderView   = new FolderView(1000);
            SearchFilter       sfSearchFilter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "Common Views");
            FindFoldersResults ffoldres       = service.FindFolders(rfRootFolderid, sfSearchFilter, fvFolderView);

            if (ffoldres.Folders.Count == 1)
            {
                PropertySet psPropset = new PropertySet(BasePropertySet.FirstClassProperties);
                ExtendedPropertyDefinition PidTagWlinkAddressBookEID = new ExtendedPropertyDefinition(0x6854, MapiPropertyType.Binary);
                ExtendedPropertyDefinition PidTagWlinkFolderType     = new ExtendedPropertyDefinition(0x684F, MapiPropertyType.Binary);
                ExtendedPropertyDefinition PidTagWlinkGroupName      = new ExtendedPropertyDefinition(0x6851, MapiPropertyType.String);

                psPropset.Add(PidTagWlinkAddressBookEID);
                psPropset.Add(PidTagWlinkFolderType);
                ItemView iv = new ItemView(1000);
                iv.PropertySet = psPropset;
                iv.Traversal   = ItemTraversal.Associated;

                SearchFilter            cntSearch = new SearchFilter.IsEqualTo(PidTagWlinkGroupName, searchIn);
                FindItemsResults <Item> fiResults = ffoldres.Folders[0].FindItems(cntSearch, iv);
                foreach (Item itItem in fiResults.Items)
                {
                    try {
                        object GroupName           = null;
                        object WlinkAddressBookEID = null;
                        if (itItem.TryGetProperty(PidTagWlinkAddressBookEID, out WlinkAddressBookEID))
                        {
                            byte[] ssStoreID    = (byte[])WlinkAddressBookEID;
                            int    leLegDnStart = 0;
                            String lnLegDN      = "";
                            for (int ssArraynum = (ssStoreID.Length - 2); ssArraynum != 0; ssArraynum--)
                            {
                                if (ssStoreID[ssArraynum] == 0)
                                {
                                    leLegDnStart = ssArraynum;
                                    lnLegDN      = System.Text.Encoding.ASCII.GetString(ssStoreID, leLegDnStart + 1, (ssStoreID.Length - (leLegDnStart + 2)));
                                    ssArraynum   = 1;
                                }
                            }
                            NameResolutionCollection ncCol = service.ResolveName(lnLegDN, ResolveNameSearchLocation.DirectoryOnly, true);
                            if (ncCol.Count > 0)
                            {
                                FolderId SharedCalendarId    = new FolderId(WellKnownFolderName.Calendar, ncCol[0].Mailbox.Address);
                                Folder   SharedCalendaFolder = Folder.Bind(service, SharedCalendarId);
                                rtList.Add(ncCol[0].Mailbox.Address, SharedCalendaFolder);
                            }
                        }
                    } catch (Exception exception) {
                        Console.WriteLine(exception.Message);
                    }
                }
            }
            return(rtList);
        }
示例#23
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="name"></param>
 /// <param name="prop"></param>
 public EntityLookupField(string name, string nativeName, ExtendedPropertyDefinition prop)
     : base(name, nativeName, DbType.Int32, EntityFieldFlags.Nullable)
 {
     if (prop == null)
     {
         throw new ArgumentNullException("prop");
     }
     this.SetExtendedPropertyDefinition(prop);
 }
示例#24
0
        /// <summary>
        /// Launch form to get ExtendedPropertyDefinition information
        /// </summary>
        /// <param name="sender">The parameter is not used.</param>
        /// <param name="e">The parameter is not used.</param>
        private void BtnAddExtended_Click(object sender, EventArgs e)
        {
            ExtendedPropertyDefinition epd = null;

            if (ExtendedPropertyDialog.ShowDialog(ref epd) == DialogResult.OK)
            {
                this.AddPropertyToDisplayTable(epd);
            }
        }
示例#25
0
 private static void SetExtendedPropertyItemProperty(Item item, ExtendedPropertyDefinition storeProperty, object value)
 {
     if (value == null)
     {
         item.RemoveExtendedProperty(storeProperty);
         return;
     }
     item.SetExtendedProperty(storeProperty, value);
 }
示例#26
0
        public void Remove(ExtendedPropertyDefinition property)
        {
            if (!Contains(property))
            {
                return;
            }

            InnerList.RemoveAt(IndexOf(property));
        }
示例#27
0
        public static data.ScheduleData LoadResouceCallendar(string ResourceName)
        {
            ExchangeService service = ExchangeHelper.GetExchangeServiceConnection();

            SetExchangeServiceHttpHeader(service, "X-AnchorMailbox", MailBoxAddress);

            PropertySet psPropset = new PropertySet(BasePropertySet.FirstClassProperties);
            ExtendedPropertyDefinition PidTagWlinkAddressBookEID = new ExtendedPropertyDefinition(0x6854, MapiPropertyType.Binary);
            ExtendedPropertyDefinition PidTagWlinkFolderType     = new ExtendedPropertyDefinition(0x684F, MapiPropertyType.Binary);

            psPropset.Add(PidTagWlinkAddressBookEID);
            psPropset.Add(PidTagWlinkFolderType);

            NameResolutionCollection resolve = service.ResolveName(ResourceName, ResolveNameSearchLocation.DirectoryOnly, false, psPropset);

            FindItemsResults <Appointment> findResults = null;

            if (resolve.Count > 0)
            {
                try
                {
                    SetExchangeServiceHttpHeader(service, "X-AnchorMailbox", resolve[0].Mailbox.Address);
                    //  service.HttpHeaders.Add("X-AnchorMailbox", resolve[0].Mailbox.Address);
                    FolderId       SharedCalendarId = new FolderId(WellKnownFolderName.Calendar, resolve[0].Mailbox.Address);
                    CalendarFolder cf = CalendarFolder.Bind(service, SharedCalendarId);
                    findResults = LoadResouceCallendar(cf);
                }
                catch (Microsoft.Exchange.WebServices.Data.ServiceResponseException ex)
                {
                    Trace.TraceError("Error reading calendar for resource {0} ErrMsg: {1}", ResourceName, ex.Message);
                    throw ex;
                }
                //Folder SharedCalendaFolder = Folder.Bind(service, SharedCalendarId);
            }
            else
            {
                throw new ApplicationException(String.Format("Error resolving resource name in GAL: {0}", ResourceName));
            }



            if (findResults != null && findResults.TotalCount > 0)
            {
                service.LoadPropertiesForItems(from Item item in findResults select item,
                                               new PropertySet(BasePropertySet.IdOnly, AppointmentSchema.Start, AppointmentSchema.End,
                                                               AppointmentSchema.Location, AppointmentSchema.Subject, AppointmentSchema.Categories, OnlineMeetingExternalLink,
                                                               AppointmentSchema.IsAllDayEvent, AppointmentSchema.Sensitivity, AppointmentSchema.Organizer));
            }

            return(new data.ScheduleData {
                RoomId = ResourceName, Schedule = ConvertToSerializable(findResults, ResourceName)
            });

            /*  PropertySet props = new PropertySet();
             * CalendarFolder.Bind(service,WellKnownFolderName.Calendar,)*/
        }
        public static List <EmailBox> GetMailBox(string MailBoxType, int PageSize)
        {
            ItemView        view = new ItemView(PageSize);
            List <EmailBox> list = new List <EmailBox>();

            Guid SN_PropertySetId = Guid.NewGuid();
            ExtendedPropertyDefinition SN_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(SN_PropertySetId, "SN", MapiPropertyType.String);

            Guid Folio_PropertySetId = Guid.NewGuid();
            ExtendedPropertyDefinition Folio_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(Folio_PropertySetId, "Folio", MapiPropertyType.String);

            Guid ProcessInstanceId_PropertySetId = Guid.NewGuid();
            ExtendedPropertyDefinition ProcessInstanceId_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(ProcessInstanceId_PropertySetId, "ProcessInstanceId", MapiPropertyType.String);

            Guid BusinessKey_PropertySetId = Guid.NewGuid();
            ExtendedPropertyDefinition BusinessKey_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(BusinessKey_PropertySetId, "BusinessKey", MapiPropertyType.String);

            Guid ProcessTypeId_PropertySetId = Guid.NewGuid();
            ExtendedPropertyDefinition ProcessTypeId_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(ProcessTypeId_PropertySetId, "ProcessTypeId", MapiPropertyType.String);

            Guid   MessageId_PropertySetId = Guid.NewGuid();
            string MessageId = Guid.NewGuid().ToString();
            ExtendedPropertyDefinition MessageId_ExtendedPropertyDefinition = new ExtendedPropertyDefinition(MessageId_PropertySetId, "ProcessTypeId", MapiPropertyType.String);

            ExchangeService service = ConnectToExchange();

            view.PropertySet = new PropertySet(BasePropertySet.IdOnly, ItemSchema.Subject, SN_ExtendedPropertyDefinition, Folio_ExtendedPropertyDefinition, ProcessInstanceId_ExtendedPropertyDefinition, BusinessKey_ExtendedPropertyDefinition, ProcessTypeId_ExtendedPropertyDefinition, MessageId_ExtendedPropertyDefinition);

            FindItemsResults <Item> findResults = service.FindItems((MailBoxType == "Sent" ? WellKnownFolderName.SentItems : WellKnownFolderName.Inbox), view);

            foreach (Item email in findResults.Items)
            {
                Item mail = Item.Bind(service, email.Id);
                list.Add(new EmailBox
                {
                    MailBoxType       = MailBoxType,
                    Subject           = mail.Subject,
                    Body              = mail.Body,
                    Importance        = mail.Importance.ToString(),
                    Id                = mail.Id.ToString(),
                    Categories        = mail.Categories.ToString(),
                    DateTimeCreated   = mail.DateTimeCreated,
                    DateTimeReceived  = mail.DateTimeReceived,
                    DateTimeSent      = mail.DateTimeSent,
                    Cc                = mail.DisplayCc,
                    To                = mail.DisplayTo,
                    SN                = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[0].Value.ToString():string.Empty),
                    Folio             = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[1].Value.ToString(): string.Empty),
                    ProcessInstanceId = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[2].Value.ToString(): string.Empty),
                    BusinessKey       = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[3].Value.ToString(): string.Empty),
                    ProcessTypeId     = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[4].Value.ToString(): string.Empty),
                    MessageId         = (email.ExtendedProperties.Count > 0 ? email.ExtendedProperties[5].Value.ToString(): string.Empty)
                });
            }
            return(list);
        }
示例#29
0
        /// <summary>
        /// Return the type name for the given PropertyDefinitionBase, if an
        /// ExtendedPropertyDefinition use the same logic in
        /// GetPropertyType(ExtendedPropertyDefinition).  If a PropertyDefinition
        /// return the type FullName.
        /// </summary>
        /// <param name="exPropDef">Property defintion to examine</param>
        /// <returns>
        /// FullName of Type for a PropertyDefinition.  See the GetPropertyType()
        /// overloads for ExtendedPropertyDefinition format.
        /// </returns>
        public static string GetPropertyType(PropertyDefinitionBase propDef)
        {
            ExtendedPropertyDefinition exPropDef = propDef as ExtendedPropertyDefinition;

            if (exPropDef != null)
            {
                return(GetPropertyType(exPropDef));
            }

            return(propDef.GetType().Name);
        }
示例#30
0
        private void PropertyDefinitionControl_Leave(object sender, EventArgs e)
        {
            // If the current settings match a known property, select it in
            // the drop down list
            ExtendedPropertyDefinition propDef = this.ConvertFormToExtendedPropDef();

            if (propDef != null)
            {
                SetFormWithExtendedPropDef(propDef);
            }
        }
 public ExchangeProcessor()
 {
     MailBoxFolderPath = ConfigurationManager.AppSettings["appMailBoxLocation"];
     PropertySetId = "{C11FF724-AA03-4555-9952-8FA248A11C3E}";
     MailboxExtendedPropNameInbox = "doris_mailbox_id_inbox";
     MailboxExtendedPropNameSent = "doris_mailbox_id_sent";
     CalendarExtendedPropName = "doris_calendar_id";
     MailboxExtendedPropertyDefinitionInbox = new ExtendedPropertyDefinition(new Guid(PropertySetId), MailboxExtendedPropNameInbox, MapiPropertyType.String);
     MailboxExtendedPropertyDefinitionSent = new ExtendedPropertyDefinition(new Guid(PropertySetId), MailboxExtendedPropNameSent, MapiPropertyType.String);
     CalendarExtendedPropertyDefinition = new ExtendedPropertyDefinition(new Guid(PropertySetId), CalendarExtendedPropName, MapiPropertyType.String);
 }
示例#32
0
      private void mnuRemoveProperty_Click(object sender, EventArgs e)
      {
          if (this.PropertyListDataGridView.SelectedRows.Count != 1)
          {
              return;
          }

          DataRowView viewRow = this.PropertyListDataGridView.SelectedRows[0].DataBoundItem as DataRowView;

          // If there's no row then we can't find the property to remove
          if (viewRow == null)
          {
              return;
          }

          GridDataTables.PropertyListRow row = (GridDataTables.PropertyListRow)viewRow.Row;

          // Only extended properties can be removed
          ExtendedPropertyDefinition exPropDef = row.PropertyObject as ExtendedPropertyDefinition;

          if (exPropDef == null)
          {
              return;
          }

          try
          {
              this.Cursor = Cursors.WaitCursor;

              Item item = this.CurrentObject as Item;
              if (item != null)
              {
                  item.RemoveExtendedProperty(exPropDef);
                  item.Service.ClientRequestId = Guid.NewGuid().ToString();    // Set a new GUID.
                  item.Update(ConflictResolutionMode.AutoResolve);
              }
              else
              {
                  Folder folder = this.CurrentObject as Folder;
                  if (folder != null)
                  {
                      return;
                  }

                  folder.RemoveExtendedProperty(exPropDef);
                  folder.Service.ClientRequestId = Guid.NewGuid().ToString();    // Set a new GUID.
                  folder.Update();
              }
          }
          finally
          {
              this.Cursor = Cursors.Default;
          }
      }
        /// <summary>
        /// Find folders with extended filter.
        /// </summary>
        /// <param name="exchangeService"></param>
        /// <returns></returns>
        public static async Task FindFoldersWithExtendedFilter(ExchangeService exchangeService)
        {
            MailFolderView folderView = new MailFolderView();

            folderView.PropertySet.Add(MailFolderObjectSchema.TotalItemCount);
            ExtendedPropertyDefinition extendedPropertyDefinition1 = new ExtendedPropertyDefinition(MapiPropertyType.Integer, 0x0FFE);

            folderView.PropertySet.Add(extendedPropertyDefinition1);
            SearchFilter          searchfilter          = new SearchFilter.IsEqualTo(MailFolderObjectSchema.DisplayName, "Inbox");
            FindMailFolderResults findMailFolderResults = await exchangeService.FindFolders("MsgFolderRoot", searchfilter, folderView);
        }
        protected override void ProcessRecord()
        {
            ExtendedPropertyDefinition extendedProperty;

            switch (this.ParameterSetName)
            {
                case "DefaultExtendedProperty":
                    extendedProperty = new ExtendedPropertyDefinition(this.DefaultExtendedProperty, this.PropertyId, this.MapiProperty);
                    break;

                default:
                    extendedProperty = new ExtendedPropertyDefinition(this.PropertyId, this.MapiProperty);
                    break;
            }

            this.WriteObject(extendedProperty);
        }
 /// <summary>
 /// Tries to load from XML.
 /// </summary>
 /// <param name="reader">The reader.</param>
 /// <param name="propertyDefinition">The property definition.</param>
 /// <returns>True if property was loaded.</returns>
 internal static bool TryLoadFromXml(EwsServiceXmlReader reader, ref PropertyDefinitionBase propertyDefinition)
 {
     switch (reader.LocalName)
     {
         case XmlElementNames.FieldURI:
             propertyDefinition = ServiceObjectSchema.FindPropertyDefinition(reader.ReadAttributeValue(XmlAttributeNames.FieldURI));
             reader.SkipCurrentElement();
             return true;
         case XmlElementNames.IndexedFieldURI:
             propertyDefinition = new IndexedPropertyDefinition(
                 reader.ReadAttributeValue(XmlAttributeNames.FieldURI),
                 reader.ReadAttributeValue(XmlAttributeNames.FieldIndex));
             reader.SkipCurrentElement();
             return true;
         case XmlElementNames.ExtendedFieldURI:
             propertyDefinition = new ExtendedPropertyDefinition();
             (propertyDefinition as ExtendedPropertyDefinition).LoadFromXml(reader);
             return true;
         default:
             return false;
     }
 }
示例#36
0
        private void btnUploadConv_Click(object sender, EventArgs e)
        {
            FSWatch.EnableRaisingEvents = false;
            ImportProgressDialog ipd = new ImportProgressDialog();
            AddOwnedForm(ipd);
            //ipd.Parent = this;

            //if (listFiles.SelectedItems.Count != 0)
            //{
            ipd.Show();
            int FileCounter = 0;
            String[] FileList = Directory.GetFiles(HistorySpoolerPath);
            int FileCount = FileList.Count();

            ipd.prgImportProgress.Maximum = FileCount;

            foreach (String HistFile in FileList)
            {
                FileCounter++;

                FileInfo fi = new FileInfo(HistFile);

                ipd.prgImportProgress.Value = FileCounter;
                ipd.lblProgress.Text = String.Format("Processing file {0} of {1}...", FileCounter, FileCount);
                ipd.lblStatus.Text = String.Format("Uploading {0} ({1} bytes)...", fi.Name, fi.Length);

                if (_exchangeService == null)
                {
                    _exchangeService = new ExchangeService();

                    var store = new X509Store(StoreLocation.CurrentUser);
                    store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadOnly);
                    X509Certificate2Collection certs = store.Certificates.Find(X509FindType.FindByExtension, "2.5.29.37", true);
                    _exchangeService.Url = new Uri("https://autodiscover.mail.mil/EWS/Exchange.asmx");

                    X509Certificate2Collection scollection = X509Certificate2UI.SelectFromCollection(certs, "DEE Certificate Select", "Select a certificate to connect to DISA E-mail", X509SelectionFlag.SingleSelection);

                    _exchangeService.Credentials = new ClientCertificateCredentials(scollection);
                }

                if (_imHistoryFolder == null)
                {
                    _imHistoryFolder = FindImHistoryFolder();
                }

                LyncHistoryFile lhf = new LyncHistoryFile();
                lhf.ReadFromFile(fi.FullName);
                //lhf.ReadFromFile(((FileInfo)listFiles.SelectedItems[0].Tag).FullName);

                EmailMessage ConversationItem = new EmailMessage(_exchangeService);

                //ConversationItem.MimeContent = new MimeContent("UTF-8",File.ReadAllBytes(((FileInfo)listFiles.SelectedItems[0].Tag).FullName));

                foreach(var Member in lhf._Guts.Members)
                {
                    ConversationItem.ToRecipients.Add(new EmailAddress(Member.SIPAddress));
                }

                ConversationItem.Body = lhf._Guts.HTML1;
                ConversationItem.Subject = lhf._Guts.Title;
                ConversationItem.From = new EmailAddress(lhf._Guts.Initiator.SIPAddress);

                ExtendedPropertyDefinition PR_MESSAGE_FLAGS_msgflag_read = new ExtendedPropertyDefinition(3591, MapiPropertyType.Integer);
                //ExtendedPropertyDefinition PR_RECEIPT_TIME = new ExtendedPropertyDefinition(0x002A, MapiPropertyType.SystemTime);
                ConversationItem.SetExtendedProperty(PR_MESSAGE_FLAGS_msgflag_read, 1);
                //ConversationItem.SetExtendedProperty(PR_RECEIPT_TIME, ((FileInfo)listFiles.SelectedItems[0].Tag).CreationTime);

                ConversationItem.Save(_imHistoryFolder.Id);

                if (btnLocalCopies.Checked)
                {
                    if (!Directory.Exists(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Documents\\LyncArchive\\"))
                    {
                        Directory.CreateDirectory(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Documents\\LyncArchive\\");
                    }
                    try
                    {
                        File.Move(HistFile, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Documents\\LyncArchive\\" + fi.Name);
                    }
                    catch
                    {
                        File.Delete(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Documents\\LyncArchive\\" + fi.Name);
                        File.Move(HistFile, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Documents\\LyncArchive\\" + fi.Name);
                    }
                }
                else
                {
                    File.Delete(HistFile);
                }
                //LoadConversation(((FileInfo)listFiles.SelectedItems[0].Tag).FullName);
            }

            ipd.Close();

            UpdateFileList();
            HTMLViewer.DocumentText = "";

            FSWatch.EnableRaisingEvents = true;
        }
示例#37
0
        static Microsoft.Exchange.WebServices.Data.FolderId exchCreateFolder(ExchangeService service, string fldrDisplayName, Microsoft.Exchange.WebServices.Data.FolderId fldrParentID, ExtendedPropertyDefinition fldrRetentionPolicyTag, System.Guid fldrRetentionPolicyGUID, ExtendedPropertyDefinition fldrRetentionFlagTag, int fldrRetentionFlagValue)
        {
            // Verify that the paramters passed in are valid
            if (fldrDisplayName.Length == 0)
            {
                Console.WriteLine("\tError in exchCreateFolder : Invalid Folder Name");
                return null;
            }

            //Generate process output
            Console.Write("\tCreating Folder : " + fldrDisplayName + "...");

            if (service == null)
            {
                Console.WriteLine("error:Exchange Service reference Invalid");
                return null;
            }
            if (fldrParentID == null)
            {
                Console.WriteLine("error:Invalid Parent Folder");
                return null;
            }
            //if (fldrRetentionPolicyTag == null)
            //{
            //    Console.WriteLine("\t\tError in exchCreateFolder : Invalid Retention Policy Tag");
            //    return null;
            //}
            //if (fldrRetentionPolicyGUID == null)
            //{
            //    Console.WriteLine("\tError in exchCreateFolder : Invalid Retention Policy GUID");
            //    return null;
            //}

            //if (fldrRetentionFlagTag == null)
            //{
            //    Console.WriteLine("\t\tError in exchCreateFolder : Invalid Retention Policy Flag Tag");
            //    return null;
            //}

            //if (fldrRetentionFlagValue < 1)
            //{
            //    Console.WriteLine("\t\tError in exchCreateFolder : Invalid Retention Policy Flag Value");
            //    return null;
            //}

            //We have all of the inforamtion we need to make folders, create folder and assign retention policy.

            // Create Folder instance
            Folder newFolder = new Folder(service);

            try
            {
                // Assign attributes to folder and save it to exchange server
                newFolder.DisplayName = fldrDisplayName;
                if (fldrRetentionPolicyTag != null)
                {
                    Console.Write("Applying Retention Policy Tag..");
                    newFolder.SetExtendedProperty(fldrRetentionPolicyTag, fldrRetentionPolicyGUID.ToByteArray());
                    newFolder.SetExtendedProperty(fldrRetentionFlagTag, fldrRetentionFlagValue);

                }
                newFolder.Save(fldrParentID);

            }
            catch (Exception ex)
            {
                Console.WriteLine("Error : " + ex.Message);
                return null;

            }

            Console.WriteLine("success.");
            //Return the folder id reference
            return newFolder.Id;
        }
        public ActionResult MessageEWS(EmailAddress email)
        {
            ExchangeService service = Connection.ConnectEWS();

            //Create empty list for all mailbox messages:
            var listing = new List<EmailMessage>();

            //Create ItemView with correct pagesize and offset:
            ItemView view = new ItemView(Connection.ExPageSize, Connection.ExOffset, OffsetBasePoint.Beginning);

            view.PropertySet = new PropertySet(BasePropertySet.FirstClassProperties,
                EmailMessageSchema.Subject,
                EmailMessageSchema.DateTimeReceived,
                EmailMessageSchema.From,
                EmailMessageSchema.ToRecipients);

            view.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Descending);

            //string sf = "Body:\"Compensation\"";

            //Define the new PidTagParentDisplay property to use for filtering:
            ExtendedPropertyDefinition def = new ExtendedPropertyDefinition(0x0E05, MapiPropertyType.String);
            SearchFilter searchCriteria = new SearchFilter.IsEqualTo(def, email.Address);
            FindItemsResults<Item> findResults = service.FindItems(WellKnownFolderName.Inbox, searchCriteria, view);

            foreach (EmailMessage it in findResults.Items)
            {
                listing.Add(it);
            }

            return View(listing.ToList<EmailMessage>());
        }
示例#39
0
 /// <summary>
 /// Removes an extended property.
 /// </summary>
 /// <param name="extendedPropertyDefinition">The extended property definition.</param>
 /// <returns>True if property was removed.</returns>
 public bool RemoveExtendedProperty(ExtendedPropertyDefinition extendedPropertyDefinition)
 {
     return this.ExtendedProperties.RemoveExtendedProperty(extendedPropertyDefinition);
 }
示例#40
0
 /// <summary>
 /// Sets the extended property.
 /// </summary>
 /// <param name="extendedPropertyDefinition">The extended property definition.</param>
 /// <param name="value">The value.</param>
 public void SetExtendedProperty(ExtendedPropertyDefinition extendedPropertyDefinition, object value)
 {
     this.ExtendedProperties.SetExtendedProperty(extendedPropertyDefinition, value);
 }
        public static FindItemsResults<Item> GetCMessages(ExchangeService service, Folder targetFolder, string[] email, int start, int length, string datefromS, string datetoS, string toS, string fromS, string subjectS, string bodyS, string dateFilter, string fromFilter, string subjectFilter)
        {
            //Create empty list for all mailbox messages:
            var listing = new List<EmailMessage>();

            Folder gsf = gsf = GetGlobalFolder(service);
            FindItemsResults<Item> findResults = null;

            //Create ItemView with correct pagesize and offset:
            ItemView view = new ItemView(length, start, OffsetBasePoint.Beginning);

            view.PropertySet = new PropertySet(EmailMessageSchema.Id,
                EmailMessageSchema.Subject,
                EmailMessageSchema.DateTimeReceived,
                EmailMessageSchema.From
                );
            view.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Descending);

            //Define the new PidTagParentDisplay property to use for filtering:
            ExtendedPropertyDefinition def = new ExtendedPropertyDefinition(0x0E05, MapiPropertyType.String);

            List<SearchFilter> searchANDFilterCollection = new List<SearchFilter>();
            List<SearchFilter> searchORcommCollection = new List<SearchFilter>();
            List<SearchFilter> searchCompCollection = new List<SearchFilter>();

            //Add "OR" commissioner search criteria:
            if (email != null && email.Count() > 0)
            {
                foreach (var target in email)
                {
                    string t = target;
                    if (target.Contains('@'))
                    {
                        t = target.Split('@')[0];
                    }

                    searchORcommCollection.Add(new SearchFilter.ContainsSubstring(def, t.ToLower()));
                    logger.Debug("Added mailbox to searchOR collection: " + target);
                }
            }

            if (searchORcommCollection.Count > 0)
            {
                SearchFilter searchOrFilter = new SearchFilter.SearchFilterCollection(LogicalOperator.Or, searchORcommCollection.ToArray());
                searchCompCollection.Add(searchOrFilter);
            }

            //Populate fields from the SEARCH form (not the filters, just the search):

            if (!string.IsNullOrWhiteSpace(datefromS))
            {
                DateTime dFrom = DateTime.Parse(datefromS + " 12:00AM");
                logger.Debug("datefromS -- " + dFrom.ToString());

                searchANDFilterCollection.Add(new SearchFilter.IsGreaterThanOrEqualTo(EmailMessageSchema.DateTimeReceived, dFrom));
            }

            if (!string.IsNullOrWhiteSpace(datetoS))
            {
                DateTime dTo = DateTime.Parse(datetoS + " 11:59PM");
                logger.Debug("datetoS -- " + dTo.ToString());
                searchANDFilterCollection.Add(new SearchFilter.IsLessThanOrEqualTo(EmailMessageSchema.DateTimeReceived, dTo));
            }

            if (!string.IsNullOrWhiteSpace(fromS))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.From, fromS));
            }

            if (!string.IsNullOrWhiteSpace(toS))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.DisplayTo, toS));
            }

            if (!string.IsNullOrWhiteSpace(subjectS))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.Subject, subjectS));
            }

            if (!string.IsNullOrWhiteSpace(bodyS))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.Body, bodyS));
            }

            //Populate fields from Datatables FILTER form (this supplements the SEARCH form):

            if (!string.IsNullOrWhiteSpace(dateFilter))
            {
                string[] dates = dateFilter.Split('~');

                if (!string.IsNullOrWhiteSpace(dates[0]))
                {
                    DateTime dfFrom = DateTime.Parse(dates[0] + " 12:00AM");
                    logger.Debug("dfFrom -- " + dfFrom.ToString());
                    searchANDFilterCollection.Add(new SearchFilter.IsGreaterThanOrEqualTo(EmailMessageSchema.DateTimeReceived, dfFrom));
                }

                if (!string.IsNullOrWhiteSpace(dates[1]))
                {
                    DateTime dfTo = DateTime.Parse(dates[1] + " 11:59PM");
                    logger.Debug("dfTo -- " + dfTo.ToString());
                    searchANDFilterCollection.Add(new SearchFilter.IsLessThanOrEqualTo(EmailMessageSchema.DateTimeReceived, dfTo));
                }
            }

            if (!string.IsNullOrWhiteSpace(fromFilter))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.From, fromFilter));
            }

            if (!string.IsNullOrWhiteSpace(subjectFilter))
            {
                searchANDFilterCollection.Add(new SearchFilter.ContainsSubstring(EmailMessageSchema.Subject, subjectFilter));
            }

            //Assemble the SearchFilter Collection

            if (searchANDFilterCollection.Count > 0)
            {
                SearchFilter searchANDFilter = new SearchFilter.SearchFilterCollection(LogicalOperator.And, searchANDFilterCollection.ToArray());
                searchCompCollection.Add(searchANDFilter);
            }

            //Evaluate filters and execute find results:

            if (searchORcommCollection.Count > 0 || searchANDFilterCollection.Count > 0)
            {
                SearchFilter searchComp = new SearchFilter.SearchFilterCollection(LogicalOperator.And, searchCompCollection.ToArray());
                findResults = service.FindItems(targetFolder.Id, searchComp, view);
            }
            else
            {
                findResults = service.FindItems(targetFolder.Id, view);
            }

            logger.Debug("FindResults Count = " + findResults.TotalCount);

            return findResults;
        }
示例#42
0
        public void ExtendedPropertyCanBeRegistered()
        {
            var tc = new TestContainer();

            var pd = new ExtendedPropertyDefinition<int>("Grid", "Row", () => 0);

            var p = tc.ExtendedProperties.GetOrAddProperty<int>(pd);
            
            tc.ExtendedProperties["Grid.Row"].Value = 3;

            Assert.AreEqual(3, tc.ExtendedProperties["Grid.Row"].ActualValue);
        }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="baseShape">Preview item base shape</param>
 /// <param name="additionalProperties">Additional properties (must be in form of extended properties)</param>
 public PreviewItemResponseShape(PreviewItemBaseShape baseShape, ExtendedPropertyDefinition[] additionalProperties)
 {
     this.BaseShape = baseShape;
     this.AdditionalProperties = additionalProperties;
 }
        /// <summary>
        /// Parses the message XML.
        /// </summary>
        /// <param name="reader">The reader.</param>
        private void ParseMessageXml(EwsServiceXmlReader reader)
        {
            do
            {
                reader.Read();

                if (reader.IsStartElement())
                {
                    switch (reader.LocalName)
                    {
                        case XmlElementNames.Value:
                            this.errorDetails.Add(reader.ReadAttributeValue(XmlAttributeNames.Name), reader.ReadElementValue());
                            break;

                        case XmlElementNames.FieldURI:
                            this.errorProperties.Add(ServiceObjectSchema.FindPropertyDefinition(reader.ReadAttributeValue(XmlAttributeNames.FieldURI)));
                            break;

                        case XmlElementNames.IndexedFieldURI:
                            this.errorProperties.Add(
                                new IndexedPropertyDefinition(
                                    reader.ReadAttributeValue(XmlAttributeNames.FieldURI),
                                    reader.ReadAttributeValue(XmlAttributeNames.FieldIndex)));
                            break;

                        case XmlElementNames.ExtendedFieldURI:
                            ExtendedPropertyDefinition extendedPropDef = new ExtendedPropertyDefinition();
                            extendedPropDef.LoadFromXml(reader);
                            this.errorProperties.Add(extendedPropDef);
                            break;

                        default:
                            break;
                    }
                }
            }
            while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.MessageXml));
        }
示例#45
0
        public List<EWSCalendar> GetCalendarsAsync(int maxFoldersToRetrive, Dictionary<string, object> calendarSpecificData)
        {
            CheckCalendarSpecificData(calendarSpecificData);
            var serverSettings = GetBestSuitedExchangeServerData(ExchangeServerSettings.Domain,
                ExchangeServerSettings.EmailId, ExchangeServerSettings.Password,
                ExchangeServerSettings.UsingCorporateNetwork);
            var service = GetExchangeService(serverSettings);

            // Create a new folder view, and pass in the maximum number of folders to return.
            var view = new FolderView(1000);

            // Create an extended property definition for the PR_ATTR_HIDDEN property,
            // so that your results will indicate whether the folder is a hidden folder.
            var isHiddenProp = new ExtendedPropertyDefinition(0x10f4, MapiPropertyType.Boolean);

            // As a best practice, limit the properties returned to only those required.
            // In this case, return the folder ID, DisplayName, and the value of the isHiddenProp
            // extended property.
            view.PropertySet = new PropertySet(BasePropertySet.FirstClassProperties, FolderSchema.DisplayName,
                isHiddenProp);

            // Indicate a Traversal value of Deep, so that all subfolders are retrieved.
            view.Traversal = FolderTraversal.Deep;

            // Call FindFolders to retrieve the folder hierarchy, starting with the MsgFolderRoot folder.
            // This method call results in a FindFolder call to EWS.
            var findFolderResults = service.FindFolders(WellKnownFolderName.MsgFolderRoot, view);

            var ewsCalendars = new List<EWSCalendar>();
            foreach (var searchFolder in findFolderResults.Folders)
            {
                GetCalendars(searchFolder, ewsCalendars, view);
            }
            return ewsCalendars;
        }