Implement a comment/discussion system in GraphSpace

applications/discussions/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

applications/discussions/apps.py

@@ -0,0 +1,7 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class DiscussionsConfig(AppConfig):
+    name = 'discussions'

applications/discussions/controllers.py

@@ -0,0 +1,83 @@
+from sqlalchemy.exc import IntegrityError
+import applications.discussions.dal as db
+from graphspace.exceptions import ErrorCodes, BadRequest
+from graphspace.wrappers import atomic_transaction
+
+
+@atomic_transaction
+def add_discussion(request, message=None, topic=None, group_id=None, is_resolved=0, owner_email=None,
+                   parent_discussion_id=None):
+    # Construct new discussion to add to database
+    discussion = db.add_discussion(request.db_session, message=message, topic=topic,
+                                   owner_email=owner_email,
+                                   group_id=group_id, is_resolved=is_resolved,
+                                   parent_discussion_id=parent_discussion_id)
+    return discussion
+
+
+def search_discussions_by_group_id(request, group_id=None, topic=None, limit=20, offset=0, order='desc', sort='created_at'):
+    if group_id is None:
+        raise Exception("Atleast one group id is required.")
+
+    if sort == 'topic':
+        sort_attr = db.Discussion.topic
+    else:
+        sort_attr = db.Discussion.created_at
+
+    if order == 'desc':
+        orber_by = db.asc(sort_attr)
+    else:
+        orber_by = db.desc(sort_attr)
+
+    total, discussions = db.get_discussions_by_group_id(request.db_session,
+                                                        group_id=group_id,
+                                                        topic=topic,
+                                                        limit=limit,
+                                                        offset=offset,
+                                                        order_by=orber_by)
+
+    return total, discussions
+
+
+
+def get_discussion_by_id(request, discussion_id):
+    return db.get_discussion(request.db_session, id=discussion_id)
+
+
+def search_comments_by_discussion_id(request, group_id=None, discussion_id=None):
+    if group_id is None:
+        raise Exception("Atleast one group id is required.")
+    if discussion_id is None:
+        raise Exception("Atleast one discussion id is required.")
+    return db.get_comments_by_discussion_id(request.db_session, group_id=group_id, discussion_id=discussion_id)
+
+
+def is_user_authorized_to_delete_discussion(request, username, discussion_id):
+    is_authorized = False
+
+    discussion = db.get_discussion(request.db_session, discussion_id)
+
+    if discussion is not None: 
+        if discussion.owner_email == username:
+            is_authorized = True
+
+    return is_authorized
+
+
+def delete_discussion_by_id(request, discussion_id):
+    db.delete_discussion(request.db_session, id=discussion_id)
+    return
+
+
+def update_discussion(request, discussion_id, message, is_resolved):
+    discussion = {}
+    if message is not None:
+        discussion['message'] = message
+        return db.update_discussion(request.db_session, id=discussion_id, updated_discussion=discussion)
+    if is_resolved is not None:
+        if is_resolved == u'1':
+            discussion['is_resolved'] = is_resolved
+            return db.resolve_discussion(request.db_session, id=discussion_id, updated_discussion=discussion)
+        if is_resolved == u'0':
+            discussion['is_resolved'] = is_resolved
+            return db.reopen_discussion(request.db_session, id=discussion_id, updated_discussion=discussion)

applications/discussions/dal.py

