Esempio n. 1
0
        /// <summary>
        /// Bekommt eine Liste von Matchings und übersetzt sie in XML Elemente. Speichert danach die Datei unter dem übergebenen Pfad.
        /// </summary>
        /// <param name="path">Der Pfad in dem die XML Datei gespeichert werden soll.</param>
        /// <param name="list">Die Liste an Matchings die gespeichert werden soll</param>
        public static void saveToXml(string path, List <Matching> list)
        {
            try
            {
                //WRITE XML
                var doc = new XDocument();

                //doc.Add(new XElement("MatchingList", list.Select(x => new XElement("MatchingEntry",
                //        new XAttribute("Subject", x.Subject),
                //        new XElement("PublicId", x.PublicId),
                //        new XElement("MailboxId", x.MailboxId)))));

                XElement xml = new XElement("MatchingList",
                                            from p in list
                                            select new XElement("MatchingEntry",
                                                                new XElement("Subject", p.Subject),
                                                                new XElement("PublicId", p.PublicId),
                                                                new XElement("MailboxId", p.MailboxId)));

                doc.Add(xml);
                doc.Save(path);
            }
            catch (Exception ex)
            {
                //Console.WriteLine("XMLReader.cs - 38: "+ex.Message);
                ExchangeSync.writeLog("XMLReader.cs - 38: " + ex.Message);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Config Datei wird eingelesen und für für jedes Postfach werden die Jahrestage und Geburtstage überprüft und syncroniesiert.
        /// Danach werden die Kontakte Syncronisiert.
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Config config = ReadConfig();

            ExchangeSync.writeLog("##################################################################");

            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            foreach (var m in config.mailboxes)
            {
                ExchangeSync.writeLog("---------- " + m.smtpAdresse.ToUpper() + " ----------");
                ExchangeService service = ExchangeConnect(config.username, config.password, config.domain, m.smtpAdresse, config.exUri);

                if (m.birthday || m.anniversary)
                {
                    ExchangeSync.writeLog("---------- SyncRun Start - Appointment ----------");
                    Stopwatch sWatch = new Stopwatch();
                    sWatch.Start();

                    var BASync = new AppointmentSync(service, m.smtpAdresse);

                    // Aktiviren wenn alle Termine gelöscht werden sollen
                    //BASync.runDelete();

                    if (m.birthday)
                    {
                        BASync.runBirthdaySync();
                    }
                    if (m.anniversary)
                    {
                        BASync.runAnniversarySync();
                    }

                    sWatch.Stop();
                    ExchangeSync.writeLog("---------- SyncRun End - " + stopWatch.Elapsed + " ----------");
                }

                if (m.folder.Count > 0 && m.folder[0] != "")
                {
                    foreach (var f in m.folder)
                    {
                        var SyncRun = new ExchangeSync(service, m.smtpAdresse, f);
                        SyncRun.writePublicIdInExProp();
                        bool changes = SyncRun.Sync();

                        if (changes)
                        {
                            MatchingList.Create(service, m.smtpAdresse, f);
                            ExchangeSync.writeLog("Matching List created: " + m.smtpAdresse + " - " + f);
                        }
                    }
                }
            }

            stopWatch.Stop();
            ExchangeSync.writeLog("Complete Sync - Time: " + stopWatch.Elapsed);
        }
Esempio n. 3
0
        /// <summary>
        /// Eine XML Datei wird eingelesen und in Matchings übersetzt.
        /// </summary>
        /// <param name="path">Der Pfad der XML Datei die eingelesen werden soll.</param>
        /// <returns>Eine Liste von Matchings</returns>
        public static List <Matching> readFromXml(string path)
        {
            List <Matching> _list = null;

            try
            {
                _list = (
                    from e in XDocument.Load(path).Root.Elements("MatchingEntry")
                    select new Matching
                {
                    MailboxId = (string)e.Element("MailboxId"),
                    PublicId = (string)e.Element("PublicId"),
                    Subject = (string)e.Element("Subject")
                }
                    ).ToList();
            }
            catch (Exception ex)
            {
                //Console.WriteLine("ERROR: " + ex.Message);
                ExchangeSync.writeLog("XMLReader.cs - 62: " + ex.Message);
            }

            return(_list);
        }
Esempio n. 4
0
        /// <summary>
        /// Bindet sich den öffentlichen Ordner uns startet eine Schleife über alle internen Kontakte ("Arges Intern").
        /// Danach wird der Geburtstag oder Jahrestag auf NULL überprüft (ist NULL zb. bei Meetingraum) und ausgelesen.
        /// Ist ein Geburtstag oder Jahrestag da, wird nun das Alter berechnet.
        /// <h3>DIESES JAHR</h3>
        /// <ul>
        ///     <li>Erstellt neuen Termin</li>
        ///     <li>Setzt die Eigenschaften für den Termin (zb. Subject, Start, Ende, AllDayEvent...)</li>
        ///     <li>Fpgt die Kategorie "autogenerated by Arges IT" hinzu</li>
        ///     <li>Prüft ob der Termin in der übergebenen Liste schon vorhanden ist</li>
        ///     <li>Fügt den Termin zum Kalender falls er noch nicht vorhanden ist und der Start >= Heute ist</li>
        /// </ul>
        /// <h3>NÄCHSTES JAHR</h3>
        /// Wiederholt die Schritte von diesem Jahr nur mit age+1
        /// </summary>
        /// <param name="mailboxList">Liste mit allen Terminen die aus getMailboxAppointments() zurück kommen</param>
        /// <param name="BirthdayOrAnniversary">0 => Geburtstag  1 => Jahrestag</param>
        void addAppointment(List <string> mailboxList, int BirthdayOrAnniversary) // 0 => Geburtstag  1 => Jahrestag
        {
            var PublicRoot = Folder.Bind(service, WellKnownFolderName.PublicFoldersRoot);

            SearchFilter.IsEqualTo filter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, ContactFolderName);
            FindFoldersResults     FindPublicContactFolder = service.FindFolders(PublicRoot.Id, filter, new FolderView(1));
            var ContactFolder = FindPublicContactFolder.Folders[0];

            ItemView view = new ItemView(int.MaxValue);
            FindItemsResults <Item> findResults;

            var count = 0;

            do
            {
                findResults = service.FindItems(ContactFolder.Id, view);

                // Läuft über alle Kontakte im PublicFolder
                foreach (Item item in findResults.Items)
                {
                    //Prüft ob Birthday / Jahrestag ungleich NULL ist (zb bei Kontakt Meetingraum)
                    DateTime BirthDayValue = new DateTime();
                    bool     check         = BirthdayOrAnniversary == 0 ? check = item.TryGetProperty(ContactSchema.Birthday, out BirthDayValue) : check = item.TryGetProperty(ContactSchema.WeddingAnniversary, out BirthDayValue);

                    if (check)
                    {
                        //Berechne Geburtsdatum und Alter
                        int age = DateTime.Now.Year - BirthDayValue.Year;
                        BirthDayValue = BirthDayValue.AddYears(age);
                        //if (DateTime.Now.CompareTo(BirthDayValue) < 0) { age--; }


                        // #### DIESES JAHR

                        // Erstelle Appointment Objekt
                        Appointment appo = new Appointment(service);

                        //Setze Appointment Eigenschaften
                        appo.Subject              = BirthdayOrAnniversary == 0 ? age + ". Geburtstag von " + item.Subject : age + ". Jahrestag von " + item.Subject;
                        appo.Start                = BirthDayValue;
                        appo.End                  = appo.Start.AddHours(1);
                        appo.IsAllDayEvent        = true;
                        appo.IsReminderSet        = false;
                        appo.LegacyFreeBusyStatus = 0;

                        // Setze Categorie an der Objekte erkannt werden, die hier mit diesem Script erstellt worden sind
                        appo.Categories.Add("autogenerated by Arges IT");

                        // Prüft ob Appointment schon vorhanden ist
                        var match = mailboxList.FirstOrDefault(stringToCheck => stringToCheck.Contains(appo.Subject));
                        if (match == null && appo.Start >= DateTime.Now)
                        {
                            count++;
                            appo.Save();
                        }
                        else
                        {
                            mailboxList.Remove(appo.Subject);
                        }

                        // #### NÄCHSTES JAHR

                        // Erstelle Appointment Objekt
                        appo = new Appointment(service);

                        //Setze Appointment Eigenschaften
                        appo.Subject              = BirthdayOrAnniversary == 0 ? age + 1 + ". Geburtstag von " + item.Subject : age + 1 + ". Jahrestag von " + item.Subject;
                        appo.Start                = BirthDayValue.AddYears(1);
                        appo.End                  = appo.Start.AddHours(1);
                        appo.IsAllDayEvent        = true;
                        appo.IsReminderSet        = false;
                        appo.LegacyFreeBusyStatus = 0;

                        // Setze Categorie an der Objekte erkannt werden, die hier mit diesem Script erstellt worden sind
                        appo.Categories.Add("autogenerated by Arges IT");

                        // Prüft ob Appointment schon vorhanden ist
                        match = mailboxList.FirstOrDefault(stringToCheck => stringToCheck.Contains(appo.Subject));
                        if (match == null && appo.Start >= DateTime.Now)
                        {
                            count++;
                            appo.Save();
                        }
                        else
                        {
                            mailboxList.Remove(appo.Subject);
                        }
                    }
                }

                view.Offset += findResults.Items.Count;
            } while (findResults.MoreAvailable == true);

            var e = BirthdayOrAnniversary == 0 ? " Geburtstage" : " Jahrestag";

            if (mailboxList.Count > 0)
            {
                foreach (var subject in mailboxList)
                {
                    deleteBySubject(subject);
                }
                ExchangeSync.writeLog(SMTPAdresse + " - " + mailboxList.Count + e + " gelöscht");
            }
            if (count > 0)
            {
                ExchangeSync.writeLog(SMTPAdresse + " - " + count + e + " hinzugefügt");
            }
            else
            {
                ExchangeSync.writeLog(SMTPAdresse + " - Keine" + e + " hinzugefügt");
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Durchsucht alle Termine der nächsten zwei Jahre nach der übergebenen Kategorie + " - Arges Intern" oder " - Arges Kontakte" und löscht diese.
        /// </summary>
        /// <param name="cat">Der name der Kategorie</param>
        public void deleteWithCategorie(string cat)
        {
            // Initialize values for the start and end times, and the number of appointments to retrieve.
            DateTime startDate = DateTime.Now;
            DateTime endDate   = startDate.AddYears(2);
            // Initialize the calendar folder object with only the folder ID.
            CalendarFolder calendar = CalendarFolder.Bind(service, WellKnownFolderName.Calendar, new PropertySet());
            // Set the start and end time and number of appointments to retrieve.
            CalendarView cView = new CalendarView(startDate, endDate, 500);

            // Limit the properties returned to the appointment's subject, start time, and end time.
            cView.PropertySet = new PropertySet(AppointmentSchema.Subject, AppointmentSchema.Start, AppointmentSchema.End, AppointmentSchema.Categories);

            FindItemsResults <Appointment> appointments;
            var total = 0;
            var tDel  = 0;

            do
            {
                appointments = calendar.FindAppointments(cView);

                //Läuft über alle Kalendereinträge
                foreach (Appointment a in appointments)
                {
                    //Prüft ob Kalendereintrag ein Categorie enthält
                    if (a.Categories.Contains(cat + " - Arges Intern") || a.Categories.Contains(cat + " - Arges Kontakte"))
                    {
                        a.Delete(DeleteMode.HardDelete);
                        tDel++;
                    }
                }

                cView.StartDate = appointments.Items[appointments.Items.Count - 1].Start;
                total          += appointments.Items.Count;
            } while (appointments.MoreAvailable);
            ExchangeSync.writeLog(SMTPAdresse + " - " + total + " Termine gefunder, " + tDel + " mit Kategorie \"" + cat + "\" gefunden");



            //int pageSize = 500;
            //int offset = 0;

            //ItemView _cView = new ItemView(pageSize + 1, offset);
            //FolderId _folderID = new FolderId(WellKnownFolderName.Calendar);
            //CalendarFolder _calendar = CalendarFolder.Bind(service, _folderID);

            //_cView.PropertySet = new PropertySet(AppointmentSchema.Subject, AppointmentSchema.Start, AppointmentSchema.End, AppointmentSchema.Categories);

            //var moreItems = true;
            //var index = 0;
            //while (moreItems)
            //{
            //    var result = _calendar.FindItems(_cView);
            //    moreItems = result.MoreAvailable;

            //    foreach (var item in result)
            //    {
            //        index++;
            //        Console.WriteLine(index + " - " + item.Subject);
            //        if (item.Categories.Contains(cat + " - Arges Intern") || item.Categories.Contains(cat + " - Arges Kontakte"))
            //        {
            //            item.Delete(DeleteMode.HardDelete);

            //        }
            //    }

            //    if (moreItems)
            //    {
            //        _cView.Offset += pageSize;
            //    }
            //}
        }