D6i{+ddlmZddlmZmZmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZ ddlmZGd d ZGd d eZddZy #e$rd ZY#wxYw))datetime)JSONColumnDateTimeIntegerString) declared_attr) MutableDict) NoResultFound) BaseStorage) FakeCachefirst)AnonymousUserMixinNceZdZdZedZeedZee ddZ ee e jdZeej edZd Zy ) OAuthConsumerMixina% A :ref:`SQLAlchemy declarative mixin ` with some suggested columns for a model to store OAuth tokens: ``id`` an integer primary key ``provider`` a short name to indicate which OAuth provider issued this token ``created_at`` an automatically generated datetime that indicates when the OAuth provider issued this token ``token`` a :class:`JSON ` field to store the actual token received from the OAuth provider c<d|jjS)N flask_dance_)__name__lower)clss d/home/azureuser/techstart-app/venv/lib/python3.12/site-packages/flask_dance/consumer/storage/sqla.py __tablename__z OAuthConsumerMixin.__tablename__#scll002344T) primary_key2F)nullable)defaultrc:g}|j|jj|jr|jd|j|jr|jd|jddj dj |S)Nzid=z provider=""z<{}> )append __class__ridproviderformatjoin)selfpartss r__repr__zOAuthConsumerMixin.__repr__,sq T^^,,- 77 LL3twwi ) == LL:dmm_A6 7}}SXXe_--rN)r __module__ __qualname____doc__r rrrr#rr$rrutcnow created_atr as_mutablertokenr)rrrrsj"55 T *BfRj51H(//EJJ );))$/% @E.rrcBeZdZdZ ddZd dZd dZd dZd dZy) SQLAlchemyStoragez Stores and retrieves OAuth tokens using a relational database through the `SQLAlchemy`_ ORM. .. _SQLAlchemy: http://www.sqlalchemy.org/ Nc||_||_||_||_||duxs|du|_n||_|xst |_|xs t|_y)a Args: model: The SQLAlchemy model class that represents the OAuth token table in the database. At a minimum, it must have a ``provider`` column and a ``token`` column. If tokens are to be associated with individual users in the application, it must also have a ``user`` relationship to your User model. It is recommended, though not required, that your model class inherit from :class:`~flask_dance.consumer.storage.sqla.OAuthConsumerMixin`. session: The :class:`SQLAlchemy session ` for the database. If you're using `Flask-SQLAlchemy`_, this is ``db.session``. user: If you want OAuth tokens to be associated with individual users in your application, this is a reference to the user that you want to use for the current request. It can be an actual User object, a function that returns a User object, or a proxy to the User object. If you're using `Flask-Login`_, this is :attr:`~flask.ext.login.current_user`. user_id: If you want to pass an identifier for a user instead of an actual User object, use this argument instead. Sometimes it can save a database query or two. If both ``user`` and ``user_id`` are provided, ``user_id`` will take precendence. user_required: If set to ``True``, an exception will be raised if you try to set or retrieve an OAuth token without an associated user. If set to ``False``, OAuth tokens can be set with or without an associated user. The default is auto-detection: it will be ``True`` if you pass a ``user`` or ``user_id`` parameter, ``False`` otherwise. anon_user: If anonymous users are represented by a class in your application, provide that class here. If you are using `Flask-Login`_, anonymous users are represented by the :class:`flask_login.AnonymousUserMixin` class, but you don't have to provide that -- Flask-Dance treats it as the default. cache: An instance of `Flask-Caching`_. Providing a caching system is highly recommended, but not required. .. _Flask-SQLAlchemy: http://pythonhosted.org/Flask-SQLAlchemy/ .. _Flask-Login: https://flask-login.readthedocs.io/ .. _Flask-Caching: https://flask-caching.readthedocs.io/en/latest/ N) modelsessionuseruser_id user_requiredr anon_userr cache)r'r5r6r7r8r9r:r;s r__init__zSQLAlchemyStorage.__init__>sar     !%T!1!HWD5HD !.D "8&8)ik rc2t|j|jjdg}|sGtfd|j|jjdfD}t |d|}dj |j|S)Nr8c3JK|]}t|jywN_get_real_userr:.0refr's r z3SQLAlchemyStorage.make_cache_key..s$sDNN3 #r7r#z"flask_dance_token|{name}|{user_id})namer8)rr8configgetr7getattrr%rG)r' blueprintr7r8uidus` rmake_cache_keyz SQLAlchemyStorage.make_cache_keysWdllI,<,<,@,@,KLM $))Y-=-=-A-A&-IJA!T1%C3::;  rcj|||}jj|}|r|Sjj j j |j}t|j|jjdg}tfd|j|jjdfD}jr|s |s tdtj dr|r|j |}nStj dr|r|j |}n(tj dr|j d } |jj }jj%|||S#t"$rd }Y+wxYw) aWhen you have a statement in your code that says "if .authorized:" (for example "if google.authorized:"), a long string of function calls result in this function being used to check the Flask server's cache and database for any records associated with the current_user. The `user` and `user_id` parameters are actually not set in that case (see base.py:token(), that's what calls this function), so the user information is instead loaded from the current_user (if that's what you specified when you created the blueprint) with blueprint.config.get('user_id'). :param blueprint: :param user: :param user_id: :return: rKr7r8r$r8c3JK|]}t|jywr?r@rBs rrEz(SQLAlchemyStorage.get..$  3 / rFr7z1Cannot get OAuth token without an associated userr8r7N)rNr;rIr6queryr5 filter_byrGrr8rHr7r9 ValueErrorhasattroner0r set) r'rKr7r8 cache_keyr0rVrLrMs ` rrIzSQLAlchemyStorage.gets|"'')$PW'X  y) L ""4::.88)..8QWdllI,<,<,@,@,KLM  dii)9)9)=)=f)EF     aPQ Q 4::y )cOOCO0E TZZ (QOOO+E TZZ +OODO1E IIK%%E y%(  E s9F11 F?>F?ct|j|jjdg}tfd|j|jjdfD}j r|s |s t djjjj|j}tjd}|r|r|j|}tjd} | r|r|j|}|j|j|d} |r|r|| d<| r|r|| d<jjjd i| jjj jj#||| y) Nr8c3JK|]}t|jywr?r@rBs rrEz(SQLAlchemyStorage.set..rSrFr7z1Cannot set OAuth token without an associated userrQrTrU)r$r0rPr1)rr8rHrIr7r9rXr6rVr5rWrGrYdeleteaddcommitr;rN) r'rKr0r7r8rLrMexisting_query has_user_idhas_userkwargss ` rr[zSQLAlchemyStorage.setsWdllI,<,<,@,@,KLM  dii)9)9)=)=f)EF     aPQ Q++DJJ7AA^^B djj)4 3+55c5BN4::v. +5515=N'nnu= 3 #F9  F6N -f-.     )$  P rc:jjjj|j}t |j |jjdg}t fd|j|jjdfD}jr|s |s tdtjdr|r|j|}nStjdr|r|j|}n(tjdr|jd}|jjjjjj!|||y) NrQr8c3JK|]}t|jywr?r@rBs rrEz+SQLAlchemyStorage.delete..rSrFr7z4Cannot delete OAuth token without an associated userrTrUrP)r6rVr5rWrGrr8rHrIr7r9rXrYr_rar;rN)r'rKr7r8rVrLrMs` rr_zSQLAlchemyStorage.deletesA ""4::.88)..8QWdllI,<,<,@,@,KLM  dii)9)9)=)=f)EF     aST T 4::y )cOOCO0E TZZ (QOOO+E TZZ +OODO1E      )$  P r)NNNNN)NN) rr*r+r,r<rNrIr[r_r1rrr3r36s5B*H  3j$ L rr3ct|dr|j}t|r|}|r t||ry|S)a Given a "user" that could be: * a real user object * a function that returns a real user object * a LocalProxy to a real user object (like Flask-Login's ``current_user``) This function returns the real user object, regardless of which we have. _get_current_objectN)rYricallable isinstance)r7r:s rrArAs?t*+'')~vZi0 Krr?)r sqlalchemyrrrrrsqlalchemy.ext.declarativer sqlalchemy.ext.mutabler sqlalchemy.orm.excr flask_dance.consumer.storager flask_dance.utilsr r flask_loginr ImportErrorrr3rAr1rrrts\>>4.,4.. ".".JM M `ssAA A