@@ -0,0 +1,126 @@
+from sqlalchemy import and_, or_, desc, asc, event
+from sqlalchemy.orm import joinedload, subqueryload
+from graphspace.wrappers import with_session
+from applications.discussions.models import *
+from applications.users.dal import *
+from applications.users.models import *
+import graphspace.signals as socket
+from graphspace.database import *
+
+@with_session
+def add_discussion(db_session, message, topic, group_id, owner_email=None, is_resolved=0, parent_discussion_id=None):
+	discussion = Discussion(owner_email=owner_email, group_id=group_id,
+				  is_resolved=is_resolved, parent_discussion_id=parent_discussion_id, message=message, topic=topic)
+	group = get_group(db_session, group_id)
+	group.group_discussions.append(discussion)
+	db_session.add(discussion)
+	return discussion
+
+
+@with_session
+def get_discussions_by_group_id(db_session, group_id, topic, limit, offset, order_by=desc(Discussion.created_at)):
+
+	query = db_session.query(Discussion).filter(Discussion.group_id == group_id)
+	query = query.filter(Discussion.parent_discussion_id == None)
+	if order_by is not None:
+		query = query.order_by(order_by)
+	if topic is not None:
+		query1 = query.filter(Discussion.topic.ilike(topic))
+		query2 = query.filter(Discussion.owner_email.ilike(topic))
+		query3 = query.filter(Discussion.message.ilike(topic))
+		query4 = query1.union(query2)
+		query = query3.union(query4)
+	total = query.count()
+
+	if offset is not None and limit is not None:
+		query = query.limit(limit).offset(offset)
+
+	return total, query.all()
+
+@with_session
+def get_discussion(db_session, id):
+	"""
+	Get discussion by discussion id.
+	:param db_session: Database session.
+	:param id: Unique ID of the discussion
+	:return: Discussion if id exists else None
+	"""
+	return db_session.query(Discussion).filter(Discussion.id == id).one_or_none()
+def get_comments_by_discussion_id(db_session, group_id, discussion_id):
+	query = db_session.query(Discussion).filter(Discussion.group_id == group_id)
+	query = query.filter(Discussion.parent_discussion_id == discussion_id)
+	return query.count(), query.all()
+
+@with_session
+def delete_discussion(db_session, id):
+	"""
+	Delete discussion from Discussion table.
+	:param db_session: Database session.
+	:param id: Unique ID of the discussion
+	:return: discussion
+	"""
+	discussion = db_session.query(Discussion).filter(Discussion.id == id).one_or_none()
+	query = db_session.query(Discussion).filter(Discussion.parent_discussion_id == id).all()
+	db_session.delete(discussion)
+	for ele in query:
+		db_session.delete(ele)
+	return discussion
+
+@with_session
+def update_discussion(db_session, id, updated_discussion):
+	"""
+	Update discussion row entry.
+	:param db_session: Database session.
+	:param id: Unique ID of the discussion
+	:param updated_discussion: Updated discussion row entry
+	:return: Discussion if id exists else None
+	"""
+	discussion = db_session.query(Discussion).filter(Discussion.id == id).one_or_none()
+	for (key, value) in updated_discussion.items():
+		setattr(discussion, key, value)
+	send_discussion(discussion, event="edited")
+	return discussion
+
+@with_session
+def resolve_discussion(db_session, id, updated_discussion):
+	"""
+	Update discussion row entry.
+	:param db_session: Database session.
+	:param id: Unique ID of the discussion
+	:param updated_discussion: Updated discussion row entry
+	:return: Discussion if id exists else None
+	"""
+	discussion = db_session.query(Discussion).filter(Discussion.id == id).one_or_none()
+	for (key, value) in updated_discussion.items():
+		setattr(discussion, key, value)
+	send_discussion(discussion, event="resolve")
+	return discussion
+
+@with_session
+def reopen_discussion(db_session, id, updated_discussion):
+	"""
+	Update discussion row entry.
+	:param db_session: Database session.
+	:param id: Unique ID of the discussion
+	:param updated_discussion: Updated discussion row entry
+	:return: Discussion if id exists else None
+	"""
+	discussion = db_session.query(Discussion).filter(Discussion.id == id).one_or_none()
+	for (key, value) in updated_discussion.items():
+		setattr(discussion, key, value)
+	send_discussion(discussion, event="reopen")
+	return discussion
+
+
+@event.listens_for(Discussion, 'after_insert')
+def update_listener(mapper, connection, discussion):
+	send_discussion(discussion, event="insert")
+
+@event.listens_for(Discussion, 'after_delete')
+def delete_listener(mapper, connection, discussion):
+	send_discussion(discussion, event="delete")
+
+def send_discussion(discussion, event):
+	users_list = get_users_by_group(Database().session(), discussion.group_id)
+	socket.send_discussion(discussion=discussion, type="private", users=users_list, event=event)
+

applications/discussions/models.py

