added db migrations and group support, still problems with json serialization

models/user_model.py

@@ -2,8 +2,10 @@
 """
 Example user model and related models
 """
+from sqlalchemy.orm import relation
+from sqlalchemy import MetaData
 
-from backend import db, app
+from backend import db, app, login_manager
 from backend.models.post_model import Post
 from backend.models.example_model import ExampleDataItem
 import re
@@ -14,6 +16,9 @@ from datetime import datetime, timedelta
 from passlib.hash import sha256_crypt
 from hashlib import md5
 
+
+metadata = MetaData()
+
 followers = db.Table('followers',
                      db.Column('follower_id', db.Integer, db.ForeignKey('user.id')),
                      db.Column('followed_id', db.Integer, db.ForeignKey('user.id'))
@@ -24,6 +29,20 @@ acquaintances = db.Table('acquaintances',
                          db.Column('acquaintance_id', db.Integer, db.ForeignKey('user.id'))
                          )
 
+# This is the association table for the many-to-many relationship between
+# groups and members - this is, the memberships.
+user_group_table = db.Table('user_group',
+                     db.Column('user_id', db.Integer,
+                            db.ForeignKey('user.id',
+                                       onupdate="CASCADE",
+                                       ondelete="CASCADE"),
+                            primary_key=True),
+                     db.Column('group_id', db.Integer,
+                            db.ForeignKey('group.id',
+                                       onupdate="CASCADE",
+                                       ondelete="CASCADE"),
+                            primary_key=True))
+
 
 class User(UserMixin, db.Model):
     """
@@ -42,8 +61,10 @@ class User(UserMixin, db.Model):
     example_data_item_id = db.Column(db.ForeignKey(ExampleDataItem.id))
     about_me = db.Column(db.String(140))
     role = db.Column(db.String(64))
+    groups = db.relationship('Group', secondary=user_group_table, back_populates='users')
     password = db.Column(db.String(255), nullable=True)
     registered_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
+    external_user = db.Column(db.Boolean, default=False)
     last_seen = db.Column(db.DateTime, default=datetime.utcnow())
     jwt_exp_delta_seconds = db.Column(db.Integer, nullable=True)
     acquainted = db.relationship('User',
@@ -62,11 +83,21 @@ class User(UserMixin, db.Model):
     def __init__(self, **kwargs):
         super(User, self).__init__(**kwargs)
         password = kwargs.get("password", None)
+        external_user = kwargs.get("external_user", None)
+        groups = kwargs.get("groups", None)
         if password is not None:
             self.password = sha256_crypt.encrypt(password)
-        # do custom initialization here
+        if external_user is not None:
+            self.external_user = external_user
+        if groups is not None:
+            if isinstance(groups, list):
+                for g in groups:
+                    self.groups.append(g)
+            elif isinstance(groups, str):
+                self.groups.append(groups)
 
     @staticmethod
+    @login_manager.user_loader
     def get_by_identifier(identifier):
         """
         Find user by identifier, which might be the nickname or the e-mail address.
@@ -152,6 +183,15 @@ class User(UserMixin, db.Model):
         # TODO: implement correctly
         return False
 
+    @property
+    def is_read_only(self):
+        """
+        Returns true if user is active.
+        :return:
+        """
+        # TODO: implement correctly
+        return True
+
     @staticmethod
     def decode_auth_token(auth_token):
         """
@@ -307,7 +347,7 @@ class User(UserMixin, db.Model):
             followers.c.follower_id == self.id).order_by(Post.timestamp.desc())
 
     def to_dict(self):
-        return dict(id=self.id, email=self.email)
+        return dict(id=self.id, email=self.email, groups=self.groups)
 
     def __repr__(self):
         return '<User %r>' % self.nickname
@@ -342,3 +382,24 @@ class BlacklistToken(db.Model):
             return True
         else:
             return False
+
+
+class Group(db.Model):
+    def __init__(self, **kwargs):
+        super(Group, self).__init__(**kwargs)
+
+    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
+    name = db.Column(db.Unicode(64), unique=True, nullable=False)
+    users = db.relationship('User', secondary=user_group_table, back_populates='groups')
+
+    @staticmethod
+    def get_by_name(name):
+        """
+        Find group by name
+        :param name:
+        :return:
+        """
+        return Group.query.filter(Group.name == name).first()
+
+    def __str__(self):
+        return self.name