# Sincronizando eventos entre contas do Outlook usando Python

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1700320003168/8313d219-c25b-4da4-a88a-6ea97f55fd0a.png)

Olá pessoal! Neste texto eu vou demonstrar uma forma de criar um script em Python para sincronizar eventos entre duas contas do Outlook usando a lib [PyExchange](https://github.com/linkedin/pyexchange).

O código completo pode ser baixado [aqui](https://github.com/RafaelSermenho/outlookSync/tree/master).

A primeira coisa a ser feita é instalar o PyExchange e para isso vamos utilizar o [pip](https://pypi.python.org/pypi/pip):

```
pip install pyexchange
```

O próximo passo é começar o script importando os módulos que serão necessários:

from datetime import datetime  
from pytz import timezone  
from pyexchange import Exchange2010Service, ExchangeNTLMAuthConnection

Então, devemos configurar os dados da conta de origem:

originURL = u'https://nomeDoServidor.outlook.com/EWS/Exchange.asmx'  
originUsername = u'nomeDoUsuario'  
originPassword = u"passwordDoUsuario"

Note que na URL sempre devemos incluir o sufixo “**/EWS/Exchange.asmx**”.

Após definir os dados da conta, podemos configurar a conexão e iniciar o serviço usando a lib PyExchange:

originConnection = ExchangeNTLMAuthConnection(url=originURL, username=originUsername, password=originPassword)  
originService = Exchange2010Service(originConnection)

Com o serviço instanciado, só falta obter uma instância do calendário e listar todos os eventos, conforme nosso filtro:

originCalendar = originService.calendar()originEvents = originCalendar.list\_events(  
    start=timezone("America/Sao\_Paulo").localize(datetime(2017, 11, 1, 0, 0, 0)),  
    end=timezone("America/Sao\_Paulo").localize(datetime(2017, 11, 17, 0, 0, 0)),  
    details=True  
)

No exemplo acima, estou listando todos os eventos entre 01/11/2017 e 17/11/2017 no timezone de São Paulo.

Dando continuidade, criei uma classe chamada *Event* para armazenar os dados dos nossos eventos. Não se esqueça de adicionar a linha abaixo no início para importar a classe:

from Event import Event

Note que na classe *Event* foi preciso implementar o método *\_\_eq\_\_* para verificarmos se os eventos são iguais:

class Event:  
    def \_\_init\_\_(self, start, end, subject, location, html\_body, text\_body, attendees, required\_attendees, optional\_attendees, recurrence, recurrence\_interval, recurrence\_end\_date, recurrence\_days):  
      self.start = start  
      self.end = end  
      self.subject = subject  
      self.location = location  
      self.html\_body = html\_body  
      self.text\_body = text\_body  
      self.attendees = attendees  
      self.required\_attendees = required\_attendees  
      self.optional\_attendees = optional\_attendees  
      self.recurrence = recurrence  
      self.recurrence\_interval = recurrence\_interval  
      self.recurrence\_end\_date = recurrence\_end\_date  
      self.recurrence\_days = recurrence\_days  
     
    def \_\_eq\_\_(self, other):  
        return self.start == other.start and self.end == other.end \\  
            and self.subject == other.subject and self.location == other.location \\  
            and self.html\_body == other.html\_body and self.text\_body == other.text\_body \\  
            and self.attendees == other.attendees and self.required\_attendees == other.required\_attendees \\  
            and self.optional\_attendees == other.optional\_attendees and self.recurrence == other.recurrence \\  
            and self.recurrence\_interval == other.recurrence\_interval and self.recurrence\_end\_date == other.recurrence\_end\_date \\  
            and self.recurrence\_days == other.recurrence\_days

O código abaixo cria uma lista de eventos e imprime no console algumas informações sobre os itens inseridos:

originList = list()  
for originEvent in originEvents.events:  
    event = Event(originEvent.start, originEvent.end, originEvent.subject, originEvent.location, originEvent.html\_body, originEvent.text\_body, originEvent.attendees, originEvent.required\_attendees, originEvent.optional\_attendees, originEvent.recurrence, originEvent.recurrence\_interval, originEvent.recurrence\_end\_date, originEvent.recurrence\_days)  
    originList.append(event);  
    print "{start} {end} - {subject}".format(  
        start=originEvent.start,  
        end=originEvent.end,  
        subject=originEvent.subject  
    )

Agora que já temos os eventos da primeira conta do Outlook, vamos pegar os eventos da segunda conta da mesma forma:

destinyURL = u'[https://outroServidor.outlook.com/EWS/Exchange.asmx'](https://outroServidor.outlook.com/EWS/Exchange.asmx%27)  
destinyUsername = u'nomeUsuario'  
originPassword = u'passwordUsuario'

\# Set up the connection to Exchange  
destinyConnection = ExchangeNTLMAuthConnection(url=destinyURL,  
                                        username=destinyUsername,  
                                        password=originPassword)

destinyService = Exchange2010Service(destinyConnection)

destinyCalendar = destinyService.calendar()

destinyEvents = destinyCalendar.list\_events(  
    start=timezone("America/Sao\_Paulo").localize(datetime(2017, 11, 1, 0, 0, 0)),  
    end=timezone("America/Sao\_Paulo").localize(datetime(2017, 11, 17, 0, 0, 0)),  
    details=True  
)

destinyList = list()  
for destinyEvent in destinyEvents.events:  
    event = Event(destinyEvent.start, destinyEvent.end, destinyEvent.subject, destinyEvent.location, destinyEvent.html\_body, destinyEvent.text\_body, destinyEvent.attendees, destinyEvent.required\_attendees, destinyEvent.optional\_attendees, destinyEvent.recurrence, destinyEvent.recurrence\_interval, destinyEvent.recurrence\_end\_date, destinyEvent.recurrence\_days)  
    destinyList.append(event);  
    print "{start} {end} - {subject}".format(  
        start=destinyEvent.start,  
        end=destinyEvent.end,  
        subject=destinyEvent.subject  
    )

Com as duas listas de eventos prontas, como faço para saber quais eventos devo incluir? A forma que eu encontrei foi a seguinte:

Iterar a lista de origem e para cada ocorrência verificar se o evento está na lista de destino. Caso não esteja, basta usar os métodos da PyExchange para criar o evento:

for event in originList:  
    if event not in destinyList:  
        event = destinyService.calendar().new\_event(  
            subject=originEvent.subject,  
            start=originEvent.start,  
            end=originEvent.end,  
            location=originEvent.location,  
            html\_body = originEvent.html\_body,  
            text\_body = originEvent.text\_body,  
            recurrence = originEvent.recurrence,  
            recurrence\_interval = originEvent.recurrence\_interval,  
            recurrence\_end\_date = originEvent.recurrence\_end\_date,  
            recurrence\_days = originEvent.recurrence\_days  
        )  
        event.create()

O mesmo procedimento deve ser feito para incluirmos os eventos da lista de destino na lista de origem:

event = originService.calendar().new\_event(  
            subject=destinyEvent.subject,  
            start=destinyEvent.start,  
            end=destinyEvent.end,  
            location=destinyEvent.location,  
            html\_body = destinyEvent.html\_body,  
            text\_body = destinyEvent.text\_body,  
            recurrence = destinyEvent.recurrence,  
            recurrence\_interval = destinyEvent.recurrence\_interval,  
            recurrence\_end\_date = destinyEvent.recurrence\_end\_date,  
            recurrence\_days = destinyEvent.recurrence\_days  
        )  
        event.create()

Pronto! Dessa forma nossa agenda de eventos está sincronizada entre duas contas do Outlook.

Se você tiver alguma sugestão de melhoria, deixe seu comentário e vamos trocar uma ideia a respeito.