@@ -0,0 +1,51 @@
+from __future__ import unicode_literals
+
+from applications.users.models import *
+from django.conf import settings
+from graphspace.mixins import *
+import json
+from sqlalchemy import ForeignKeyConstraint, text, Enum, Boolean
+from sqlalchemy import String, ForeignKey, UniqueConstraint
+Base = settings.BASE
+
+
+# ================== Table Definitions =================== #
+
+class Discussion(IDMixin, TimeStampMixin, Base):
+    __tablename__ = 'discussion'
+
+    message = Column(String, nullable=False)
+    is_resolved = Column(Integer, nullable=False, default=0)
+    topic = Column(String, nullable=True)
+
+    owner_email = Column(String, ForeignKey('user.email', ondelete="CASCADE", onupdate="CASCADE"), nullable=False)
+    owner = relationship("User", back_populates="owned_discussions", uselist=False)
+
+    group_id = Column(Integer, ForeignKey('group.id', ondelete="CASCADE", onupdate="CASCADE"), nullable=False)
+    group = relationship("Group", back_populates="group_discussions", uselist=False)
+
+    parent_discussion_id = Column(Integer, ForeignKey('discussion.id', ondelete="CASCADE", onupdate="CASCADE"),
+                                  nullable=True)
+    constraints = (UniqueConstraint('topic', 'group_id', name='_discussion_uc_topic_group_id'),)
+    indices = ()
+
+    @declared_attr
+    def __table_args__(cls):
+        args = cls.constraints + cls.indices
+        return args
+
+    def serialize(cls, **kwargs):
+        return {
+            'id': cls.id,
+            'owner_email': cls.owner_email,
+            'message': cls.message,
+            'topic': cls.topic,
+            'is_resolved': cls.is_resolved,
+            'group_id': cls.group_id,
+            'parent_discussion_id': cls.parent_discussion_id,
+            'group_owner_email': cls.group.owner_email,
+            'created_at': cls.created_at.isoformat(),
+            'updated_at': cls.updated_at.isoformat()
+        }
+
+

applications/users/models.py

@@ -6,6 +6,7 @@
 
 from applications.graphs.models import *
 from applications.comments.models import *
+from applications.discussions.models import *
 
 
 Base = settings.BASE
@@ -31,7 +32,7 @@ class User(IDMixin, TimeStampMixin, Base):
 	owned_graphs = relationship("Graph", back_populates="owner", cascade="all, delete-orphan")
 	owned_layouts = relationship("Layout", back_populates="owner", cascade="all, delete-orphan")
 	owned_comments = relationship("Comment", back_populates="owner", cascade="all, delete-orphan")
-
+	owned_discussions = relationship("Discussion", back_populates="owner", cascade="all, delete-orphan")
 
 	member_groups = association_proxy('user_groups', 'group')
 
@@ -86,6 +87,8 @@ class Group(IDMixin, TimeStampMixin, Base):
 	invite_code = Column(String, nullable=False)
 
 	owner = relationship("User", back_populates="owned_groups", uselist=False)
+	group_discussions = relationship("Discussion", back_populates="group", cascade="all, delete-orphan")
+
 	members = association_proxy('member_users', 'user')
 	graphs = association_proxy('shared_graphs', 'graph')
 
@@ -106,6 +109,7 @@ def serialize(cls, **kwargs):
 			'description': cls.description,
 			'total_graphs': len(cls.graphs),
 			'total_members': len(cls.members),
+			'group_discussions': len(cls.group_discussions),
 			'created_at': cls.created_at.isoformat(),
 			'updated_at': cls.updated_at.isoformat()
 		}

applications/users/urls.py

@@ -5,6 +5,7 @@
 
 	url(r'^groups/$', views.groups_page, name='groups'),
 	url(r'^groups/(?P<group_id>[^/]+)$', views.group_page, name='group'),
+	url(r'^groups/(?P<group_id>[^/]+)/discussions/(?P<discussion_id>[^/]+)$', views.discussion_page, name='discussion'),
 
 	url(r'^groups/(?P<group_id>[^/]+)/join/$', views.join_group_page, name='signup_by_invitation'),
 
@@ -22,6 +23,9 @@
 	# Group Graphs
 	url(r'^ajax/groups/(?P<group_id>[^/]+)/graphs$', views.group_graphs_ajax_api, name='group_graphs_ajax_api'),
 	url(r'^ajax/groups/(?P<group_id>[^/]+)/graphs/(?P<graph_id>[^/]+)$', views.group_graphs_ajax_api, name='group_graphs_ajax_api'),
+	# Group Discussions
+	url(r'^ajax/groups/(?P<group_id>[^/]+)/discussions$', views.group_discussions_ajax_api, name='group_discussions_ajax_api'),
+	url(r'^ajax/groups/(?P<group_id>[^/]+)/discussions/(?P<discussion_id>[^/]+)$', views.discussion_comments_ajax_api, name='discussion_comments_ajax_api'),
 
 	# REST APIs Endpoints