feat: Sync Google (#136)

Author: LiranCaduri

.gitignore

@@ -145,11 +145,14 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
+# mac env
+bin
 
 # register stuff
 run.txt
+
 # VScode
-.vscode/
+.vscode
 app/.vscode/
 
 app/routers/stam

app/config.py.example

@@ -36,6 +36,11 @@ WEBSITE_LANGUAGE = "en"
 ASTRONOMY_API_KEY = os.getenv('ASTRONOMY_API_KEY')
 WEATHER_API_KEY = os.getenv('WEATHER_API_KEY')
 
+# https://developers.google.com/calendar/quickstart/python -
+# follow instracions and make an env variable with the path to the file.
+CLIENT_SECRET_FILE = os.environ.get('CLIENT_SECRET')
+
+
 # EXPORT
 ICAL_VERSION = '2.0'
 PRODUCT_ID = '-//Our product id//'

app/database/models.py

@@ -46,6 +46,10 @@ class User(Base):
     )
     comments = relationship("Comment", back_populates="user")
 
+    oauth_credentials = relationship(
+        "OAuthCredentials", cascade="all, delete", back_populates="owner",
+        uselist=False)
+
     def __repr__(self):
         return f'<User {self.id}>'
 
@@ -65,11 +69,12 @@ class Event(Base):
     end = Column(DateTime, nullable=False)
     content = Column(String)
     location = Column(String)
+    is_google_event = Column(Boolean)
     vc_link = Column(String)
     color = Column(String, nullable=True)
-    availability = Column(Boolean, default=True, nullable=False)
     invitees = Column(String)
     emotion = Column(String, nullable=True)
+    availability = Column(Boolean, default=True, nullable=False)
 
     owner_id = Column(Integer, ForeignKey("users.id"))
     category_id = Column(Integer, ForeignKey("categories.id"))
@@ -187,6 +192,21 @@ def __repr__(self):
         )
 
 
+class OAuthCredentials(Base):
+    __tablename__ = "oauth_credentials"
+
+    id = Column(Integer, primary_key=True, index=True)
+    token = Column(String)
+    refresh_token = Column(String)
+    token_uri = Column(String)
+    client_id = Column(String)
+    client_secret = Column(String)
+    expiry = Column(DateTime)
+
+    user_id = Column(Integer, ForeignKey("users.id"))
+    owner = relationship("User", back_populates=__tablename__, uselist=False)
+
+
 class SalarySettings(Base):
     # Code revision required after categories feature is added
     # Code revision required after holiday times feature is added

app/dependencies.py

@@ -8,6 +8,7 @@
 from app.database import SessionLocal
 from app.internal.logger_customizer import LoggerCustomizer
 
+GOOGLE_ERROR = config.CLIENT_SECRET_FILE is None
 APP_PATH = os.path.dirname(os.path.realpath(__file__))
 MEDIA_PATH = os.path.join(APP_PATH, config.MEDIA_DIRECTORY)
 STATIC_PATH = os.path.join(APP_PATH, "static")

app/internal/google_connect.py

