message Feature for AGs & with email when email is confirmed

app/__init__.py

@@ -11,6 +11,8 @@
 ma = Marshmallow(app)
 
 from app.models.user import Session, User
+from app.models.ag import AG, AGSchema
+from app.models.associations import UserAG
 from app.utils import after_this_request, requires_auth
 
 from app.blueprints.api import v1
@@ -89,4 +91,6 @@ def set_cookie(response):
 @app.route('/')
 @requires_auth()
 def index():
-    return render_template('index.html', title='Dashboard')
+    ags = db.session.query(AG).join(UserAG).filter(UserAG.user_id == g.session.user_id)
+    ags_schema = AGSchema(many=True)
+    return render_template('index.html', title='Dashboard', ags=ags_schema.dump(ags))

app/blueprints/ag.py

@@ -1,12 +1,12 @@
 from flask import Blueprint, g, redirect, render_template, url_for, flash
 from sqlalchemy.sql import exists
 from werkzeug.exceptions import NotFound, Unauthorized
-from app.models.associations import UserAG
-from app.models.ag import AG, AGSchema, AGSchemaIntern
+from app.models.associations import UserAG, UserAGMessage
+from app.models.ag import AG, AGSchema, AGSchemaIntern, AGMessage, AGMessageSchema
 from app.models import db
-from app.utils import requires_auth, requires_mentor, requires_membership
+from app.utils import requires_auth, requires_mentor, requires_membership, requires_ag_message_rights
 
-from config.regex import AGRegex
+from config.regex import AGRegex, MessageRegex
 
 bp = Blueprint('ag', __name__)
 
@@ -65,4 +65,21 @@ def discover():
 @requires_auth()
 @requires_mentor()
 def edit_event():
-    pass
+    pass
+
+@bp.route('<ag_name>/messages/write', methods=["GET"])
+@requires_auth()
+@requires_mentor()
+def write_message(ag_name, ag, user_ag):
+    print(ag_name)
+    return render_template('ag/write_message.html', title=f"Write Message for {ag.display_name}", message_regex=MessageRegex, ag_name=ag_name)
+
+@bp.route('<ag_name>/messages/view/<message_id>')
+@requires_auth()
+@requires_ag_message_rights()
+def view_message(ag_name, message_id, ag, user_ag, ag_message, user_ag_message):
+    message_schema = AGMessageSchema()
+    user_ag_message.read = True
+    db.session.add(user_ag_message)
+    db.session.commit()
+    return render_template('ag/view_message.html', title='View Message', message=message_schema.dump(ag_message), my_role=user_ag.role)

app/blueprints/api/v1/ag.py

@@ -4,14 +4,15 @@
 from sqlalchemy.sql import exists, and_, or_
 from werkzeug.exceptions import NotFound, BadRequest, Forbidden, PreconditionFailed
 
-from app.models.ag import AG, AGSchema, AGSchemaIntern
+from app.models.ag import AG, AGSchema, AGSchemaIntern, AGMessage
 from app.models.user import User, UserSchema
-from app.models.associations import UserAG
+from app.models.associations import UserAG, UserAGMessage
 from app.models import db
 
-from app.utils import requires_auth, requires_mentor, requires_ag, requires_member_association, requires_gracefully_not_member, get_user_by_username, get_membership
+from app.utils import requires_auth, requires_mentor, requires_ag, requires_member_association, requires_gracefully_not_member, get_user_by_username, get_membership, get_user_by_username
 
-from config.regex import AGRegex
+from config.regex import AGRegex, MessageRegex
+import app.mail as mail
 
 bp = Blueprint('ag_api', __name__)
 
