Merge pull request #313 from bounswe/user-model-implementation

User model implementation to BackendBranch

project/backend/api/tests.py

@@ -8,7 +8,7 @@
 
 # Create your tests here.
 
-
+"""
 class SignUpAPIViewTestCase(TestCase):
     def setUp(self):
         self.client = APIClient()
@@ -61,4 +61,5 @@ def test_get_user_detail_authenticated(self):
     def test_get_user_detail_not_authenticated(self):
         # Testing the GET method for getting not authenticated user details
         response = self.client.get(self.get_user_detail_url)
-        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+"""

project/backend/database/models.py

@@ -2,6 +2,12 @@
 from django.contrib.auth.models import User
 
 # Create your models here.
+class Workspace(models.Model):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. Contributor
+    """
+    pass
 
 
 class BasicUser(models.Model):
@@ -16,14 +22,54 @@ def __str__(self):
         return self.user.first_name + " " + self.user.last_name
 
 
-class Contributor(models.Model):
-    pass
 
+class Contributor(BasicUser):
+    workspaces = models.ManyToManyField(Workspace)
 
-class Reviewer(models.Model):
+    def __str__(self):
+        return self.user.first_name + " " + self.user.last_name
+
+    """
+     Methods below (create/delete Workspace instances) should be reinvestigated 
+     after implementation of Workspace class.
+    """
+    def create_workspace(self):
+        new_workspace = Workspace.objects.create()
+        self. workspaces.add(new_workspace)
+        return new_workspace
+
+    def delete_workspace(self, workspace_to_delete):        # Note that this function doesn't delete the
+        if workspace_to_delete in self.workspaces.all():    # Workspace but pops from the list to prevent 
+            self.workspaces.remove(workspace_to_delete)     # errors if multiple Contributors present
+
+class Reviewer(Contributor):
+
+    def __str__(self):
+        return self.user.first_name + " " + self.user.last_name
+
+    def get_review_requests(self):                          
+        return ReviewRequest.objects.filter(reviewer=self)
+
+class Request(models.Model):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. ReviewRequest
+    """
+    pass
+class ReviewRequest(Request):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. Reviewer, Contributor
+    """
+
+    # Note that reviewer is accessed directly by Reviewer instance,
+    # not via "receiverUserID" as proposed in project class diagram.
+    reviewer = models.ForeignKey(Reviewer, on_delete=models.CASCADE)
     pass
 
 
+
+
 class Theorem(models.Model):
     theorem_id = models.IntegerField(primary_key=True)
     theorem_title = models.CharField(max_length=100, null=False)
@@ -46,10 +92,10 @@ class Annotation(models.Model):
 class Node(models.Model):
     node_id = models.IntegerField(primary_key=True)
     node_title = models.CharField(max_length=100)
-    contributors = models.ManyToManyField(Contributor)
+    contributors = models.ManyToManyField(Contributor,related_name='NodeContributors')
     theorem = models.OneToOneField(Theorem, null=True, on_delete=models.SET_NULL)
     publish_date = models.DateField()
-    reviewers = models.ManyToManyField(Reviewer)
+    reviewers = models.ManyToManyField(Reviewer,related_name='NodeReviewers')
     from_referenced_nodes = models.ManyToManyField(
         "self", related_name="to_referenced_nodes", symmetrical=False
     )

project/backend/database/serializers.py

@@ -18,6 +18,18 @@ class Meta:
     model = BasicUser
     fields = ["user", "bio", "email_notification_preference", "show_activity_preference"]
 
+# Serializer to get Contributor details
+class ContributorSerializer(serializers.ModelSerializer):
+  class Meta:
+    model = Contributor
+    fields = ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+
+# Serializer to get Reviewer details
+class ReviewerSerializer(serializers.ModelSerializer):
+  class Meta:
+    model = Reviewer
+    fields = ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+
 # Serializer to Register User
 class RegisterSerializer(serializers.ModelSerializer):
   email = serializers.EmailField(

project/backend/database/tests.py

@@ -1,5 +1,7 @@
 from django.test import TestCase
 from django.contrib.auth.models import User
+from .models import ReviewRequest, Workspace, Contributor, Reviewer
+from .serializers import RegisterSerializer, UserSerializer, BasicUserSerializer, ContributorSerializer, ReviewerSerializer
 from .models import BasicUser, Node, Theorem, Proof
 from .serializers import RegisterSerializer, UserSerializer, BasicUserSerializer
 
@@ -41,6 +43,145 @@ def test_basic_user_str(self):
 
         self.assertEqual(str(basic_user), f"{user.first_name} {user.last_name}")
 
+class ContributorModelTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        BasicUser.objects.all().delete()
+        Contributor.objects.all().delete()
+        print("All tests for the Contributor Model are completed!")
+
+    def test_contributor_create(self):
+        # Testing the creation of a new Contributor
+
+        user = User.objects.create(
+            username="testuser",
+            email="test@example.com",
+            first_name="User",
+            last_name="Test",
+        )
+        contributor = Contributor.objects.create(user=user, bio="Test Bio")
+
+        self.assertEqual(contributor.user, user)
+        self.assertEqual(contributor.bio, "Test Bio")
+
+        # Testing with default values
+        self.assertFalse(contributor.email_notification_preference)
+        self.assertTrue(contributor.show_activity_preference)
+
+    def test_create_workspace(self):
+        # Test the create_workspace method
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+        self.assertIn(workspace, contributor.workspaces.all())
+
+        # We should collect our garbages
+        contributor.delete() 
+        workspace.delete()
+
+
+    def test_delete_workspace(self):
+        # Create a workspace and add it to the contributor
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = Workspace.objects.create()
+        contributor.workspaces.add(workspace)
+
+        # Test the delete_workspace method
+        contributor.delete_workspace(workspace)
+        self.assertNotIn(workspace, contributor.workspaces.all())
+
+        # We should collect our garbages
+        contributor.delete() 
+        workspace.delete() 
+
+
+    def test_delete_nonexistent_workspace(self):
+        # Create a workspace, but don't add it to the contributor
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = Workspace.objects.create()
+
+        # Test the delete_workspace method with a non-existent workspace
+        contributor.delete_workspace(workspace)  # This should not raise an error
+
+        # We should collect our garbages 
+        contributor.delete() 
+        workspace.delete()
+
+class ReviewerModelTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        BasicUser.objects.all().delete()
+        Contributor.objects.all().delete()
+        Reviewer.objects.all().delete
+        print("All tests for the Reviewer Model are completed!")
+
+    def test_reviewer_create(self):
+        # Testing the creation of a new Reviewer
+        user = User.objects.create(
+            username="testuser",
+            email="test@example.com",
+            first_name="User",
+            last_name="Test",
+        )
+        reviewer = Reviewer.objects.create(user=user)
+
+
+        self.assertEqual(reviewer.user, user)
+
+        # Testing with default values
+        self.assertFalse(reviewer.email_notification_preference)
+        self.assertTrue(reviewer.show_activity_preference)
+
+    def test_get_review_requests(self):
+        # Create reviewer instances, note that username is a key.
+        reviewer1=Reviewer.objects.create(user=User.objects.create(username="First"))
+        reviewer2=Reviewer.objects.create(user=User.objects.create(username="Second"))
+
+        # Create review requests associated with the reviewer1
+        review_request1 = ReviewRequest.objects.create(reviewer=reviewer1)
+        review_request2 = ReviewRequest.objects.create(reviewer=reviewer1)
+
+        # Create a review request not associated with the reviewer1
+        other_review_request = ReviewRequest.objects.create(reviewer=reviewer2)
+
+        review_requests = reviewer1.get_review_requests()
+
+        # Ensure that the reviewer's review requests are in the queryset
+        self.assertIn(review_request1, review_requests)
+        self.assertIn(review_request2, review_requests)
+
+        # Ensure that the other_review_request is not in the queryset
+        self.assertNotIn(other_review_request, review_requests)
+
+        # We should collect our garbages
+        other_review_request.delete() 
+        review_requests.delete()
+        review_request1.delete() 
+        review_request2.delete() 
+        reviewer1.delete() 
+        reviewer2.delete() 
+
+    def test_inheritance(self):
+        # Create a contributor and it's workspace
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+
+        # Suppose this particular contributor becomes a reviewer
+        contributor.__class__= Reviewer
+        contributor.save()
+        reviewer = contributor
+
+        # Review request is issued to new reviewer
+        review_request = ReviewRequest.objects.create(reviewer=reviewer)
+        self.assertIn(review_request, reviewer.get_review_requests())
+
+        # Check if workspace is inherited
+        self.assertIn(workspace, reviewer.workspaces.all())
+
+        # We should collect our garbages
+        review_request.delete()
+        workspace.delete()
+        reviewer.delete()
+
 
 class NodeModelTestCase(TestCase):
     def tearDown(self):
@@ -186,6 +327,7 @@ def test_theorem_model(self):
         self.assertEqual(theorem.theorem_content, "This is a test theorem content.")
 
 
+
 class RegisterSerializerTestCase(TestCase):
     def setUp(self):
         self.data = {
@@ -264,3 +406,41 @@ def test_basic_user_serializer_fields(self):
             ["user", "bio", "email_notification_preference", "show_activity_preference"]
         )
         self.assertEqual(set(serializer.data.keys()), expected_fields)
+
+
+class ContributorSerializerTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        Contributor.objects.all().delete()
+        print("All tests for the ContributorSerializer are completed!")
+
+    def test_contributor_serializer_fields(self):
+        # Testing the fiels of the serializer
+
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+
+        serializer = ContributorSerializer(contributor)
+        expected_fields = set(
+            ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+        )
+        self.assertEqual(set(serializer.data.keys()), expected_fields)
+
+class ReviewerSerializerTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        Reviewer.objects.all().delete()
+        print("All tests for the ReviewerSerializer are completed!")
+
+    def test_reviewer_serializer_fields(self):
+        # Testing the fiels of the serializer
+
+        reviewer = Reviewer.objects.create(user=User.objects.create())
+        workspace = reviewer.create_workspace()
+
+        serializer = ReviewerSerializer(reviewer)
+        expected_fields = set(
+            ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+        )
+        self.assertEqual(set(serializer.data.keys()), expected_fields)
+