[api] Add API endpoints to manage repositories

This commit adds two new API endpoints for managing repositories:

- /scheduler/add_repository: This endpoint allows users to add a new
   repository for analysis.

- `/scheduler/repositories`: This endpoint provides a list of available
   repositories in GrimoireLab along with task information. It includes
   filtering options for backend, category, and URI.

Signed-off-by: Jose Javier Merchante <[email protected]>

Author: jjmerchante

src/grimoirelab/core/scheduler/api.py

@@ -30,6 +30,7 @@
     get_registered_task_model
 )
 from .tasks.models import EventizerTask
+from .datasources.models import Repository
 
 
 class EventizerPaginator(pagination.PageNumberPagination):
@@ -176,3 +177,33 @@ class EventizerJobLogs(generics.RetrieveAPIView):
     def get_queryset(self):
         task_id = self.kwargs['task_id']
         return get_registered_task_model('eventizer')[1].objects.filter(task__uuid=task_id)
+
+
+class EventizerRepositoryListSerializer(serializers.ModelSerializer):
+    task = EventizerTaskListSerializer()
+
+    class Meta:
+        model = Repository
+        fields = [
+            'uri', 'datasource_type', 'datasource_category', 'task',
+        ]
+
+
+class RepositoryList(generics.ListAPIView):
+    serializer_class = EventizerRepositoryListSerializer
+    pagination_class = EventizerPaginator
+
+    def get_queryset(self):
+        datasource = self.request.query_params.get('datasource')
+        category = self.request.query_params.get('category')
+        uri = self.request.query_params.get('uri')
+
+        queryset = Repository.objects.select_related('task')
+        if datasource is not None:
+            queryset = queryset.filter(datasource_type=datasource)
+        if category is not None:
+            queryset = queryset.filter(datasource_category=category)
+        if uri is not None:
+            queryset = queryset.filter(uri=uri)
+
+        return queryset

src/grimoirelab/core/scheduler/urls.py

@@ -24,6 +24,8 @@
 
 urlpatterns = [
     re_path(r'^add_task', views.add_task),
+    re_path(r'^add_repository', views.add_repository, name='add_repository'),
+    path('repositories/', api.RepositoryList.as_view()),
     path('tasks/', api.EventizerTaskList.as_view()),
     path('tasks/<str:uuid>/', api.EventizerTaskDetail.as_view()),
     path('tasks/<str:task_id>/jobs/', api.EventizerJobList.as_view()),

src/grimoirelab/core/scheduler/views.py

@@ -19,10 +19,12 @@
 import json
 
 from django.conf import settings
+from django.db import IntegrityError
 from django.http import JsonResponse
 from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_http_methods
 
+from .datasources.models import Repository
 from .scheduler import (
     schedule_task
 )
@@ -78,3 +80,66 @@ def add_task(request):
         'message': f"Task {task.id} added correctly"
     }
     return JsonResponse(response, safe=False)
+
+
+@require_http_methods(["POST"])
+@csrf_exempt
+def add_repository(request):
+    """Create a Repository and start a Task to fetch items
+
+    The body should contain a JSON similar to:
+    {
+        'uri': "<repository_uri>",
+        'datasource_type': 'git',
+        'datasource_category': 'commit',
+        'scheduler': {
+            'job_interval': 86400,
+            'job_max_retries': 3,
+        }
+    }
+    """
+    try:
+        data = json.loads(request.body)
+    except json.JSONDecodeError:
+        return JsonResponse({"error": "Invalid JSON format."}, status=400)
+
+    # Get POST data
+    job_interval = settings.GRIMOIRELAB_JOB_INTERVAL
+    job_max_retries = settings.GRIMOIRELAB_JOB_MAX_RETRIES
+    if 'scheduler' in data:
+        job_interval = data['scheduler'].get('job_interval', job_interval)
+        job_max_retries = data['scheduler'].get('job_max_retries', job_max_retries)
+
+    uri = data.get('uri')
+    datasource_type = data.get('datasource_type')
+    datasource_category = data.get('datasource_category')
+    if not uri or not datasource_type or not datasource_category:
+        return JsonResponse({"error": "Missing parameters"}, status=400)
+
+    # Create the task and the repository
+    try:
+        repository = Repository.objects.create(uri=uri,
+                                               datasource_type=datasource_type,
+                                               datasource_category=datasource_category)
+    except IntegrityError:
+        return JsonResponse({"error": "Repository already exists"}, status=405)
+
+    task_args = {
+        'uri': data['uri']
+    }
+    task = schedule_task(
+        'eventizer', task_args,
+        datasource_type=datasource_type,
+        datasource_category=datasource_category,
+        job_interval=job_interval,
+        job_max_retries=job_max_retries
+    )
+    repository.task = task
+    repository.save()
+
+    response = {
+        'status': 'ok',
+        'task_id': repository.task.uuid,
+        'message': f"Repository {uri} added correctly"
+    }
+    return JsonResponse(response, safe=False)

tests/scheduler/test_views.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) GrimoireLab Contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from django.test import TestCase, Client
+from django.urls import reverse
+from unittest.mock import patch
+import json
+
+from grimoirelab.core.scheduler.tasks.models import EventizerTask
+from grimoirelab.core.scheduler.datasources.models import Repository
+
+
+class TestAddRepository(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.url = reverse('add_repository')
+        self.valid_data = {
+            'uri': "https://example.com/repo.git",
+            'datasource_type': 'git',
+            'datasource_category': 'commit',
+            'scheduler': {
+                'job_interval': 86400,
+                'job_max_retries': 3,
+                'force_run': False
+            }
+        }
+        self.task = EventizerTask.create_task(
+            task_args={'uri': 'uri'},
+            job_interval=86400,
+            job_max_retries=3,
+            datasource_type='git',
+            datasource_category='commit'
+        )
+
+    @patch('grimoirelab.core.scheduler.views.schedule_task')
+    def test_add_repository_valid(self, mock_schedule_task):
+        """Test adding a repository with valid data"""
+
+        mock_schedule_task.return_value = self.task
+
+        response = self.client.post(
+            self.url,
+            data=json.dumps(self.valid_data),
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {
+            'status': 'ok',
+            'task_id': self.task.uuid,
+            'message': f"Repository {self.valid_data['uri']} added correctly"
+        })
+
+    def test_add_repository_invalid_json(self):
+        """Test adding a repository with invalid JSON"""
+
+        response = self.client.post(
+            self.url,
+            data="invalid json",
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json(), {"error": "Invalid JSON format."})
+
+    def test_add_repository_missing_parameters(self):
+        """Test adding a repository with missing parameters"""
+
+        invalid_data = self.valid_data.copy()
+        del invalid_data['uri']
+
+        response = self.client.post(
+            self.url,
+            data=json.dumps(invalid_data),
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json(), {"error": "Missing parameters"})
+
+    def test_add_repository_already_exists(self):
+        """Test adding a repository that already exists"""
+
+        # Make the repository already existing
+        existing_repository = Repository.objects.create(
+            uri="https://example.com/repo.git",
+            datasource_type="git",
+            datasource_category="commit",
+            task=self.task
+        )
+        response = self.client.post(
+            self.url,
+            data=json.dumps(self.valid_data),
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 405)
+        self.assertEqual(response.json(), {"error": "Repository already exists"})