@@ -25,7 +26,7 @@
 @requires_auth()
 def add_ag():
     '''
-    Create a new AG. The request body has to inclurde the following:
+    Create a new AG. The request body has to include the following:
         :key: name: AG name used to identify the ag (eg. /ag/<name>)
         :key: display_name: AG name that is human read able
         (can contain spaces etc.)
@@ -338,3 +339,68 @@ def leave_ag(ag_name, ag, user_ag):
         flash(f'You sucessfully left the AG {ag.name}', 'success')
     db.session.commit()
     return redirect(url_for('index'))
+
+
+
+@bp.route('<ag_name>/kick/<user_name>')
+@requires_auth()
+@requires_mentor()
+def kick_user(ag_name, user_name, ag, user_ag):
+
+    user = get_user_by_username(user_name)
+    edit_user_ag = db.session.query(UserAG).filter_by(user_id=user.id, ag_id=ag.id).scalar()
+    if(edit_user_ag is None or edit_user_ag.role == "NONE"):
+        flash(f'You cannot kick {user.username} from {ag.display_name}. He is no valid member of this AG')
+        return redirect(url_for('ag.ag_dashboard', ag_name=ag_name))
+    edit_user_ag.role = "NONE"
+    edit_user_ag.status = "KICKED"
+    db.session.flush()
+    if(len(ag.actual_users) == 0):
+        db.session.delete(ag)
+        db.session.commit()
+        flash(f'You sucessfully left and deleted the AG {ag.display_name}', 'success')
+        return redirect(url_for('index'))
+    elif(len(ag.mentors) == 0):
+        flash(f'You cannot kick the last Mentor of {ag.display_name}', 'error')
+    else:
+        flash(f'You sucessfully kicked {user.username} from the AG {ag.display_name}', 'success')
+        db.session.commit()
+    return redirect(url_for('ag.ag_dashboard', ag_name=ag_name))
+
+@bp.route('<ag_name>/delete')
+@requires_auth()
+@requires_mentor()
+def delete_ag(ag_name, ag, user_ag):
+    db.session.delete(ag)
+    db.session.commit()
+    flash(f'You successfully deleted the AG {ag.display_name}', 'success')
+    return redirect(url_for('index'))
+
+@bp.route('<ag_name>/messages/write', methods=["POST"])
+@requires_auth()
+@requires_mentor()
+def write_message(ag_name, ag, user_ag):
+    subject = request.values.get('subject')
+    message = request.values.get('message')
+    email = request.values.get('email')
+    if subject is None and not bool(re.match(MessageRegex.subject, subject)):
+        return PreconditionFailed(description='subject')
+    if message is None and not bool(re.match(MessageRegex.message, message)):
+        return PreconditionFailed(description='message')
+    new_message = AGMessage()
+    new_message.subject = subject
+    new_message.message = message
+    new_message.ag_id = ag.id
+    db.session.add(new_message)
+    db.session.flush()
+    for user in ag.actual_users:
+        new_assoc = UserAGMessage()
+        new_assoc.user_id = user.id
+        new_assoc.message_id = new_message.id
+        new_assoc.read = False
+        db.session.add(new_assoc)
+    if email is not None:
+        mail.ag_mail(agmessage=new_message, ag=ag)
+    db.session.commit()
+    flash('Successfully send message', 'success')
+    return redirect(url_for('ag.ag_dashboard', ag_name=ag_name))

app/blueprints/api/v1/user.py

@@ -44,9 +44,8 @@ def add_user():
 
         db.session.add(user)
         db.session.commit()
-
         mail.confirmation_mail(user)
-
+            
         return user_schema.jsonify(user), 200
     except Exception as e:
         print(e)

app/mail.py

@@ -2,7 +2,7 @@
 from flask_mail import Mail, Message
 
 from app.models.user import User
-
+from app.models.ag import AGMessage, AG
 mail = Mail()
 
 
@@ -12,3 +12,10 @@ def confirmation_mail(user: User):
                       )
     message.add_recipient(user.email)
     mail.send(message)
+
+def ag_mail(agmessage: AGMessage, ag: AG):
+    message = Message(subject=agmessage.subject, body=agmessage.message)
+    for user in ag.actual_users:
+        if user.email_confirmed:
+            message.add_recipient(user.email)
+    mail.send(message)

app/models/ag.py

@@ -1,8 +1,9 @@
 from app import ma
 from app.models import db
 from sqlalchemy import and_
-from app.models.associations import UserAG
+from app.models.associations import UserAG, UserAGMessage, UserAGMessageSchema
 from flask import g
+from datetime import datetime
 
 
 class AG(db.Model):
@@ -35,10 +36,35 @@ class AG(db.Model):
 
     events = db.relationship('Event')
 
+    messages = db.relationship('AGMessage')
+
+    unread_messages = db.relationship('AGMessage',
+                                    secondary='users_ag_messages',
+                                    primaryjoin='and_(UserAGMessage.message_id == AGMessage.id, AG.id == AGMessage.ag_id, UserAGMessage.read == 0, UserAGMessage.user_id == 1)',
+                                    viewonly=True)
+
+    read_messages = db.relationship('AGMessage',
+                                    secondary=f'users_ag_messages',
+                                    primaryjoin=f'and_(UserAGMessage.message_id == AGMessage.id, AG.id == AGMessage.ag_id, UserAGMessage.read == 1, UserAGMessage.user_id == 1)',
+                                    viewonly=True)
+
     def __repr__(self):
         return f'<AG {self.name}>'
 
 
+class AGMessage(db.Model):
+    __tablename__ = 'ag_messages'
+    id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
+    ag_id = db.Column(db.Integer, db.ForeignKey('ags.id'))
+    subject = db.Column(db.String(20))
+    message = db.Column(db.String(1000))
+    created = db.Column(db.DateTime, default=datetime.now())
+
+    users = db.relationship('UserAGMessage', secondary='users', primaryjoin='and_(AGMessage.id == UserAGMessage.message_id, UserAGMessage.user_id == User.id)', viewonly=True)
+
+    def __repr__(self):
+        return f'<AGMessage {self.id}>'
+
 class AGSchema(ma.Schema):
     users = ma.Nested('UserSchema', many=True, exclude=('ags',))
     events = ma.Nested('EventSchema', many=True, exclude=('ag',))
@@ -61,8 +87,67 @@ class AGSchemaIntern(ma.Schema):
     actual_users = ma.Nested('UserSchema', many=True, exclude=('ags',))
     invited_users = ma.Nested('UserSchema', many=True, exclude=('ags',))
     applied_users = ma.Nested('UserSchema', many=True, exclude=('ags',))
+    messages = ma.Nested('AGMessageSchema', many=True)
+    read_messages = ma.Method('get_read_messages')
+    unread_messages = ma.Method('get_unread_messages')
+
+    def get_unread_messages(self, obj: AG):
+        if not g.session.authenticated:
+            return None
+        ag_id = obj.id
+        ag_message = db.session.query(AGMessage).join(UserAGMessage, and_(AGMessage.ag_id == ag_id, UserAGMessage.user_id == g.session.user_id, UserAGMessage.message_id == AGMessage.id, UserAGMessage.read == 0)).all()
+        ag_messages_Schema = AGMessageSchema(many=True)
+        return ag_messages_Schema.dump(ag_message)
+
+    def get_read_messages(self, obj: AG):
+        if not g.session.authenticated:
+            return None
+        print('test')
+        ag_id = obj.id
+        ag_message = db.session.query(AGMessage).join(UserAGMessage, and_(AGMessage.ag_id == ag_id, UserAGMessage.user_id == g.session.user_id, UserAGMessage.message_id == AGMessage.id, UserAGMessage.read == 1)).all()
+        if len(ag_message) > 1:
+            ag_messages_Schema = AGMessageSchema(many=True, exclude=('users',))
+        else:
+            ag_messages_Schema = AGMessageSchema(many=True, exclude=('users',))
+
+        print(ag_messages_Schema.dump(ag_message))
+        print('test')
+        return ag_messages_Schema.dump(ag_message)
+
 
     class Meta:
         fields = (
             'id', 'name', 'display_name', 'description', 'users', 'events', 'color', 'actual_users', 'invited_users',
-            'applied_users')
+            'applied_users', 'messages', 'unread_messages', 'read_messages')
+
+
+
+
+class AGMessageSchema(ma.Schema):
+    read = ma.Method('get_read_status')
+    users = ma.Nested('UserAGMessageSchema', many=True)
+
+
+    def get_read_status(self, obj: AGMessage):
+        if not g.session.authenticated:
+            return None
+        user_ag_message = db.session.query(UserAGMessage).filter_by(user_id = g.session.user_id, message_id=obj.id).scalar()
+        return user_ag_message.read
+
+
+    class Meta:
+        fields = (
+            'id', 'ag_id', 'subject', 'message', 'read', 'created', 'users'
+        )
+
+class Message(db.Model):
+    __tablename__ = 'messages'
+    id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
+    subject = db.Column(db.String(20))
+    message = db.Column(db.String(1000))
+    created = db.Column(db.DateTime, default=datetime.now())
+
+
+    def __repr__(self):
+        return f'<Message {self.id}>'
+

app/models/associations.py

@@ -1,4 +1,6 @@
+from app import ma
 from app.models import db
+from datetime import datetime
 
 
 class UserAG(db.Model):
@@ -37,3 +39,22 @@ class UserDate(db.Model):
 
     def __repr__(self):
         return f'<UserDate {self.id}>'
+
+class UserAGMessage(db.Model):
+    __tablename__ = 'users_ag_messages'
+    id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
+
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
+    message_id = db.Column(db.Integer, db.ForeignKey('ag_messages.id'))
+    read = db.Column(db.Boolean, default=False)
+    updated = db.Column(db.DateTime, onupdate=datetime.now())
+    user = db.relationship('User')
+
+
+    def __repr__(self):
+        return f'<UserAGMessage {self.id}>'
+
+class UserAGMessageSchema(ma.Schema):
+    user = ma.Nested('UserSchema')
+    class Meta:
+        fields = ('user_id', 'read', 'updated', 'user')

app/models/user.py

@@ -30,6 +30,8 @@ class User(db.Model):
     dates = db.relationship('Date', secondary='users_dates')
     sessions = db.relationship('Session')
 
+    unread_messages = db.relationship('UserAGMessage', primaryjoin='and_(User.id == UserAGMessage.user_id, UserAGMessage.read == 0)', viewonly=True) 
+
     def __init__(self):
         self.confirmation_token = secrets.token_hex(32)