@@ -0,0 +1,213 @@
+from datetime import datetime
+from fastapi import Depends
+
+from google.auth.transport.requests import Request as google_request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+
+from app.database.models import Event, User, OAuthCredentials, UserEvent
+from app.dependencies import get_db, SessionLocal
+from app.config import CLIENT_SECRET_FILE
+from app.routers.event import create_event
+
+
+SCOPES = ['https://www.googleapis.com/auth/calendar']
+
+
+def get_credentials(user: User,
+                    session: SessionLocal = Depends(get_db)) -> Credentials:
+    credentials = get_credentials_from_db(user)
+
+    if credentials is not None:
+        credentials = refresh_token(credentials, session, user)
+    else:
+        credentials = get_credentials_from_consent_screen(
+            user=user, session=session)
+
+    return credentials
+
+
+def fetch_save_events(credentials: Credentials, user: User,
+                      session: SessionLocal = Depends(get_db)) -> None:
+    if credentials is not None:
+        events = get_current_year_events(credentials, user, session)
+        push_events_to_db(events, user, session)
+
+
+def clean_up_old_credentials_from_db(
+    session: SessionLocal = Depends(get_db)
+) -> None:
+    session.query(OAuthCredentials).filter_by(user_id=None).delete()
+    session.commit()
+
+
+def get_credentials_from_consent_screen(user: User,
+                                        session: SessionLocal = Depends(get_db)
+                                        ) -> Credentials:
+    credentials = None
+
+    if not is_client_secret_none():  # if there is no client_secrets.json
+        flow = InstalledAppFlow.from_client_secrets_file(
+            client_secrets_file=CLIENT_SECRET_FILE,
+            scopes=SCOPES
+        )
+
+        flow.run_local_server(prompt='consent')
+        credentials = flow.credentials
+
+        push_credentials_to_db(
+            credentials=credentials, user=user, session=session
+        )
+
+        clean_up_old_credentials_from_db(session=session)
+
+    return credentials
+
+
+def push_credentials_to_db(credentials: Credentials, user: User,
+                           session: SessionLocal = Depends(get_db)
+                           ) -> OAuthCredentials:
+
+    oauth_credentials = OAuthCredentials(
+        owner=user,
+        token=credentials.token,
+        refresh_token=credentials.refresh_token,
+        token_uri=credentials.token_uri,
+        client_id=credentials.client_id,
+        client_secret=credentials.client_secret,
+        expiry=credentials.expiry
+    )
+
+    session.add(oauth_credentials)
+    session.commit()
+    return credentials
+
+
+def is_client_secret_none() -> bool:
+    return CLIENT_SECRET_FILE is None
+
+
+def get_current_year_events(
+        credentials: Credentials, user: User,
+        session: SessionLocal = Depends(get_db)) -> list:
+    '''Getting user events from google calendar'''
+
+    current_year = datetime.now().year
+    start = datetime(current_year, 1, 1).isoformat() + 'Z'
+    end = datetime(current_year + 1, 1, 1).isoformat() + 'Z'
+
+    service = build('calendar', 'v3', credentials=credentials)
+    events_result = service.events().list(
+        calendarId='primary',
+        timeMin=start,
+        timeMax=end,
+        singleEvents=True,
+        orderBy='startTime'
+    ).execute()
+
+    events = events_result.get('items', [])
+    return events
+
+
+def push_events_to_db(events: list, user: User,
+                      session: SessionLocal = Depends(get_db)) -> bool:
+    '''Adding google events to db'''
+    cleanup_user_google_calendar_events(user, session)
+
+    for event in events:
+        # Running over the events that have come from the API
+        title = event.get('summary')  # The Google event title
+
+        # support for all day events
+        if 'dateTime' in event['start']:
+            # This case handles part time events (not all day events)
+            start = datetime.fromisoformat(event['start']['dateTime'])
+            end = datetime.fromisoformat(event['end']['dateTime'])
+        else:
+            # This case handles all day events
+            start_in_str = event['start']['date']
+            start = datetime.strptime(start_in_str, '%Y-%m-%d')
+
+            end_in_str = event['end']['date']
+            end = datetime.strptime(end_in_str, '%Y-%m-%d')
+
+        # if Google Event has a location attached
+        location = event.get('location')
+
+        create_google_event(title, start, end, user, location, session)
+    return True
+
+
+def create_google_event(title: str, start: datetime,
+                        end: datetime, user: User, location: str,
+                        session: SessionLocal = Depends(get_db)) -> Event:
+    return create_event(
+        # creating an event obj and pushing it into the db
+        db=session,
+        title=title,
+        start=start,
+        end=end,
+        owner_id=user.id,
+        location=location,
+        is_google_event=True
+    )
+
+
+def cleanup_user_google_calendar_events(
+    user: User, session: SessionLocal = Depends(get_db)
+) -> bool:
+    '''removing all user google events so the next time will be syncronized'''
+
+    for user_event in user.events:
+        user_event_id = user_event.id
+        event = user_event.events
+        if event.is_google_event:
+            session.query(Event).filter_by(id=event.id).delete()
+            session.query(UserEvent).filter_by(id=user_event_id).delete()
+            session.commit()
+
+    return True
+
+
+def get_credentials_from_db(user: User) -> Credentials:
+    '''bring user credential to use with google calendar api
+    and save the credential in the db'''
+
+    credentials = None
+
+    if user.oauth_credentials is not None:
+        db_credentials = user.oauth_credentials
+        credentials = Credentials(
+            token=db_credentials.token,
+            refresh_token=db_credentials.refresh_token,
+            token_uri=db_credentials.token_uri,
+            client_id=db_credentials.client_id,
+            client_secret=db_credentials.client_secret,
+            expiry=db_credentials.expiry
+        )
+
+    return credentials
+
+
+def refresh_token(credentials: Credentials,
+                  user: User, session: SessionLocal = Depends(get_db)
+                  ) -> Credentials:
+
+    refreshed_credentials = credentials
+    if credentials.expired:
+        credentials.refresh(google_request())
+        refreshed_credentials = OAuthCredentials(
+            owner=user,
+            token=credentials.token,
+            refresh_token=credentials.refresh_token,
+            token_uri=credentials.token_uri,
+            client_id=credentials.client_id,
+            client_secret=credentials.client_secret,
+            expiry=credentials.expiry
+        )
+
+        session.add(refreshed_credentials)
+        session.commit()
+
+    return refreshed_credentials

app/main.py

@@ -43,7 +43,8 @@ def create_tables(engine, psql_environment):
 
 from app.routers import (  # noqa: E402
     agenda, calendar, categories, celebrity, currency, dayview,
-    email, event, export, four_o_four, invitation, login, logout, profile,
+    email, event, export, four_o_four, google_connect,
+    invitation, login, logout, profile,
     register, search, telegram, user, weekview, whatsapp,
 )
 
@@ -78,6 +79,7 @@ async def swagger_ui_redirect():
     event.router,
     export.router,
     four_o_four.router,
+    google_connect.router,
     invitation.router,
     login.router,
     logout.router,

app/routers/event.py

@@ -100,8 +100,10 @@ async def create_new_event(request: Request,
     if vc_link is not None:
         raise_if_zoom_link_invalid(vc_link)
 
-    event = create_event(session, title, start, end, owner_id, content,
-                         location, vc_link, invitees=invited_emails,
+    event = create_event(db=session, title=title, start=start, end=end,
+                         owner_id=owner_id, content=content,
+                         location=location, vc_link=vc_link,
+                         invitees=invited_emails,
                          category_id=category_id,
                          availability=availability)
 
@@ -263,6 +265,7 @@ def create_event(db: Session, title: str, start, end, owner_id: int,
                  invitees: List[str] = None,
                  category_id: Optional[int] = None,
                  availability: bool = True,
+                 is_google_event: bool = False,
                  ):
     """Creates an event and an association."""
 
@@ -282,6 +285,7 @@ def create_event(db: Session, title: str, start, end, owner_id: int,
         invitees=invitees_concatenated,
         category_id=category_id,
         availability=availability,
+        is_google_event=is_google_event
     )
     create_model(
         db, UserEvent,

app/routers/google_connect.py

@@ -0,0 +1,37 @@
+from fastapi import Depends, APIRouter, Request
+from starlette.responses import RedirectResponse
+from loguru import logger
+
+from app.internal.utils import get_current_user
+from app.dependencies import get_db
+from app.internal.google_connect import get_credentials, fetch_save_events
+from app.routers.profile import router as profile
+
+router = APIRouter(
+    prefix="/google",
+    tags=["sync"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/sync")
+async def google_sync(request: Request,
+                      session=Depends(get_db)) -> RedirectResponse:
+    '''Sync with Google - if user never synced with google this funcion will take
+    the user to a consent screen to use his google calendar data with the app.
+    '''
+
+    user = get_current_user(session)  # getting active user
+
+    # getting valid credentials
+    credentials = get_credentials(user=user, session=session)
+
+    if credentials is None:
+        # in case credentials is none, this is mean there isn't a client_secret
+        logger.error("GoogleSync isn't available - missing client_secret.json")
+
+    # fetch and save the events com from Google Calendar
+    fetch_save_events(credentials=credentials, user=user, session=session)
+
+    url = profile.url_path_for('profile')
+    return RedirectResponse(url=url)

app/routers/profile.py

@@ -9,7 +9,7 @@
 
 from app import config
 from app.database.models import User
-from app.dependencies import get_db, MEDIA_PATH, templates
+from app.dependencies import get_db, MEDIA_PATH, templates, GOOGLE_ERROR
 from app.internal.on_this_day_events import get_on_this_day_events
 from app.internal.import_holidays import (get_holidays_from_file,
                                           save_holidays_to_db)
@@ -58,6 +58,7 @@ async def profile(
         "user": user,
         "events": upcoming_events,
         "signs": signs,
+        'google_error': GOOGLE_ERROR,
         "on_this_day_data": on_this_day_data,
     })