adding agentSP and tests for F02, updating other tests according new attributes of SCP

Alexis Koralewski
1 parent b6a13fc4
Showing 18 changed files with 1293 additions and 416 deletions Show diff stats
pyros.py
src/core/pyros_django/common/models.py
src/core/pyros_django/misc/fixtures/tests/scientific_program_TZ.json
src/core/pyros_django/obsconfig/tests.py
src/core/pyros_django/pyros/settings.py
src/core/pyros_django/scheduler/Scheduler.py
src/core/pyros_django/scheduler/UserManager.py
src/core/pyros_django/scientific_program/AgentSP.py
src/core/pyros_django/scientific_program/functions.py
src/core/pyros_django/scientific_program/templates/scientific_program/create_period.html
src/core/pyros_django/scientific_program/templates/scientific_program/period_detail.html
src/core/pyros_django/scientific_program/templates/scientific_program/scientific_program_detail.html
src/core/pyros_django/scientific_program/templates/scientific_program/test_tac_auto.html
src/core/pyros_django/scientific_program/tests.py
src/core/pyros_django/scientific_program/urls.py
src/core/pyros_django/scientific_program/views.py
src/core/pyros_django/user_manager/tests.py
@@ -37,7 +37,8 @@ AGENTS = {
     "agentX" : "AgentX", 
     "agentA" : "AgentA", 
     "agentB" : "AgentB", 
-    "agentM" : "AgentM", 
+    "agentM" : "AgentM",
+    "agentSP" : "AgentSP", 
     #"agentDevice" : "AgentDevice", 
     #"agentDeviceTelescopeGemini" : "AgentDeviceTelescopeGemini",
     "agentDeviceGemini" : "AgentDeviceGemini",
@@ -524,8 +525,8 @@ def test(app):
     #start_dir = os.getcwd()
     if app == None:
         #apps = ['obsconfig','scientific_program','common', 'scheduler', 'routine_manager', 'user_manager', 'alert_manager.tests.TestStrategyChange']
-        # Removing temporiraly scientific_program and alert_manager from tests
-        apps = ['obsconfig','common', 'scheduler', 'routine_manager', 'user_manager']
+        # Removing alert_manager from tests
+        apps = ['obsconfig',"scientific_program",'common', 'scheduler', 'routine_manager', 'user_manager']
     else:
         os.environ["PATH_TO_OBSCONF_FILE"] = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"obsconfig/fixtures/observatory_configuration_ok_simple.yml")
         change_dir(PYROS_DJANGO_BASE_DIR)
@@ -712,6 +713,8 @@ def start(agent:str, configfile:str,observatory:str):
                 ##agentX.run(FOR_REAL=True)
                 if agent_name == "agentM": 
                     os.chdir(PYROS_DJANGO_BASE_DIR+"/monitoring/")
+                elif agent_name == "agentSP":
+                    os.chdir(PYROS_DJANGO_BASE_DIR+"/scientific_program/")
                 else:
                     os.chdir(PYROS_DJANGO_BASE_DIR+"/agent/")
                 #cmd = "-m AgentX"
@@ -10,7 +10,7 @@ from typing import List
 from django.core.validators import MaxValueValidator, MinValueValidator
  
 # DJANGO imports
-from django.contrib.auth.models import AbstractUser
+from django.contrib.auth.models import AbstractUser, UserManager
 from django.db import models
 from django.db.models import Q, Max
 from django.core.validators import MaxValueValidator, MinValueValidator
@@ -1234,7 +1234,6 @@ class ScienceTheme(models.Model):
  
     def __str__(self) -> str:
         return str(self.name)
-
 class Institute(models.Model):
     name = models.CharField(max_length=100,blank=False,null=False,unique=True)
     quota = models.IntegerField(validators=[MinValueValidator(0), MaxValueValidator(100)])
@@ -1243,6 +1242,13 @@ class Institute(models.Model):
     def __str__(self) -> str:
         return str(self.name)
  
+class PyrosUserManager(UserManager):
+    def tac_users(self):
+        return PyrosUser.objects.filter(user_level__name="TAC")
+    
+    def unit_users(self):
+        return PyrosUser.objects.filter(Q(user_level__name="Unit-PI")|Q(user_level__name="Unit-board"))
+
 class PyrosUser(AbstractUser):
     username = models.CharField(max_length=255, blank=False, null=False, unique=True)
     is_active = models.BooleanField(default='False')
@@ -1274,6 +1280,8 @@ class PyrosUser(AbstractUser):
     # can_del_void_req = models.BooleanField(default=False)
     validator = models.ForeignKey("PyrosUser", on_delete=models.DO_NOTHING, null=True, related_name="pyros_users")
     referee_themes = models.ManyToManyField("ScienceTheme",related_name="referee_themes",blank=True)
+
+    objects = PyrosUserManager()
     class Meta:
         managed = True
         db_table = 'pyros_user'
@@ -1397,7 +1405,6 @@ class PeriodManager(models.Manager):
         submission_periods_id = []
         periods = Period.objects.filter(start_date__gte=today)
         for period in periods:
-            print(period)
             if period.submission_start_date <= today and period.submission_end_date > today:
                 submission_periods_id.append(period.id)
         periods = periods.filter(id__in=submission_periods_id)
@@ -1418,7 +1425,7 @@ class PeriodManager(models.Manager):
         validation_periods_id = []
         periods = Period.objects.filter(start_date__gte=today)
         for period in periods:
-            if period.unit_pi_validation_start_date >= today and period.notification_start_date < today:
+            if period.unit_pi_validation_start_date <= today and period.notification_start_date > today:
                 validation_periods_id.append(period.id)
         periods = periods.filter(id__in=validation_periods_id)
         return periods
@@ -1428,7 +1435,7 @@ class PeriodManager(models.Manager):
         notification_periods_id = []
         periods = Period.objects.filter(start_date__gte=today)
         for period in periods:
-            if period.notification_start_date >= today and period.start_date < today:
+            if period.notification_start_date <= today and period.start_date > today:
                 notification_periods_id.append(period.id)
         periods = periods.filter(id__in=notification_periods_id)
         return periods
@@ -1453,6 +1460,12 @@ class PeriodManager(models.Manager):
         today = timezone.now().date()
         previous_periods = Period.objects.filter(start_date__lt=today).order_by("-start_date").exclude(id=self.exploitation_period().id)
         return previous_periods
+    
+    def next_period(self)->any:
+        current_period = self.exploitation_period()
+        next_period =  Period.objects.filter(start_date__gt=current_period.start_date).order_by("start_date").first()
+        return next_period
+
  
 class Period(models.Model):
     # if change of default value, those values need to be changed also in create_period and edit_period.html (Javascript )
@@ -1467,7 +1480,7 @@ class Period(models.Model):
     start_date = models.DateField(blank=True, null=True, default=timezone.now,editable=True)    
  
     exploitation_duration =  models.PositiveIntegerField(blank=True, null=True, default=182,editable=True)    
-    submission_duration = models.PositiveIntegerField(blank=True, null=True, default=182,editable=True)    
+    submission_duration = models.PositiveIntegerField(blank=True, null=True, default=136,editable=True)    
     evaluation_duration = models.PositiveIntegerField(blank=True,null=True,default=31,editable=True)
     validation_duration = models.PositiveIntegerField(blank=True, null=True, default=5,editable=True)    
     notification_duration = models.PositiveIntegerField(blank=True, null=True, default=10,editable=True)    
@@ -1480,19 +1493,19 @@ class Period(models.Model):
  
     @property
     def submission_start_date(self):
-        return self.start_date + relativedelta(days=-self.exploitation_duration)
+        return self.start_date + relativedelta(days=-(self.submission_duration+self.evaluation_duration+self.validation_duration+self.notification_duration))
  
     @property
     def submission_end_date(self):
-        return self.start_date + relativedelta(days=-self.evaluation_duration)
+        return self.submission_start_date + relativedelta(days=self.submission_duration)
  
     @property
     def unit_pi_validation_start_date(self):
-        return self.start_date + relativedelta(days=-self.validation_duration)
+        return self.submission_end_date + relativedelta(days=self.evaluation_duration)
  
     @property
     def notification_start_date(self):
-        return self.start_date + relativedelta(days=-self.notification_duration)
+        return self.unit_pi_validation_start_date + relativedelta(days=self.validation_duration)
  
     @property
     def property_of_data_end_date(self):
@@ -1616,6 +1629,22 @@ class SP_Period_User(models.Model):
 class SP_Period_Guest(models.Model):
     SP_Period = models.ForeignKey(SP_Period, on_delete=models.DO_NOTHING,related_name="SP_Period_Guests")
     email = models.EmailField(max_length=254)
+
+class SP_PeriodWorkflow(models.Model):
+    SUBMISSION = "SUB"
+    EVALUATION = "EVAL"
+    VALIDATION = "VALI"
+    NOTIFICATION = "NOTI"
+    ACTIONS_CHOICES = (
+        (SUBMISSION,"Submission"),
+        (EVALUATION,"Evaluation"),
+        (VALIDATION,"Validation"),
+        (NOTIFICATION,"Notification")
+    )
+    action = models.CharField(max_length=120,choices=ACTIONS_CHOICES)
+    period = models.ForeignKey("Period",on_delete=models.DO_NOTHING,related_name="SP_Period_Workflows")
+    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
+
 class Sequence(models.Model):
  
     """ Definition of Status enum values """
@@ -126,7 +126,7 @@
         "username": "observer",
         "first_name": "",
         "last_name": "",
-        "email": "",
+        "email": "observer@test.com",
         "is_staff": true,
         "is_active": true,
         "date_joined": "2016-05-02T14:02:36.495Z",
@@ -153,7 +153,7 @@
         "username": "tac",
         "first_name": "",
         "last_name": "",
-        "email": "",
+        "email": "tac@test.com",
         "is_staff": true,
         "is_active": true,
         "date_joined": "2016-05-02T14:02:36.495Z",
@@ -167,7 +167,8 @@
         "tel": "",
         "address": "",
         "laboratory": "",
-        "institute": 1
+        "institute": 1,
+        "referee_themes":[1]
     }
 },
 {
@@ -180,7 +181,7 @@
         "username": "unit_pi",
         "first_name": "",
         "last_name": "",
-        "email": "",
+        "email": "unit_pi@test.com",
         "is_staff": true,
         "is_active": true,
         "date_joined": "2016-05-02T14:02:36.495Z",
@@ -207,7 +208,7 @@
         "username": "operator",
         "first_name": "",
         "last_name": "",
-        "email": "",
+        "email": "operator@test.com",
         "is_staff": true,
         "is_active": true,
         "date_joined": "2016-05-02T14:02:36.495Z",
@@ -234,7 +235,89 @@
         "username": "observer2",
         "first_name": "",
         "last_name": "",
-        "email": "",
+        "email": "observer2@test.com",
+        "is_staff": true,
+        "is_active": true,
+        "date_joined": "2016-05-02T14:02:36.495Z",
+        "groups": [],
+        "user_permissions": [],
+        "country": 1,
+        "user_level": [2],
+        "desc": "",
+        "created": "2016-06-03T09:29:15.450Z",
+        "updated": "2016-06-03T09:29:15.450Z",
+        "tel": "",
+        "address": "",
+        "laboratory": "",
+        "institute": 1
+    }
+},
+{
+    "model": "common.pyrosuser",
+    "pk": 7,
+    "fields": {
+        "password": "pbkdf2_sha256$24000$NC9UO4LPGvDN$+pkRcZUbmV3HEtbrhBdDCSPnAsDVValrbwLt7cXqrJE=",
+        "last_login": "2016-06-03T09:27:53.245Z",
+        "is_superuser": false,
+        "username": "tac2",
+        "first_name": "",
+        "last_name": "",
+        "email": "tac2@test.com",
+        "is_staff": true,
+        "is_active": true,
+        "date_joined": "2016-05-02T14:02:36.495Z",
+        "groups": [],
+        "user_permissions": [],
+        "country": 1,
+        "user_level": [3],
+        "desc": "",
+        "created": "2016-06-03T09:29:15.450Z",
+        "updated": "2016-06-03T09:29:15.450Z",
+        "tel": "",
+        "address": "",
+        "laboratory": "",
+        "institute": 1,
+        "referee_themes":[1]
+    }
+},
+{
+    "model": "common.pyrosuser",
+    "pk": 8,
+    "fields": {
+        "password": "pbkdf2_sha256$24000$NC9UO4LPGvDN$+pkRcZUbmV3HEtbrhBdDCSPnAsDVValrbwLt7cXqrJE=",
+        "last_login": "2016-06-03T09:27:53.245Z",
+        "is_superuser": false,
+        "username": "observer3",
+        "first_name": "",
+        "last_name": "",
+        "email": "observer3@test.com",
+        "is_staff": true,
+        "is_active": true,
+        "date_joined": "2016-05-02T14:02:36.495Z",
+        "groups": [],
+        "user_permissions": [],
+        "country": 1,
+        "user_level": [2],
+        "desc": "",
+        "created": "2016-06-03T09:29:15.450Z",
+        "updated": "2016-06-03T09:29:15.450Z",
+        "tel": "",
+        "address": "",
+        "laboratory": "",
+        "institute": 1
+    }
+},
+{
+    "model": "common.pyrosuser",
+    "pk": 9,
+    "fields": {
+        "password": "pbkdf2_sha256$24000$NC9UO4LPGvDN$+pkRcZUbmV3HEtbrhBdDCSPnAsDVValrbwLt7cXqrJE=",
+        "last_login": "2016-06-03T09:27:53.245Z",
+        "is_superuser": false,
+        "username": "observer4",
+        "first_name": "",
+        "last_name": "",
+        "email": "observer4@test.com",
         "is_staff": true,
         "is_active": true,
         "date_joined": "2016-05-02T14:02:36.495Z",
@@ -250,5 +333,26 @@
         "laboratory": "",
         "institute": 1
     }
+},
+{
+    "model":"common.ScienceTheme",
+    "pk":1,
+    "fields":{
+        "name":"Solar System"
+    }
+},
+{
+    "model":"common.ScienceTheme",
+    "pk":2,
+    "fields":{
+        "name":"Galatic"
+    }
+},
+{
+    "model":"common.ScienceTheme",
+    "pk":3,
+    "fields":{
+        "name":"Extra Galatic"
+    }
 }
 ]
 \ No newline at end of file
@@ -39,7 +39,7 @@ class ObservatoryConfigurationTests(TestCase):
         u1 = PyrosUser.objects.get(username="haribo")
         u1.set_password("password123")
         u1.save()
-        self.client.login(username="haribo",password="password123")
+        self.client.post(reverse("login_validation"),{"email":"haribo","password":"password123"})
         response = self.client.get(reverse('obs_astronomer_config'))
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, 'base.html')
@@ -57,7 +57,8 @@ class ObservatoryConfigurationTests(TestCase):
         u1 = PyrosUser.objects.get(username="haribo")
         u1.set_password("password123")
         u1.save()
-        self.client.login(username="haribo",password="password123")
+        #self.client.login(username="haribo",password="password123")
+        self.client.post(reverse("login_validation"),{"email":"haribo","password":"password123"})
         response = self.client.get(reverse('obs_astronomer_config'))
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, 'base.html')
@@ -399,7 +399,7 @@ EMAIL_BACKEND = &#39;django.core.mail.backends.console.EmailBackend&#39;
  
 python_version = subprocess.run( "python --version | cut -d ' ' -f 2 | cut -d '.' -f 1,2",shell=True,stdout=subprocess.PIPE,universal_newlines=True)
 python_version = python_version.stdout
-today = "2021-10-14"
+today = "2021-11-02"
 django_version_major,django_version_minor = django.VERSION[:2][0],django.VERSION[:2][1] 
-pyros_version = "0.2.10.0"
+pyros_version = "0.2.11.0"
 VERSION_NUMBER = f"{pyros_version}_{django_version_major}.{django_version_minor}_{python_version}_{today}"
 \ No newline at end of file
 from operator import attrgetter
  
 from scheduler.templatetags.jdconverter import jdtodate
-from .UserManager import UserManager
+from .UserManager import UserQuotaManager
 from .Interval import *
 from django.db.models import Q
  
@@ -221,11 +221,11 @@ class Scheduler(IntervalManagement):
         #print("sequences are", self.sequences)
         for sequence, shs in list(self.sequences):
             #print("placeSequences() sequence is", sequence)
-            quota = UserManager.determineQuota(sequence)
+            quota = UserQuotaManager.determineQuota(sequence)
             #print("quota is", quota)
-            if not UserManager.isSufficient(quota, sequence):
+            if not UserQuotaManager.isSufficient(quota, sequence):
                 shs.status = Sequence.REJECTED
-                shs.desc = UserManager.REJECTED
+                shs.desc = UserQuotaManager.REJECTED
                 continue
             matching_intervals = self.getMatchingIntervals(sequence)
             if len(matching_intervals) > 0:
@@ -350,7 +350,7 @@ class Scheduler(IntervalManagement):
         return 0
  
     def decreaseQuota(self, sequence: Sequence, quota: float) -> int:
-        user = UserManager(sequence.request.pyros_user)
+        user = UserQuotaManager(sequence.request.pyros_user)
         if SIMULATION:
             return 0
         return user.decreaseQuota(Decimal(quota))
@@ -2,7 +2,7 @@ from common.models import *
 from utils.Logger import *
 from decimal import *
  
-class UserManager(Logger):
+class UserQuotaManager(Logger):
     REJECTED = "Insufficient quota"
  
     def __init__(self, user: PyrosUser):
@@ -0,0 +1,222 @@
+import sys
+
+sys.path.append("..")
+sys.path.append("../../../..")
+from src.core.pyros_django.agent.Agent import Agent, build_agent
+from common.models import Period, SP_Period, PyrosUser, SP_Period_Guest, SP_PeriodWorkflow, ScientificProgram,SP_Period_User, ScienceTheme
+from django.shortcuts import reverse
+from django.conf import settings
+from django.core.mail import send_mail
+from dateutil.relativedelta import relativedelta
+from django.db.models import Q
+from django.utils import timezone
+from django.test.utils import setup_test_environment
+import numpy as np
+
+class AgentSP(Agent):
+
+    period = None
+
+    def __init__(self, config_filename=None, RUN_IN_THREAD=True,use_db_test=False):
+        ##if name is None: name = self.__class__.__name__
+        if use_db_test:
+            print("USE DB TEST")
+            setup_test_environment()
+        super().__init__(None, RUN_IN_THREAD)
+        print(Period.objects.all())
+        next_period = Period.objects.next_period()
+        period = next_period
+
+    # @override
+    def init(self):
+        super().init()
+
+    def associate_tac_sp_auto(self,themes,tac_users,scientific_programs):
+        print("Associating tac to sp")
+        matrix_tac_themes = np.zeros([len(tac_users),len(themes)])
+        maxtrix_themes_sp = np.zeros([len(themes),len(scientific_programs)])
+        matrix_tac_sp = np.zeros([len(tac_users),len(scientific_programs)])
+        for i,tac_user in enumerate(tac_users):
+            for j,theme in enumerate(themes):
+                if theme.name in tac_user.get_referee_themes_as_str():
+                    matrix_tac_themes[i,j] = 1
+        for i,theme in enumerate(themes):
+            for j,sp in enumerate(scientific_programs):
+                if theme.id == sp.science_theme.id:
+                    maxtrix_themes_sp[i,j] = 1
+        matrix_tac_sp = np.dot(matrix_tac_themes,maxtrix_themes_sp)
+        nb_tac_per_sp = np.sum(matrix_tac_sp,axis=0)
+        next_period = Period.objects.next_period()
+        for i,sp in enumerate(scientific_programs):
+            if nb_tac_per_sp[i-1] == 2:
+                # We auto assign the tac users to scientific programs
+                print(sp)
+                sp_period = SP_Period.objects.get(scientific_program=sp,period=next_period)
+                available_tac_users = PyrosUser.objects.filter(referee_themes=sp.science_theme)
+                print("available tacs :")
+                print(available_tac_users)
+                sp_period.referee1 = available_tac_users[0]
+                sp_period.referee2 = available_tac_users[1]
+                sp_period.save()
+        #return matrix_tac_sp
+
+    def change_sp_status(self,scientific_programs,new_status):
+        print(f"---- CHANGE STATUS FOR {scientific_programs} TO {new_status}------- ")
+        for sp in scientific_programs:
+            if sp.status != new_status:
+                sp.status = new_status
+                sp.save()
+
+    def send_mail_to_tac_for_evaluation(self,tac_users,next_period):
+        domain = settings.DEFAULT_DOMAIN
+        url = f"{domain}{reverse('list_submitted_scientific_program')}"
+        mail_subject = '[PyROS CC] The evaluation period is now opened'
+        mail_message = (f"Hi,\n\nYou can now evaluate scientific programs for the next period ({next_period}).\n"
+                        f"Click on the following link {url} to evaluate your assignated scientific programs."
+                        "\n\nCordially,\n\nPyROS Control Center")
+        email_list = tac_users.values_list("email")
+        for email in email_list:
+            send_mail(
+                mail_subject,
+                mail_message,
+                from_email=None,
+                recipient_list=[email],
+                fail_silently=False,
+            )
+
+    def send_mail_to_observers_for_notification(self,sp_periods):
+        for sp_period in sp_periods:
+            sp_pi = sp_period.scientific_program.sp_pi
+            scientific_program = sp_period.scientific_program
+            domain = settings.DEFAULT_DOMAIN
+            url = f"{domain}{reverse('sp_register',args=(scientific_program.pk,sp_period.period.pk))}"
+            mail_subject = '[PyROS CC] New registration to a scientific program'
+            mail_message = (f"Hi,\n\nYou were invited to join a scientific program that as been submitted using PyROS.\n"
+                            f"The name of the scientific program is {scientific_program.name} and his PI is {sp_pi.first_name} {sp_pi.last_name}.\n"
+                            f"To accept this invitation, click on the following link : {url}\n"
+                            f"Once you have joined the scientific program, you can start to submit sequences"
+                            "You might be asked to login first and will be redirected to the scientific program page.\n"
+                            "If the redirection doesn't work, click again on the link after you've logged in.\n"
+                            "If you don't own an PyROS account, go on the website in order to create an account with the same mail adress that you are using to read this mail."
+                            "\n\nCordially,\n\nPyROS Control Center")
+            invited_observers_of_sp = SP_Period_Guest.objects.filter(SP_Period=sp_period).values("user")
+            recipient_list = invited_observers_of_sp
+            for invited_observer in recipient_list:
+                send_mail(
+                    mail_subject,
+                    mail_message,
+                    from_email=None,
+                    recipient_list=[invited_observer],
+                    fail_silently=False,
+                )
+    
+    def send_mail_to_unit_users_for_tac_assignation(self):
+        domain = settings.DEFAULT_DOMAIN
+        url = f"{domain}{reverse('list_drafted_scientific_program')}"
+        mail_subject = '[PyROS CC] TAC assignation to scientific programs for the next period'
+        mail_message = (f"Hi,\n\nYou can assign TAC users to scientific programs by choosing them in the {url} page.\n"
+                        "PyROS has suggested TAC to some of the scientific programs but you can change those assignations.\n"
+                        f"The TAC assignation will be effective and couldn't be modified at the {self.period.submission_end_date}.\n"
+                        "\n\nCordially,\n\nPyROS Control Center")
+        unit_users = PyrosUser.objects.unit_users().values_list("email",flat=True)
+        send_mail(
+            mail_subject,
+            mail_message,
+            from_email=None,
+            recipient_list=unit_users,
+            fail_silently=False,
+        )
+        print("--------- SEND MAIL TO UNIT USERS ----------")
+
+
+    def automatic_period_workflow(self):
+        today = timezone.now().date()
+        next_period = Period.objects.next_period()
+        # check if next_period has changed
+        if self.period != next_period:
+            self.period = next_period
+        # get scientific program for next_period 
+        next_sp = SP_Period.objects.filter(period=next_period)
+        auto_validated_sp = ScientificProgram.objects.filter(is_auto_validated=True)
+        auto_validated_sp_periods = SP_Period.objects.filter(scientific_program__in=auto_validated_sp,period=next_period)
+        # remove auto validated sp from next_sp
+        next_sp = next_sp.exclude(scientific_program__in=auto_validated_sp)
+        # get all tac users 
+        tac_users = PyrosUser.objects.filter(user_level__name="TAC")
+        # submission workflow
+        if not SP_PeriodWorkflow.objects.filter(action=SP_PeriodWorkflow.SUBMISSION, period=self.period).exists():
+            print("routine automatic period workflow SUBMISSION")
+            # if the next_period is actually in the "submission" subperiod 
+            if next_period in Period.objects.submission_periods():
+                # we have to assign TAC to SP 
+                themes = ScienceTheme.objects.all()
+                # get id of scientific programs from SP_Period
+                sp_id = next_sp.exclude(scientific_program__is_auto_validated=True).filter(Q(referee1=None)|Q(referee2=None)).values("scientific_program")
+                # get scientific programs
+                sp = ScientificProgram.objects.filter(id__in=sp_id).order_by("name")
+                # if we are ten days before the end of the submission period, we have to assign TAC to scientific programs 
+                # and send a mail to the Unit users to they assign the TAC users to SP
+                if next_period.submission_end_date + relativedelta(days=-10) == today :
+                    self.associate_tac_sp_auto(themes,tac_users,sp)
+                    # send mail to unit pi to tell him to associate TAC to SP 
+                    self.send_mail_to_unit_users_for_tac_assignation()
+                    SP_PeriodWorkflow.objects.create(period=self.period,action=SP_PeriodWorkflow.SUBMISSION) 
+
+        if not SP_PeriodWorkflow.objects.filter(action=SP_PeriodWorkflow.EVALUATION, period=self.period).exists():
+            print("routine automatic period workflow EVALUATION")
+            if next_period in Period.objects.evaluation_periods() and next_period.submission_end_date == today :
+                next_sp = SP_Period.objects.filter(period=next_period).exclude(scientific_program__in=auto_validated_sp).filter(status=SP_Period.STATUSES_DRAFT)
+                self.change_sp_status(next_sp,SP_Period.STATUSES_SUBMITTED)
+                self.send_mail_to_tac_for_evaluation(tac_users,next_period)
+
+                # for auto validated sp, we have to change their status
+                self.change_sp_status(auto_validated_sp_periods,SP_Period.STATUSES_ACCEPTED)    
+                for sp in auto_validated_sp_periods:
+                    sp.is_valid = SP_Period.IS_VALID_ACCEPTED
+                    sp.save()
+                    
+                SP_PeriodWorkflow.objects.create(period=self.period,action=SP_PeriodWorkflow.EVALUATION)
+        if not SP_PeriodWorkflow.objects.filter(action=SP_PeriodWorkflow.VALIDATION, period=self.period).exists():
+            print("routine automatic period workflow VALIDATION")
+            if next_period.unit_pi_validation_start_date == today :
+                next_sp = SP_Period.objects.filter(period=next_period).exclude(scientific_program__in=auto_validated_sp).filter(status=SP_Period.STATUSES_SUBMITTED)
+                self.change_sp_status(next_sp,SP_Period.STATUSES_EVALUATED)
+                next_sp = SP_Period.objects.filter(period=next_period).exclude(scientific_program__in=auto_validated_sp).filter(status=SP_Period.STATUSES_EVALUATED)
+                SP_PeriodWorkflow.objects.create(period=self.period,action=SP_PeriodWorkflow.VALIDATION)
+        if not SP_PeriodWorkflow.objects.filter(action=SP_PeriodWorkflow.NOTIFICATION, period=self.period).exists():
+            print("routine automatic period workflow NOTIFICATION")
+            if next_period in Period.objects.notification_periods():
+                next_sp_accepted = SP_Period.objects.filter(period=next_period).filter(is_valid=SP_Period.IS_VALID_ACCEPTED)
+                self.change_sp_status(next_sp_accepted,SP_Period.STATUSES_ACCEPTED)
+                next_sp_rejected = SP_Period.objects.filter(period=next_period).filter(is_valid=SP_Period.IS_VALID_REJECTED)
+                self.change_sp_status(next_sp_rejected,SP_Period.STATUSES_REJECTED)
+                next_sp_to_be_notified = next_sp.filter(status=SP_Period.STATUSES_ACCEPTED,is_valid = True)
+                self.send_mail_to_observers_for_notification(next_sp_to_be_notified)
+                SP_PeriodWorkflow.objects.create(period=self.period,action=SP_PeriodWorkflow.NOTIFICATION)
+
+    def routine_process_body(self):
+        print("routine automatic period workflow")
+        print(SP_PeriodWorkflow.objects.all())
+        for sp_period_workflow in SP_PeriodWorkflow.objects.all():
+            print(sp_period_workflow.period)
+            print(sp_period_workflow.action)
+        self.automatic_period_workflow()
+
+
+if __name__ == "__main__":
+
+    # with thread
+    RUN_IN_THREAD=True
+    # with process
+    #RUN_IN_THREAD=False
+    if len(sys.argv) > 1 and sys.argv[1] == "test":
+        agent = AgentSP(None,RUN_IN_THREAD=RUN_IN_THREAD,use_db_test=True)
+    else:
+        agent = build_agent(AgentSP, RUN_IN_THREAD=RUN_IN_THREAD)
+    '''
+    TEST_MODE, configfile = extract_parameters()
+    agent = AgentM("AgentM", configfile, RUN_IN_THREAD)
+    agent.setSimulatorMode(TEST_MODE)
+    '''
+    print(agent)
+    agent.run()
-from common.models import Period
 from dateutil.relativedelta import relativedelta
  
 def get_svg_timeline(previous_period,current_period,future_period):
@@ -145,19 +145,24 @@ function loadDate(){
     // set date for each duration
  
     duration_value = parseInt($("#id_submission_duration").val())
-    date = period_start_date.addDays(-duration_value);
+    proposal_duration = parseInt($("#id_submission_duration").val()) + parseInt($("#id_evaluation_duration").val()) 
+    + parseInt($("#id_validation_duration").val()) + parseInt($("#id_notification_duration").val());
+    date = period_start_date.addDays(-proposal_duration);
+    submission_start_date = date;
     $("#submission_duration_date").html(date.toLocaleDateString("en-GB"));
  
     duration_value = parseInt($("#id_evaluation_duration").val())
-    date = period_start_date.addDays(-duration_value);
+    date = submission_start_date.addDays(duration_value);
+    evaluation_start_date = date;
     $("#evaluation_duration_date").html(date.toLocaleDateString("en-GB"));
  
     duration_value = parseInt($("#id_validation_duration").val())
-    date = period_start_date.addDays(-duration_value);
+    date = evaluation_start_date.addDays(duration_value);
+    validation_start_date = date;
     $("#validation_duration_date").html(date.toLocaleDateString("en-GB"));
  
     duration_value = parseInt($("#id_notification_duration").val())
-    date = period_start_date.addDays(-duration_value);
+    date = validation_start_date.addDays(duration_value);
     $("#notification_duration_date").html(date.toLocaleDateString("en-GB"));
  
     duration_value = parseInt($("#id_exploitation_duration").val())
@@ -180,52 +185,32 @@ $( document ).ready(function() {
  
 // IMPORTANT NOTE : In Javascript Month count start to zero (Zero is january, 1 is february etc) 
 $("#id_exploitation_duration").on("input",function(){
-    duration_value = parseInt($("#id_exploitation_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#exploitation_duration_date").html(date.toLocaleDateString("en-GB"));
+    loadDate();
 });
  
 $("#id_submission_duration").on("input",function(){
-    duration_value = parseInt($("#id_submission_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#submission_duration_date").html(date.toLocaleDateString("en-GB"));
+    loadDate();
 });
  
 $("#id_evaluation_duration").on("input",function(){
-    duration_value = parseInt($("#id_evaluation_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#evaluation_duration_date").html(date.toLocaleDateString("en-GB"));
+    loadDate();
 });
  
-$("#id_notation_duration").on("input",function(){
-    duration_value = parseInt($("#id_notation_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#notation_duration_date").html(date.toLocaleDateString("en-GB"));
+$("#id_validation_duration").on("input",function(){
+    loadDate();
+});
+
+$("#id_notification_duration").on("input",function(){
+    loadDate();
 });
  
  
 $("#id_property_of_data_duration").on("input",function(){
-    duration_value = parseInt($("#id_property_of_data_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#property_of_data_duration_date").html(date.toLocaleDateString("en-GB"));
+    loadDate();
 });
  
 $("#id_data_accessibility_duration").on("input",function(){
-    duration_value = parseInt($("#id_data_accessibility_duration").val())
-    split = $("#start_date_picker").val().split("/");
-    period_start_date = new Date(split[2],split[1]-1,split[0]);
-    date = period_start_date.addDays(duration_value);
-    $("#data_accessibility_duration_date").html(date.toLocaleDateString("en-GB"));
+    loadDate();
 });
  
 $(function() {
@@ -18,6 +18,7 @@
     <p><strong>Submission start date : </strong>{{ period.submission_start_date }}</p>
     <p><strong>Submission end date : </strong>{{ period.submission_end_date }}</p>
     <p><strong>Unit-PI validation start date : </strong>{{ period.unit_pi_validation_start_date}}</p>
+    <p><strong>Notification start date : </strong>{{ period.notification_start_date}}</p>
     <p><strong>Property of date end date : </strong>{{ period.property_of_data_end_date }}</p>
     <p><strong>Data accessibility end date : </strong>{{ period.data_accessibility_end_date }}</p>
  
@@ -46,7 +46,7 @@
             <form class="modal-content" action="{% url "delete_scientific_program" scientific_program.id %}" method="post">
                 {% csrf_token %}
                 <div class="container">
-                    <h1> Delete Account </h1>
+                    <h1> Delete scientific program </h1>
                     <p>Are you sure you want to delete this scientific program ?</p>
  
                     <div class="clearfix">
-{% extends 'base.html' %}
-{% load tags %}
-{% block content %}
-<form id="editSPForm" action="" method="post">
-    {% csrf_token %}
- 
-        {% for field in SPForm %}
-            <div class="fieldWrapper">
-                {{ field.label_tag }} {{ field.value }}
-                {{ field.as_hidden }}
-            </div>
-        {% endfor %}
-    {% if sp_period.status == "Draft" %}
-        <p style="color:red;"><strong>This proposal will be automatically submitted for evaluation on {{ sp_period.period.submission_end_date }}</strong> </p> 
-    {% endif %}
-    {% if USER_LEVEL|ifinlist:"Unit-PI,Admin,Unit-board"%}
-        {% if sp_period.referee1 != None and sp_period.referee1 == request.user %}
-            <p><strong>vote referee 1: </strong>{{ sp_period.vote_referee1 }} {{ sp_period.reason_referee1 }} by {{ sp_period.referee1.first_name }} {{ sp_period.referee1.last_name}} </p>
-        {% endif %}
-        {% if sp_period.referee2 != None %}
-            <p><strong>vote referee 2: </strong>{{ sp_period.vote_referee1 }} {{ sp_period.reason_referee1 }} by {{ sp_period.referee1.first_name }} {{ sp_period.referee1.last_name}} </p>
-        {% endif %}
-        <p><strong>Minimal quota : </strong>{{ sp_period.quota_minimal }}</p>
-        <p><strong>Nominal quota : </strong>{{ sp_period.quota_nominal }}</p>
-        <p><strong>Over quota duration : </strong>{{ sp_period.over_quota_duration }}</p>
-        <p><strong>Token : </strong>{{ sp_period.token }}</p>
-    {% endif %}
-    {% for field in SP_PeriodForm %}
-        {% if "referee1" in field.label_tag %}
-            {% if SP_PeriodForm.reason_referee1.value == "" %}
-
-                {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
-                    <div class="fieldWrapper">
-                        {{ field.label_tag }} {{ field }}
-                        {{ field.errors }}
-                            {% if field.help_text %}
-                                <p class="help">{{ field.help_text|safe }}</p>
-                            {% endif %}
-                    </div>
-                {% endif %}
-                    
-            {% else %}
-                {% if sp_period.referee1 == request.user %}
-                    {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
-                        <div class="fieldWrapper">
-                            {{ field.label_tag }} {{ field }}
-                            {{ field.errors }}
-                                {% if field.help_text %}
-                                    <p class="help">{{ field.help_text|safe }}</p>
-                                {% endif %}
-                        </div>
-                    {% endif %}
-                {% else %}
-                    {{ field.as_hidden}}
-                {% endif %}
-            {% endif %}
-        {% elif "referee2" in field.label_tag %}
-            {% if SP_PeriodForm.reason_referee1.value != "" and SP_PeriodForm.reason_referee2.value == "" and request.user != sp_period.referee1 %}
-                {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
-                    <div class="fieldWrapper">
-                        {{ field.label_tag }} {{ field }}
-                        {{ field.errors }}
-                        {% if field.help_text %}
-                            <p class="help">{{ field.help_text|safe }}</p>
-                        {% endif %}
-                    </div>
-                {% endif %}
-            {% else %}
-                {{ field.as_hidden}}
-            {% endif %}
-        {% elif "is_valid" in field.label_tag or "allocated" in field.label_tag or "priority" in field.label_tag %}
-            {% if sp_period.status != "Draft" and USER_LEVEL|ifinlist:"Unit-PI,Admin" %}
-                <div class="fieldWrapper">
-                    {{ field.label_tag }} {{ field }}
-                    {{ field.errors }}
-                        {% if field.help_text %}
-                            <p class="help">{{ field.help_text|safe }}</p>
-                        {% endif %}
-                </div>
-            {% endif %}
-
-        {% elif sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
-            <div class="fieldWrapper">
-                    {{ field.label_tag }} {{ field }}
-                    {{ field.errors }}
-                        {% if field.help_text %}
-                            <p class="help">{{ field.help_text|safe }}</p>
-                        {% endif %}
-            </div>
-        {% else %}
-            {{ field.as_hidden}}
-        {% endif %}
-    {% endfor %}
-    {% if sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
-    <label> Invite user(s) with their email adress: (list them separated by a ","):</label>
-    <div class="fieldWrapper">
-        <textarea id="users" name="users">{{guests|default_if_none:""}} </textarea>
-        {{ error_message }}
-    </div>
-    {% endif %}
-    {% if USER_LEVEL|ifinlist:"Admin,Observer" %}
-     <p> <b> Users : </b> 
-     {% for user in users_of_sp_period %}
-            {% comment %}
-            input name is the same for all role so we can retrieve a list of selected values
-            {% endcomment %}
-            <div>
-            {% if sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
-            <input type="checkbox" checked id="{{user.username}}" name="user" value="{{user.id}}">
-            {% endif %}
-            <label for="{{user.username}}"> {{ user.first_name }} {{ user.last_name }} ({{user.username}})</label>
-            </div>            
-        {% endfor %}
-    {% endif %}
-    <div>
-    <input id="submit" class="btn btn-info" type="submit" value="Submit" />
-    <a href="{% url "detail_scientific_program_period" id_sp=id_sp id_period=id_period %}" class="btn btn-info" role="button">Cancel</a>
-    </div>
-</form>
-
+{% extends 'base.html' %}
+{% load tags %}
+{% block content %}
+<form id="editSPForm" action="" method="post">
+    {% csrf_token %}
+ 
+        {% for field in SPForm %}
+            <div class="fieldWrapper">
+                {{ field.label_tag }} {{ field.value }}
+                {{ field.as_hidden }}
+            </div>
+        {% endfor %}
+    {% if sp_period.status == "Draft" %}
+        <p style="color:red;"><strong>This proposal will be automatically submitted for evaluation on {{ sp_period.period.submission_end_date }}</strong> </p> 
+    {% endif %}
+    {% if CAN_VIEW_TAC_VOTES %}
+        {% if sp_period.referee1 != None and sp_period.referee1 == request.user %}
+            <p><strong>vote referee 1: </strong>{{ sp_period.vote_referee1 }} {{ sp_period.reason_referee1 }} by {{ sp_period.referee1.first_name }} {{ sp_period.referee1.last_name}} </p>
+        {% endif %}
+        {% if sp_period.referee2 != None %}
+            <p><strong>vote referee 2: </strong>{{ sp_period.vote_referee1 }} {{ sp_period.reason_referee1 }} by {{ sp_period.referee1.first_name }} {{ sp_period.referee1.last_name}} </p>
+        {% endif %}
+        <p><strong>Minimal quota : </strong>{{ sp_period.quota_minimal }}</p>
+        <p><strong>Nominal quota : </strong>{{ sp_period.quota_nominal }}</p>
+        <p><strong>Over quota duration : </strong>{{ sp_period.over_quota_duration }}</p>
+        <p><strong>Token : </strong>{{ sp_period.token }}</p>
+    {% endif %}
+    {% for field in SP_PeriodForm %}
+        {% if "referee1" in field.label_tag %}
+            {% if SP_PeriodForm.reason_referee1.value == "" %}
+
+                {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
+                    <div class="fieldWrapper">
+                        {{ field.label_tag }} {{ field }}
+                        {{ field.errors }}
+                            {% if field.help_text %}
+                                <p class="help">{{ field.help_text|safe }}</p>
+                            {% endif %}
+                    </div>
+                {% endif %}
+                    
+            {% else %}
+                {% if sp_period.referee1 == request.user %}
+                    {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
+                        <div class="fieldWrapper">
+                            {{ field.label_tag }} {{ field }}
+                            {{ field.errors }}
+                                {% if field.help_text %}
+                                    <p class="help">{{ field.help_text|safe }}</p>
+                                {% endif %}
+                        </div>
+                    {% endif %}
+                {% else %}
+                    {{ field.as_hidden}}
+                {% endif %}
+            {% endif %}
+        {% elif "referee2" in field.label_tag %}
+            {% if SP_PeriodForm.reason_referee1.value != "" and SP_PeriodForm.reason_referee2.value == "" and request.user != sp_period.referee1 %}
+                {% if sp_period.status == "Submitted" and USER_LEVEL|ifinlist:"TAC,Admin"%}
+                    <div class="fieldWrapper">
+                        {{ field.label_tag }} {{ field }}
+                        {{ field.errors }}
+                        {% if field.help_text %}
+                            <p class="help">{{ field.help_text|safe }}</p>
+                        {% endif %}
+                    </div>
+                {% endif %}
+            {% else %}
+                {{ field.as_hidden}}
+            {% endif %}
+        {% elif "is_valid" in field.label_tag or "allocated" in field.label_tag or "priority" in field.label_tag %}
+            {% if sp_period.status != "Draft" and USER_LEVEL|ifinlist:"Unit-PI,Admin" %}
+                <div class="fieldWrapper">
+                    {{ field.label_tag }} {{ field }}
+                    {{ field.errors }}
+                        {% if field.help_text %}
+                            <p class="help">{{ field.help_text|safe }}</p>
+                        {% endif %}
+                </div>
+            {% endif %}
+
+        {% elif sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
+            <div class="fieldWrapper">
+                    {{ field.label_tag }} {{ field }}
+                    {{ field.errors }}
+                        {% if field.help_text %}
+                            <p class="help">{{ field.help_text|safe }}</p>
+                        {% endif %}
+            </div>
+        {% else %}
+            {{ field.as_hidden}}
+        {% endif %}
+    {% endfor %}
+    {% if sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
+    <label> Invite user(s) with their email adress: (list them separated by a ","):</label>
+    <div class="fieldWrapper">
+        <textarea id="users" name="users">{{guests|default_if_none:""}} </textarea>
+        {{ error_message }}
+    </div>
+    {% endif %}
+    {% if USER_LEVEL|ifinlist:"Admin,Observer" %}
+     <p> <b> Users : </b> 
+     {% for user in users_of_sp_period %}
+            {% comment %}
+            input name is the same for all role so we can retrieve a list of selected values
+            {% endcomment %}
+            <div>
+            {% if sp_period.status == "Draft" and USER_LEVEL|ifinlist:"Observer" %}
+            <input type="checkbox" checked id="{{user.username}}" name="user" value="{{user.id}}">
+            {% endif %}
+            <label for="{{user.username}}"> {{ user.first_name }} {{ user.last_name }} ({{user.username}})</label>
+            </div>            
+        {% endfor %}
+    {% endif %}
+    <div>
+    <input id="submit" class="btn btn-info" type="submit" value="Submit" />
+    <a href="{% url "detail_scientific_program_period" id_sp=id_sp id_period=id_period %}" class="btn btn-info" role="button">Cancel</a>
+    </div>
+</form>
+
 {% endblock %}
 \ No newline at end of file
@@ -0,0 +1,9 @@
+{% extends 'base.html' %}
+{% block content %}
+
+
+<div>
+
+    <img src="data:image/png;base64,{{ data }}" alt="">
+</div>
+{% endblock content %}
+from logging import log
+from sys import stdout
 from django.http import response
 from django.test import TestCase
+from django.utils import timezone, tree
 from common.models import PyrosUser,ScientificProgram,Period,SP_Period,SP_Period_User,SP_Period_Guest,UserLevel,Institute,Country
 from django.urls import reverse
 from django.core import mail
 from django.conf import settings
-import unittest,os
+from datetime import date
+from datetime import datetime
+from unittest.mock import patch
+import subprocess,time,os
+import multiprocessing
+from .AgentSP import *
 # Create your tests here.
 class ScientificProgramTests(TestCase):
     fixtures = ['tests/scientific_program_TZ.json']
     def setUp(self) -> None:
-        """
-        institute = Institute.objects.get(id=1)
-        country = Country.objects.create()
-
-        self.usr1 = PyrosUser.objects.create(username="toto", country=country, institute=institute)
-        UserLevel.objects.get(name = "Observer").pyros_users.add(self.usr1)
-        self.usr1.save()
-        self.usr2 = PyrosUser.objects.create(username="titi", country=country, institute=institute)
-        UserLevel.objects.get(name = "Unit-PI").pyros_users.add(self.usr2)
-        self.usr2.save()
-        self.usr3 = PyrosUser.objects.create(username="tata", country=country, institute=institute)
-        UserLevel.objects.get(name = "Operator").pyros_users.add(self.usr3)
-        self.usr3.save()
-        self.usr4 = PyrosUser.objects.create(username="tutu", country=country, institute=institute)
-        UserLevel.objects.get(name = "TAC").pyros_users.add(self.usr4)
-        self.usr4.save()
-        """
         password = "password123"
         Period.objects.create()
-        Period.objects.create(start_date=Period.objects.all().first().end_date)
+        self.period2 = Period.objects.create(start_date=Period.objects.all().first().end_date)
+        self.period3 = Period.objects.create(start_date=self.period2.end_date,submission_duration=550)
         self.usr1 = PyrosUser.objects.get(username="observer")
         self.usr2 = PyrosUser.objects.get(username="unit_pi")
         self.usr3 = PyrosUser.objects.get(username="tac")
         self.usr4 = PyrosUser.objects.get(username="operator")
         self.usr5 = PyrosUser.objects.get(username="observer2")
+        self.usr6 = PyrosUser.objects.get(username="tac2")
+        self.usr7 = PyrosUser.objects.get(username="observer3")
+        self.usr8 = PyrosUser.objects.get(username="observer4")
  
  
         self.usr1.set_password(password)
@@ -46,216 +41,722 @@ class ScientificProgramTests(TestCase):
         self.usr4.save()
         self.usr5.set_password(password)
         self.usr5.save()
-    def test_SCP_observer_can_create_sp(self):
-        self.client.login(username=self.usr1,password="password123")
-        path = reverse('create_scientific_program')
-        response = self.client.post(path, {"name": "test", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.assertEqual(response.status_code,302)
-        self.assertEqual(len(mail.outbox),3)
-        self.assertIn("test@example.com",mail.outbox[0].recipients())
-        self.assertIn("test2@example.com",mail.outbox[1].recipients())
-        self.assertIn("test3@example.com",mail.outbox[2].recipients())
-        domain = settings.DEFAULT_DOMAIN
-        url = f"{domain}{reverse('sp_register',args=(ScientificProgram.objects.all().order_by('-id').first().pk,Period.objects.all().order_by('-id').first().pk))}"
-        self.assertIn(url,mail.outbox[2].body)
-        self.assertEqual(ScientificProgram.objects.all().count(),1)  
-        self.assertEqual(list(SP_Period_Guest.objects.all().values_list("email",flat=True)),["test@example.com","test2@example.com","test3@example.com"])
-        self.assertEqual(SP_Period.objects.get(scientific_program__name="test").status,SP_Period.STATUSES_DRAFT)                                         
-        self.assertEqual(ScientificProgram.objects.get(name="test").sp_pi,self.usr1)
+        self.usr6.set_password(password)
+        self.usr6.save()
+        self.usr7.set_password(password)
+        self.usr7.save()
+        self.usr8.set_password(password)
+        self.usr8.save()
+
+    def logout(self):
         self.client.get(reverse("user_logout"))
-        # u2 shouldn't be able to create a new scientific program
-        self.client.login(username=self.usr2,password="password123")
+        print("Log out")
+    def login_as_user(self,number):
+        if number == 1:
+            self.client.post(reverse("login_validation"),{"email":self.usr1,"password":"password123"})
+        elif number == 2:
+            self.client.post(reverse("login_validation"),{"email":self.usr2,"password":"password123"})
+        elif number == 3:
+            self.client.post(reverse("login_validation"),{"email":self.usr3,"password":"password123"})
+        elif number == 4:
+            self.client.post(reverse("login_validation"),{"email":self.usr4,"password":"password123"})
+        elif number == 5:
+            self.client.post(reverse("login_validation"),{"email":self.usr5,"password":"password123"})
+        elif number == 6:
+            self.client.post(reverse("login_validation"),{"email":self.usr6,"password":"password123"})
+        elif number == 7:
+            self.client.post(reverse("login_validation"),{"email":self.usr7,"password":"password123"})
+        elif number == 8:
+            self.client.post(reverse("login_validation"),{"email":self.usr8,"password":"password123"})
+        print(f'Log in as {self.client.session["user"]}')
+
+    def create_dummy_SCP(self,name,user_number):
+        """
+        Generate a SCP
+        """
+        self.login_as_user(user_number)
         path = reverse('create_scientific_program')
-        response = self.client.post(path, {"name": "test2", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
+        post_data = {
+            "name":name,
+            "description_short":"sp short desc",
+            "description_long":"sp long desc",
+            "science_theme":1,
+        }
+        response = self.client.post(path,post_data)
+        self.logout()
+        return ScientificProgram.objects.get(name=name)
+    
+    def create_dummy_SCP_Period(self,scientific_program,user_number):
+        self.login_as_user(user_number)
+
+        path = reverse('create_scientific_program_period',kwargs={"id_SP":scientific_program.id})
+        post_data = {
+            "period":Period.objects.next_period().id,
+            "public_visibility":SP_Period.VISIBILITY_YES,
+            "quota_minimal":2,
+            "quota_nominal":5,
+            "over_quota_duration":2,
+            "token":2
+        }
+         
+        response = self.client.post(path,post_data)
+        sp_period = SP_Period.objects.get(scientific_program=scientific_program,period=Period.objects.next_period())
+        
+        self.logout()
+        return sp_period
+
+    def create_dummies_SCP_and_SCP_Period(self,name_of_SCP,user_number):
+        self.create_dummy_SCP(name_of_SCP,user_number)
+        scientific_program = ScientificProgram.objects.get(name=name_of_SCP)
+        sp_period = self.create_dummy_SCP_Period(scientific_program,user_number)
+        return sp_period
+
+    def test_SCP_Observer_can_submit_new_SP_from_scratch(self):
+        self.login_as_user(1)
+        path = reverse('create_scientific_program')
+        post_data = {
+            "name":"test",
+            "description_short":"sp short desc",
+            "description_long":"sp long desc",
+            "science_theme":1,
+        }
+        response = self.client.post(path,post_data)
         self.assertEqual(response.status_code,302)
-        self.assertEqual(len(mail.outbox),3)
         self.assertEqual(ScientificProgram.objects.all().count(),1)
+        current_sp = ScientificProgram.objects.all().first()
+        self.assertEqual(current_sp.sp_pi,self.usr1)
  
-    def test_SCP_view_sp_list(self):
-        self.client.login(username=self.usr1,password="password123")
+        self.logout()
+
+        self.login_as_user(2)
         path = reverse('create_scientific_program')
-        self.client.post(path, {"name": "test", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        
-        self.client.post(path, {"name": "sp2", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # login with another user to create a SP that user 1 shouldn't be able to see
+        post_data = {
+            "name":"test 2",
+            "description_short":"test2 short desc",
+            "description_long":"test2 long desc",
+            "science_theme":2,
+        }
+        response = self.client.post(path,post_data)
+        self.assertEqual(response.status_code,302)
+        # user can't access to this page
+        self.assertEqual(response.context,None)
+        self.logout()
+
+    def test_SCP_Observer_can_submit_new_SP_from_template(self):
+        self.create_dummy_SCP("test",1)
+        current_sp = ScientificProgram.objects.all().first()
+
+        self.login_as_user(1)
+        path = reverse('create_scientific_program_with_template',kwargs={"id_SP":current_sp.id})
+        post_data = {
+            "name":"test 2",
+            "description_short":"test2 short desc",
+            "description_long":"test2 long desc",
+            "science_theme":2,
+        }
+        response = self.client.post(path,post_data)
+        self.assertEqual(response.status_code,302)
+        self.assertEqual(ScientificProgram.objects.all().count(),2)
+        current_sp = ScientificProgram.objects.all().first()
+        self.assertEqual(current_sp.sp_pi,self.usr1)
+
+        self.logout()
+
+        self.login_as_user(2)
  
-        self.client.login(username=self.usr5,password="password123")
-        self.client.post(path, {"name": "third_project", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # log in again as user 1 to see the scientific program list
-        self.client.login(username=self.usr1,password="password123")
-        path = reverse("scientific_program_list")
-        response = self.client.get(path)
-        self.assertContains(response,"test")
-        self.assertContains(response,"sp2")
-        self.assertNotContains(response,"third_project")
-        self.client.get(reverse("user_logout"))
+        path = reverse('create_scientific_program_with_template',kwargs={"id_SP":current_sp.id})
+        post_data = {
+            "name":"test 3",
+            "description_short":"test3 short desc",
+            "description_long":"test3 long desc",
+            "science_theme":2,
+        }
+        response = self.client.post(path,post_data)
+        self.assertEqual(response.status_code,302)
+        # user can't access to this page
+        self.assertEqual(response.context,None)
+        self.assertEqual(ScientificProgram.objects.all().count(),2)
+        self.logout()
  
-        # log in as unit pi (user 2)
-        self.client.login(username=self.usr2,password="password123")
-        path = reverse("scientific_program_list")
-        response = self.client.get(path)
-        self.assertContains(response,"test")
-        self.assertContains(response,"sp2")
-        self.assertContains(response,"third_project")
+    def test_SCP_Observer_can_submit_SP_Period_from_scratch(self):
+        self.create_dummy_SCP("test",1)
+        self.logout()
+        self.login_as_user(1)
+        current_sp = ScientificProgram.objects.all().first()
+        path = reverse('create_scientific_program_period',kwargs={"id_SP":current_sp.id})
+        post_data = {
+            "period":Period.objects.next_period().id,
+            "public_visibility":SP_Period.VISIBILITY_YES,
+            "quota_minimal":2,
+            "quota_nominal":5,
+            "over_quota_duration":2,
+            "token":2
+        }
+         
+        response = self.client.post(path,post_data)
+   
+        self.assertEqual(response.status_code,302)
+        self.assertEqual(SP_Period.objects.filter(scientific_program=current_sp).count(),1)
+        current_sp_period = SP_Period.objects.filter(scientific_program=current_sp).first()
+        self.assertEqual(current_sp_period.quota_minimal,2)
+        self.assertEqual(current_sp_period.status,SP_Period.STATUSES_DRAFT)
  
-        self.client.get(reverse("user_logout"))
+        self.logout()
  
-        # log in as operator (shoudln't be able to see anything)
-        self.client.login(username=self.usr4,password="password123")
-        path = reverse("scientific_program_list")
-        response = self.client.get(path)
-        # user is redirected to his previous page, however it was the first page he visited to he is redirected to a None page
+        self.login_as_user(2)
+        path = reverse('create_scientific_program_period',args=[1])
+        post_data = {
+            "public_visibility":SP_Period.VISIBILITY_YES,
+            "quota_minimal":2,
+            "quota_nominal":5,
+            "quota_allocated":None,
+            "over_quota_duration":2,
+            "over_quota_duration_allocated":None,
+            "token":2,
+            "token_allocated":None,
+            "vote_referee1":None,
+            "reason_referee1":None,
+            "vote_referee2":None,
+            "reason_referee2":None,
+            "priority":None,
+            "is_valid":False
+        }
+        response = self.client.post(path,post_data)
         self.assertEqual(response.status_code,302)
+        # user can't access to this page
         self.assertEqual(response.context,None)
+        self.logout()
  
-    def test_SCP_view_sp_details(self):
-        self.client.login(username=self.usr1,password="password123")
-        path = reverse('create_scientific_program')
-        self.client.post(path, {"name": "test", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
+    def test_SCP_Observer_can_submit_existing_SP_for_new_Period(self):
+        self.create_dummy_SCP("test",1)
+        current_scientific_program = ScientificProgram.objects.all().first()
+        self.create_dummy_SCP_Period(current_scientific_program,1)
+        sp_period = SP_Period.objects.all().first()
  
-        self.client.post(path, {"name": "sp2", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # login with another user to create a SP that user 1 shouldn't be able to see
+        self.login_as_user(1)
+        path = reverse('repropose_scientific_program',kwargs={"id_SP":current_scientific_program.id,"id_SP_Period":sp_period.id})
+        post_data = {
+            "period":self.period3.id,
+            "public_visibility":SP_Period.VISIBILITY_YES,
+            "quota_minimal":2,
+            "quota_nominal":5,
+            "over_quota_duration":2,
+            "token":2
+        }
+        response = self.client.post(path,post_data)
+        self.assertEqual(SP_Period.objects.filter(scientific_program=current_scientific_program).count(),2)
+        current_sp_period = SP_Period.objects.filter(scientific_program=current_scientific_program)[1]
+        SP_Period_User(SP_Period=current_sp_period,user=self.usr5).save()
+        self.assertEqual(current_sp_period.quota_minimal,2)
+        self.assertEqual(current_sp_period.status,SP_Period.STATUSES_DRAFT)
+        # We should have one user which is from the previous period 
+        self.assertEqual(SP_Period_User.objects.filter(SP_Period=current_sp_period).count(),1)
+
+    def test_SCP_Unit_PI_can_add_Period(self):
+        self.login_as_user(2)
+        path = reverse("create_period")
+        today = timezone.now().date().strftime("%d/%m/%Y")
+        post_data = {
+            "start_date_picker":today,
+            "exploitation_duration":182,
+            "submission_duration":182,
+            "evaluation_duration":31,
+            "validation_duration":5,
+            "notification_duration":10,
+            "property_of_data_duration":365,
+            "data_accessibility_duration":365*10
+        }
  
-        self.client.login(username=self.usr5,password="password123")
-        self.client.post(path, {"name": "third_project", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # log in as user 1
-        self.client.login(username=self.usr1,password="password123")
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="test").id])
-        response = self.client.get(path)
+
+        response = self.client.post(path,post_data)
+        # This creation should fail, we should have 3 periods
+        self.assertEqual(Period.objects.all().count(),3)
         self.assertEqual(response.status_code,200)
-        self.assertContains(response,"sp long desc")
-        self.assertContains(response,"test")
+        self.assertTrue(response.context["error"])
+
+        start_date = Period.objects.latest_period().end_date.strftime("%d/%m/%Y")
+        post_data = {
+            "start_date_picker":start_date,
+            "exploitation_duration":182,
+            "submission_duration":182,
+            "evaluation_duration":31,
+            "validation_duration":5,
+            "notification_duration":10,
+            "property_of_data_duration":365,
+            "data_accessibility_duration":365*10
+        }
+        response = self.client.post(path,post_data)
+        # This creation should success, we should have 4 periods and should be redirected to period_list
+        self.assertEqual(Period.objects.all().count(),4)
+        self.assertEqual(response.status_code,302)
+        self.logout()
+
+    def test_SCP_view_main_menu(self):
+        self.create_dummy_SCP("test",1)
+        sp_period = self.create_dummy_SCP_Period(ScientificProgram.objects.all().first(),1)
+        self.login_as_user(1)
+        path = reverse("index_scientific_program")
  
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="sp2").id])
         response = self.client.get(path)
-        self.assertEqual(response.status_code,200)
-        self.assertContains(response,"sp long desc")
-        self.assertContains(response,"sp2")
+        # u1 should be able to add, view scientific programs and view Periods
+        self.assertTrue(response.context["CAN_SUBMIT_SP"])
+        self.assertTrue(response.context["CAN_VIEW_SP"])
+        self.assertTrue(response.context["CAN_VIEW_EXPLOITATION_PERIOD"])
+        self.assertFalse(response.context["CAN_VIEW_ALL_SP"])
+        self.assertFalse(response.context["CAN_EVALUATE_SP"])
+        self.assertFalse(response.context["CAN_VALIDATE_SP"])
+        self.assertFalse(response.context["CAN_CREATE_EXPLOITATION_PERIOD"])
+        self.assertFalse(response.context["CAN_ASSOCIATE_TAC_TO_SP"])
  
-        self.client.get(reverse("user_logout"))
+        self.logout()
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().submission_start_date),"%Y-%m-%d")):
+            # u2 should be able to associate TAC to SP
+            # Submission period
+            self.login_as_user(2)
+            response = self.client.get(path)
+            self.assertTrue(response.context["CAN_ASSOCIATE_TAC_TO_SP"])
+            self.logout()
+
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().unit_pi_validation_start_date),"%Y-%m-%d")):
+            self.login_as_user(2)
+            # Validation period
+            sp_period.status = SP_Period.STATUSES_EVALUATED
+            sp_period.save()
+            response = self.client.get(path)
+            self.assertEqual(self.client.session["role"],"Unit-PI")
+            # u2 should be able to do everything outside submitting, evaluate SP and see the obsever's view for sp 
+            self.assertTrue(response.context["CAN_VIEW_EXPLOITATION_PERIOD"])
+            self.assertTrue(response.context["CAN_VIEW_ALL_SP"])
+            self.assertTrue(response.context["CAN_CREATE_EXPLOITATION_PERIOD"])
+            self.assertTrue(response.context["CAN_VALIDATE_SP"])
+            self.assertFalse(response.context["CAN_ASSOCIATE_TAC_TO_SP"])
+            self.assertFalse(response.context["CAN_VIEW_SP"])
+            self.assertFalse(response.context["CAN_SUBMIT_SP"])
+            self.assertFalse(response.context["CAN_EVALUATE_SP"])
+            self.logout()
+
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().submission_end_date),"%Y-%m-%d")):
+            self.login_as_user(3)
+            sp_period.status = SP_Period.STATUSES_SUBMITTED
+            sp_period.save()
+            
+            response = self.client.get(path)
+            # u3 should be able to only evaluate SP 
+            self.assertTrue(response.context["CAN_EVALUATE_SP"])
+            self.assertFalse(response.context["CAN_VIEW_EXPLOITATION_PERIOD"])
+            self.assertFalse(response.context["CAN_VIEW_ALL_SP"])
+            self.assertFalse(response.context["CAN_CREATE_EXPLOITATION_PERIOD"])
+            self.assertFalse(response.context["CAN_VALIDATE_SP"])
+            self.assertFalse(response.context["CAN_VIEW_SP"])
+            self.assertFalse(response.context["CAN_SUBMIT_SP"])
+            self.assertFalse(response.context["CAN_ASSOCIATE_TAC_TO_SP"])
  
-         # log in as user 2
-        self.client.login(username=self.usr2,password="password123")
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="test").id])
+            self.logout()
+
+    def test_SCP_view_sp_list_and_detail(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummies_SCP_and_SCP_Period("test2",1)    
+        sp3 = self.create_dummies_SCP_and_SCP_Period("test3",1)
+        sp4 = self.create_dummies_SCP_and_SCP_Period("test4",1)
+        sp5 = self.create_dummies_SCP_and_SCP_Period("test5",1)
+        sp6 = self.create_dummies_SCP_and_SCP_Period("test6",8)
+        sp7 = self.create_dummies_SCP_and_SCP_Period("test7",7)
+        sp2.status = SP_Period.STATUSES_SUBMITTED
+        sp2.referee2 = self.usr3
+        sp2.referee1 = self.usr6
+        sp2.save()
+        sp3.status = SP_Period.STATUSES_EVALUATED
+        sp3.referee1 = self.usr6
+        sp3.referee2 = self.usr3
+        sp3.save()
+        sp4.status = SP_Period.STATUSES_ACCEPTED
+        sp4.save()
+        SP_Period_User.objects.create(SP_Period=sp4,user=self.usr5)
+        sp5.status = SP_Period.STATUSES_REJECTED
+        sp6.status = SP_Period.STATUSES_ACCEPTED
+        sp6.save()
+        SP_Period_User.objects.create(SP_Period=sp6,user=self.usr1)
+        sp7.status = SP_Period.STATUSES_ACCEPTED
+        sp7.save()
+        SP_Period_User.objects.create(SP_Period=sp7,user=self.usr5)
+
+        self.login_as_user(1)
+        path = reverse("own_scientific_program_list")
         response = self.client.get(path)
-        self.assertEqual(response.status_code,200)
-        self.assertContains(response,"sp long desc")
-        self.assertContains(response,"test")
+        # Can't compare 2 queryset, it returns an error despite they are equal.. so we transform those queryset into list and compare them.
+        self.assertEqual(list(ScientificProgram.objects.filter(sp_pi=self.usr1).order_by("-id")),list(response.context["sp_of_user"]))
  
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="sp2").id])
+        path = reverse("detail_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
         response = self.client.get(path)
-        self.assertEqual(response.status_code,200)
-        self.assertContains(response,"sp long desc")
-        self.assertContains(response,"sp2")
+        self.assertFalse(response.context["CAN_VIEW_TAC_VOTES"])
  
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="third_project").id])
+        self.logout()
+        
+        # login as TAC 1 and put today date to evaluation period
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().submission_end_date),"%Y-%m-%d")):
+            self.login_as_user(3)
+            path = reverse("list_submitted_scientific_program")
+            response = self.client.get(path)
+            self.assertEqual(list(SP_Period.objects.filter(referee2=self.usr3,period=Period.objects.next_period(),status=SP_Period.STATUSES_SUBMITTED)),response.context["list_of_evaluated_sp"])
+            path = reverse("detail_scientific_program_period",kwargs={"id_sp":sp2.scientific_program.id,"id_period":sp2.period.id})
+            
+            response = self.client.get(path)
+            self.assertEqual(response.status_code,302)
+            # user can't access to this page
+            self.assertEqual(response.context,None)
+            self.logout()
+
+        # log in as user observer
+        self.login_as_user(5)
+        path = reverse("scientific_program_list")
         response = self.client.get(path)
-        self.assertEqual(response.status_code,200)
-        self.assertContains(response,"sp long desc")
-        self.assertContains(response,"third_project")
+        sp_of_user = list(("test4","test7"))
+        self.assertListEqual(sp_of_user,list(response.context["sp_of_user"].values_list("name",flat=True)))
+        path = reverse("detail_scientific_program_period",kwargs={"id_sp":sp4.scientific_program.id,"id_period":sp4.period.id})
+        response = self.client.get(path)
+        self.assertFalse(response.context["CAN_VIEW_TAC_VOTES"])
+        self.assertFalse(response.context["CAN_SUBMIT_PROPOSAL"])
+        self.logout()
+        
+        # log in as unit pi
+        self.login_as_user(2)
+        path = reverse("scientific_program_list")
+        response = self.client.get(path)
+        self.assertListEqual(list(ScientificProgram.objects.all().order_by("-id")),list(response.context["scientific_programs"]))
+        self.logout()
  
-        self.client.get(reverse("user_logout"))
+    def test_SCP_list_Periods(self):
+        self.login_as_user(1)
+        path = reverse("period_list")
+        response = self.client.get(path)
+        self.assertContains(response,"(Current period)")
+        
+        self.assertEqual(Period.objects.all().count(),len(response.context["future_periods"]))
+        self.logout()
+
+    def test_SCP_detail_Period(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummies_SCP_and_SCP_Period("test2",1)    
+        sp3 = self.create_dummies_SCP_and_SCP_Period("test3",1)
+        sp4 = self.create_dummies_SCP_and_SCP_Period("test4",1)
+        sp5 = self.create_dummies_SCP_and_SCP_Period("test5",1)
+        
+        self.login_as_user(1)
+        period = sp1.period
+        path = reverse("detail_period",kwargs={"id":period.id})
+        response = self.client.get(path)
+        # we should see the same number of SP_Period (5) that are associated to user 1 
+        self.assertEqual(SP_Period.objects.all().count(),len(response.context["sp_periods"]))
+        self.logout()
+
+    def test_SCP_edit(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummies_SCP_and_SCP_Period("test2",1)    
+        sp3 = self.create_dummies_SCP_and_SCP_Period("test3",1)
+        sp4 = self.create_dummies_SCP_and_SCP_Period("test4",1)
+        sp5 = self.create_dummies_SCP_and_SCP_Period("test5",5)
+        sp2.status = SP_Period.STATUSES_SUBMITTED
+        sp2.save()
+        sp3.status = SP_Period.STATUSES_ACCEPTED
+        sp3.save()
+        sp4.status = SP_Period.STATUSES_ACCEPTED
+        sp4.save()
+        sp5.status = SP_Period.STATUSES_ACCEPTED
+        sp5.save()
+        post_data = {
+
+            "name":	"test",
+            "description_short":"modified test",
+            "description_long":"modified test",
+            "science_theme"	:"2",
+            "public_visibility":"Yes",
+            "quota_minimal":"0",
+            "quota_nominal":"0",
+            "over_quota_duration":"0",
+            "token":"0",
+            "vote_referee1":"",
+            "reason_referee1":"",
+            "users":"",
+        }
+        self.login_as_user(1)
+        path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
+        response = self.client.post(path,post_data)
+        self.assertEqual(response.status_code,302)
+        updated_sp = SP_Period.objects.get(id=sp1.id)
+        self.assertEqual(updated_sp.scientific_program.description_short,"modified test")
+
+        path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp2.scientific_program.id,"id_period":sp2.period.id})
+        post_data = {
+
+            "name":	"test",
+            "description_short":"modified test2",
+            "description_long":"modified test2",
+            "science_theme"	:"2",
+            "public_visibility":"Yes",
+            "quota_minimal":"10",
+            "quota_nominal":"0",
+            "over_quota_duration":"0",
+            "token":"0",
+            "vote_referee1":"",
+            "reason_referee1":"",
+            "users":"",
+        }
+        response = self.client.post(path,post_data)
+        self.assertEqual(response.status_code,302)
+        updated_sp = SP_Period.objects.get(id=sp2.id)
+        # user can't modify this SP_Period because the status isn't DRAFT
+        self.assertNotEqual(updated_sp.scientific_program.description_short,"modified test2")
+        self.assertNotEqual(updated_sp.quota_minimal,10)
+
+        path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp5.scientific_program.id,"id_period":sp5.period.id})
+        response = self.client.post(path,post_data)
+        # u1 can't edit SP5 because he is not the SP_PI
+        self.assertEqual(response.status_code,302)
+        self.assertNotEqual(updated_sp.scientific_program.description_short,"modified test2")
+        self.assertNotEqual(updated_sp.quota_minimal,10)
+        self.assertEqual(response.url,reverse("detail_scientific_program_period",kwargs={"id_sp":sp5.scientific_program.id,"id_period":sp5.period.id}))
+        self.logout()
+    
+    def test_SCP_add_users(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        post_data = {
  
-        # log in as user 4 (operator)
+            "name":	"test",
+            "description_short":"modified test",
+            "description_long":"modified test",
+            "science_theme"	:"2",
+            "public_visibility":"Yes",
+            "quota_minimal":"0",
+            "quota_nominal":"0",
+            "over_quota_duration":"0",
+            "token":"0",
+            "vote_referee1":"",
+            "reason_referee1":"",
+            "users":"observer2@test.com",
+        }
+        self.login_as_user(1)
+        path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
+        response = self.client.post(path,post_data)
+        self.assertEqual(SP_Period_Guest.objects.filter(SP_Period=sp1).first().email,"observer2@test.com")
+        self.assertEqual(len(mail.outbox),1)
+        self.assertIn("observer2@test.com",mail.outbox[0].recipients())
+        self.logout()
  
-        self.client.login(username=self.usr4,password="password123")
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="test").id])
+        url = reverse("sp_register",kwargs={"id_SP":sp1.scientific_program.id,"id_period":sp1.period.id})
+        self.login_as_user(5)
+        response = self.client.get(url)
+        self.assertEqual(response.status_code,302)
+        self.assertEqual(response.url,reverse("detail_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id}))
+        self.assertEqual(SP_Period_Guest.objects.all().count(),0)
+        self.assertEqual(SP_Period_User.objects.filter(SP_Period=sp1).count(),1)
+        self.assertEqual(SP_Period_User.objects.filter(SP_Period=sp1).first().user,self.usr5)
+        self.logout()
+
+    def test_SCP_delete(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummy_SCP("test2",1)
+        self.login_as_user(1)
+        path = reverse("delete_scientific_program",kwargs={"id_sp":sp1.scientific_program.id})
         response = self.client.get(path)
-        # user is redirected to his previous page, however it was the first page he visited to he is redirected to a None page
+        # Can't delete this SP because it's linked to a period
         self.assertEqual(response.status_code,302)
-        self.assertEqual(response.context,None)
+        self.assertEqual(response.url,reverse("detail_scientific_program", args=[sp1.scientific_program.id]))
+        self.assertEqual(ScientificProgram.objects.all().count(),2)
  
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="sp2").id])
+        path = reverse("delete_scientific_program",kwargs={"id_sp":sp2.id})
         response = self.client.get(path)
-        # user is redirected to his previous page, however it was the first page he visited to he is redirected to a None page
+        # Can delete this SP
         self.assertEqual(response.status_code,302)
-        self.assertEqual(response.context,None)
+        self.assertEqual(response.url,reverse("index_scientific_program"))
+        self.assertEqual(ScientificProgram.objects.all().count(),1)
+
+        self.logout()
  
-        path = reverse("detail_scientific_program",args=[ScientificProgram.objects.get(name="third_project").id])
+    def test_SCP_Period_delete(self):
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummies_SCP_and_SCP_Period("test2",1)
+        sp2.status = SP_Period.STATUSES_ACCEPTED
+        sp2.save()
+        self.login_as_user(1)
+        path = reverse("delete_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
         response = self.client.get(path)
-        # user is redirected to his previous page, however it was the first page he visited to he is redirected to a None page
+        # Can delete this SP because it's in draft status
         self.assertEqual(response.status_code,302)
-        self.assertEqual(response.context,None)
-        
-    def test_SCP_sp_update(self):
-        self.client.login(username=self.usr1,password="password123")
-        path = reverse('create_scientific_program')
-        self.client.post(path, {"name": "sp1", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
+        self.assertEqual(response.url,reverse("detail_scientific_program", args=[sp1.scientific_program.id]))
+        self.assertEqual(SP_Period.objects.filter(scientific_program=sp1.scientific_program).count(),0)
+
+        path = reverse("delete_scientific_program_period",kwargs={"id_sp":sp2.scientific_program.id,"id_period":sp2.period.id})
+        response = self.client.get(path)
+        # Can't delete this SP
+        self.assertEqual(response.status_code,302)
+        self.assertEqual(response.url,reverse("detail_scientific_program", args=[sp2.scientific_program.id]))
+        self.assertEqual(SP_Period.objects.filter(scientific_program=sp2.scientific_program).count(),1)
+        self.logout()
+
+    def run_agent_SP(self):
+        agent = build_agent(AgentSP, RUN_IN_THREAD=True)
+        print(agent)
+        agent.run()
+    def test_SCP_lifecycle(self):
  
-        self.client.post(path, {"name": "sp2", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.post(path, {"name": "sp3", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.post(path, {"name": "sp4", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # login with another user to create a SP that user 1 shouldn't be able to see
  
-        self.client.login(username=self.usr5,password="password123")
-        self.client.post(path, {"name": "sp5", "description_short": "sp short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 10, "quota_nominal": 15,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com,test3@example.com"
-                                           })
-        self.client.get(reverse("user_logout"))
-        # log in as user 1
-        self.client.login(username=self.usr1,password="password123")
-        period = Period.objects.all().order_by('-id').first()
-        sp1 = ScientificProgram.objects.get(name="sp1")
-        path = reverse("edit_scientific_program_period",args=[sp1.id,period.id])
-        self.assertEqual(SP_Period.objects.get(scientific_program=sp1,period=period).status,SP_Period.STATUSES_DRAFT)
-        self.client.post(path, {"name": "sp4", "description_short": "sp modified short desc", "description_long": "sp long desc",
-                                           "public_visibility": "All", "quota_minimal": 15, "quota_nominal": 20,
-                                           "over_quota_duration": 5, "token": 3,
-                                           "users":"test@example.com,test2@example.com"
-                                           })
-        
 \ No newline at end of file
+        print("--------- LIFE CYCLE START----------")
+        sp1 = self.create_dummies_SCP_and_SCP_Period("test",1)
+        sp2 = self.create_dummies_SCP_and_SCP_Period("test2",1)
+        sp3 = self.create_dummies_SCP_and_SCP_Period("test3",1)
+        sp3.scientific_program.is_auto_validated = True
+        sp3.scientific_program.save()
+        os.chdir("./scientific_program/")
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().submission_end_date + relativedelta(days=-10)),"%Y-%m-%d")):
+            # TAC Assignation            
+            p = multiprocessing.Process(target= self.run_agent_SP,args=())
+            p.daemon = True
+            p.start()
+            
+            time.sleep(10)
+            p.terminate()
+            for sp_period in SP_Period.objects.all().exclude(id=sp3.id):
+                # sp period should have referees
+                self.assertNotEqual(sp_period.referee1,None)
+                self.assertNotEqual(sp_period.referee2,None)
+            
+
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().submission_end_date),"%Y-%m-%d")):
+            # Evaluation start 
+            p = multiprocessing.Process(target= self.run_agent_SP,args=())
+            p.daemon = True
+            p.start()
+            
+            time.sleep(10)
+            p.terminate()
+            for sp_period in SP_Period.objects.all().exclude(id=sp3.id):
+                # sp period should have referees
+                self.assertEqual(sp_period.status,SP_Period.STATUSES_SUBMITTED)
+
+            # sp3 should be valid
+            self.assertEqual(SP_Period.objects.get(id=sp3.id).status,SP_Period.STATUSES_ACCEPTED)
+            self.assertEqual(SP_Period.objects.get(id=sp3.id).is_valid,SP_Period.IS_VALID_ACCEPTED)
+
+            # log in as tac to vote
+            self.login_as_user(3)
+            path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
+            post_data = {
+
+                "name":	sp1.scientific_program.name,
+                "description_short":"modified test",
+                "description_long":"modified test",
+                "science_theme"	:sp1.scientific_program.science_theme,
+                "public_visibility":"Yes",
+                "quota_minimal":sp1.quota_minimal,
+                "quota_nominal":sp1.quota_nominal,
+                "over_quota_duration":sp1.over_quota_duration,
+                "token":sp1.token,
+                "vote_referee1":SP_Period.VOTES_YES,
+                "reason_referee1":"i agree",
+                "users":"",
+            }
+            response = self.client.post(path,post_data)
+            self.assertEqual(response.status_code,302)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).vote_referee1,SP_Period.VOTES_YES)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).reason_referee1,"i agree")
+            self.logout()
+
+            # log in as tac 2 to vote
+            self.login_as_user(6)
+            path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
+            post_data = {
+
+                "name":	sp1.scientific_program.name,
+                "description_short":"modified test",
+                "description_long":"modified test",
+                "science_theme"	:sp1.scientific_program.science_theme,
+                "public_visibility":"Yes",
+                "quota_minimal":sp1.quota_minimal,
+                "quota_nominal":sp1.quota_nominal,
+                "over_quota_duration":sp1.over_quota_duration,
+                "token":sp1.token,
+                "vote_referee2":SP_Period.VOTES_YES,
+                "reason_referee2":"i agree",
+                "users":"",
+            }
+            response = self.client.post(path,post_data)
+            self.assertEqual(response.status_code,302)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).vote_referee2,SP_Period.VOTES_YES)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).reason_referee2,"i agree")
+            self.logout()
+
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().unit_pi_validation_start_date),"%Y-%m-%d")):
+            # validation start 
+            p = multiprocessing.Process(target= self.run_agent_SP,args=())
+            p.daemon = True
+            p.start()
+            
+            time.sleep(10)
+            p.terminate()
+            for sp_period in SP_Period.objects.all().exclude(id=sp3.id):
+                # sp period should be evaluated
+                self.assertEqual(sp_period.status,SP_Period.STATUSES_EVALUATED)
+            # log in as unit pi
+
+            self.login_as_user(2)
+            # valid sp1
+            path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp1.scientific_program.id,"id_period":sp1.period.id})
+            post_data = {
+                "name":	sp1.scientific_program.name,
+                "description_short":"modified test",
+                "description_long":"modified test",
+                "science_theme"	:sp1.scientific_program.science_theme,
+                "public_visibility":"Yes",
+                "quota_minimal":sp1.quota_minimal,
+                "quota_nominal":sp1.quota_nominal,
+                "over_quota_duration":sp1.over_quota_duration,
+                "token":sp1.token,
+                "is_valid":SP_Period.IS_VALID_ACCEPTED,
+                "quota_allocated" : 10,
+                "token_allocated": 5,
+                "over_quota_duration_allocated": 5
+            }
+            response = self.client.post(path,post_data)
+            self.assertEqual(response.status_code,302)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).quota_allocated,10)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).is_valid,SP_Period.IS_VALID_ACCEPTED)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).token_allocated,5)
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).over_quota_duration_allocated,5)
+
+            # reject sp 2
+            path = reverse("edit_scientific_program_period",kwargs={"id_sp":sp2.scientific_program.id,"id_period":sp2.period.id})
+            post_data = {
+                "name":	sp2.scientific_program.name,
+                "description_short":"modified test",
+                "description_long":"modified test",
+                "science_theme"	:sp2.scientific_program.science_theme,
+                "public_visibility":"Yes",
+                "quota_minimal":sp2.quota_minimal,
+                "quota_nominal":sp2.quota_nominal,
+                "over_quota_duration":sp2.over_quota_duration,
+                "token":sp2.token,
+                "is_valid":SP_Period.IS_VALID_REJECTED,
+                "quota_allocated" : 0,
+                "token_allocated": 0,
+                "over_quota_duration_allocated": 0
+            }
+            response = self.client.post(path,post_data)
+            self.assertEqual(response.status_code,302)
+            self.assertEqual(SP_Period.objects.get(id=sp2.id).is_valid,SP_Period.IS_VALID_REJECTED)
+            self.assertEqual(SP_Period.objects.get(id=sp2.id).quota_allocated,0)
+            self.assertEqual(SP_Period.objects.get(id=sp2.id).token_allocated,0)
+            self.assertEqual(SP_Period.objects.get(id=sp2.id).over_quota_duration_allocated,0)
+            self.logout()
+
+
+        with patch('django.utils.timezone.now', return_value=datetime.strptime(str(Period.objects.next_period().notification_start_date),"%Y-%m-%d")):
+            # validation start 
+            p = multiprocessing.Process(target= self.run_agent_SP,args=())
+            p.daemon = True
+            p.start()
+            
+            time.sleep(10)
+            p.terminate()
+            self.assertEqual(SP_Period.objects.get(id=sp1.id).status,SP_Period.STATUSES_ACCEPTED)
+            self.assertEqual(SP_Period.objects.get(id=sp3.id).status,SP_Period.STATUSES_ACCEPTED)
+            self.assertEqual(SP_Period.objects.get(id=sp2.id).status,SP_Period.STATUSES_REJECTED)
@@ -10,6 +10,7 @@ urlpatterns = [
     path('add_SP_with_template/<int:id_SP>', views.create_scientific_program_with_template,name='create_scientific_program_with_template'),
     path('add_SP_Period/<int:id_SP>/', views.create_scientific_program_period,name='create_scientific_program_period'),
     path('repropose_scientific_program/<int:id_SP>/<int:id_SP_Period>', views.create_scientific_program_period,name='repropose_scientific_program'),
+    path('detail_scientific_program/<int:id>/', views.detail_scientific_program,name='detail_scientific_program'),
     path('detail_scientific_program_period/<int:id_sp>/<int:id_period>', views.detail_scientific_program_period,name='detail_scientific_program_period'),
     path('edit_scientific_program_period/<int:id_sp>/<int:id_period>', views.edit_scientific_program_period,name='edit_scientific_program_period'),
     path('delete_scientific_program_period/<int:id_sp>/<int:id_period>', views.delete_scientific_program_period,name='delete_scientific_program_period'),
@@ -18,7 +19,6 @@ urlpatterns = [
     path('associate_tac_to_scientific_program/<int:id_sp>/<int:id_period>/',views.associate_tac_to_scientific_program,name="associate_tac_to_scientific_program"),
     path('scientific_program_list', views.scientific_program_list,name='scientific_program_list'),
     path('own_scientific_program_list', views.own_scientific_program_list,name='own_scientific_program_list'),
-    path('detail_scientific_program/<int:id>/', views.detail_scientific_program,name='detail_scientific_program'),
     path("list_evaluated_scientific_program",views.list_evaluated_scientific_program,name="list_evaluated_scientific_program"),
     path("list_submitted_scientific_program",views.list_submitted_scientific_program,name="list_submitted_scientific_program"),
     path("list_scientific_program_as_template",views.list_scientific_program_as_template,name="list_scientific_program_as_template"),
@@ -43,4 +43,5 @@ urlpatterns = [
     path("detail_science_theme/<int:id>/",views.detail_science_theme,name="detail_science_theme"),
     path("edit_science_theme/<int:id>/",views.edit_science_theme,name="edit_science_theme"),
     path("delete_science_theme/<int:id>/",views.delete_science_theme,name="delete_science_theme"),
+    path("test_tac_auto",views.test_tac_auto,name="test_tac_auto")
 ]
@@ -16,7 +16,8 @@ from django.utils import timezone
 from django.db.models import Q,F
 from .functions import get_global_svg_timeline, get_svg_timeline, get_proposal_svg_timeline
 from django.views.decorators.csrf import csrf_exempt
-import re
+import matplotlib.pyplot as plt
+import re,io,urllib,base64
  
 # Scientific program CRUD
  
@@ -41,8 +42,7 @@ def index_scientific_program(request):
     validation_periods = Period.objects.filter(
         start_date__gte=today, submission_end_date__gt=today,unit_pi_validation_start_date__gte=today)
     """
-    does_next_period_exist = Period.objects.filter(
-        start_date__gt=today).order_by("start_date").first() != None
+    does_next_period_exist = Period.objects.next_period() != None
     current_period = Period.objects.exploitation_period()
     future_period = Period.objects.filter(start_date__gte=current_period.end_date).first()
     previous_period = Period.objects.previous_periods().first()
@@ -50,6 +50,7 @@ def index_scientific_program(request):
     validation_periods = Period.objects.validation_periods()
     sp_to_be_evaluated = SP_Period.objects.filter(period__in=evaluation_periods,status__in=(SP_Period.STATUSES_SUBMITTED,SP_Period.STATUSES_EVALUATED)).count() > 0
     sp_to_be_validated = SP_Period.objects.filter(period__in=validation_periods,status__in=(SP_Period.STATUSES_EVALUATED,SP_Period.STATUSES_ACCEPTED,SP_Period.STATUSES_REJECTED)).count() > 0
+    does_next_period_need_tac_association = Period.objects.next_period() in Period.objects.submission_periods()
     # date_diff_today_end_of_property will give a value to make
     # the date of today shift through the time line
     if previous_period:
@@ -65,7 +66,7 @@ def index_scientific_program(request):
     CAN_VIEW_ALL_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
     CAN_VIEW_EXPLOITATION_PERIOD = request.session.get("role") in ("Admin","Observer","Unit-PI","Unit-board")
     CAN_CREATE_EXPLOITATION_PERIOD = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
-    CAN_ASSOCIATE_TAC_TO_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
+    CAN_ASSOCIATE_TAC_TO_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board") and does_next_period_need_tac_association
     svg = get_svg_timeline(previous_period,current_period,future_period)
     global_svg = get_global_svg_timeline(previous_period,current_period,future_period)
     #global_svg = get_global_svg_timeline(current_period,current_period,future_period)
@@ -79,7 +80,7 @@ def index_scientific_program(request):
         "svg":svg,
         "global_svg":global_svg,
         "CAN_VALIDATE_SP": CAN_VALIDATE_SP,
-        "CAN_EVALUATE": CAN_EVALUATE_SP,
+        "CAN_EVALUATE_SP": CAN_EVALUATE_SP,
         "CAN_SUBMIT_SP":CAN_SUBMIT_SP,
         "CAN_VIEW_SP": CAN_VIEW_SP,
         "CAN_VIEW_EXPLOITATION_PERIOD": CAN_VIEW_EXPLOITATION_PERIOD,
@@ -238,7 +239,8 @@ def list_drafted_scientific_program(request):
     select_message = "Select an SP to associate TAC users to it for the incomming evaluation time"
     none_message = f"There is no existing SP to be associated with TAC users for a new exploitation period"
     non_autovalidated_sp = ScientificProgram.objects.exclude(is_auto_validated=True)
-    sp_periods_without_tac =  SP_Period.objects.filter(scientific_program__in=non_autovalidated_sp,period=Period.objects.submission_periods().first()).filter(Q(referee1=None)|Q(referee2=None)).order_by("scientific_program__science_theme")
+    #sp_periods_without_tac =  SP_Period.objects.filter(scientific_program__in=non_autovalidated_sp,period=Period.objects.submission_periods().first()).filter(Q(referee1=None)|Q(referee2=None)).order_by("scientific_program__science_theme")
+    sp_periods_without_tac =  SP_Period.objects.filter(scientific_program__in=non_autovalidated_sp,period=Period.objects.submission_periods().first()).order_by("scientific_program__science_theme")
     return render(request, "scientific_program/list_of_scientific_program_select.html", {
         "select_message": select_message,
         "none_message": none_message,
@@ -331,8 +333,10 @@ def list_submitted_scientific_program(request):
     next_period = Period.objects.evaluation_periods().first()
     none_message = f"There is no SP to be evaluated for next exploitation period {next_period}"
     # Note : ~Q mean not query
-    list_of_sp = SP_Period.objects.filter(Q(referee1=None) & ~Q(referee2=request.user) | ~Q(
-        referee1=request.user) & Q(referee2=None), status=SP_Period.STATUSES_SUBMITTED, period=next_period)
+    #list_of_sp = SP_Period.objects.filter(Q(referee1=None) & ~Q(referee2=request.user) | ~Q(
+    #    referee1=request.user) & Q(referee2=None), status=SP_Period.STATUSES_SUBMITTED, period=next_period)
+
+    list_of_sp = SP_Period.objects.filter(status=SP_Period.STATUSES_SUBMITTED, period=next_period)
     list_of_evaluated_sp = []
     for sp in list_of_sp:
         if sp.referee1 == request.user or sp.referee2 == request.user:
@@ -390,6 +394,7 @@ def accept_sp_invitation(request, id_SP, id_period):
                 SP_Period=sp_period, email=current_user.email).delete()
             return HttpResponseRedirect(reverse("detail_scientific_program_period", kwargs={"id_sp": id_SP, "id_period": id_period}))
     return HttpResponseRedirect(reverse("index"))
+
 @login_required
 @level_required("Admin", "Unit-PI", "Unit-board")
 def associate_tac_to_scientific_program(request,id_sp,id_period):
@@ -443,7 +448,11 @@ def edit_scientific_program_period(request, id_sp, id_period):
     list_of_emails = None
     recipient_list = []
     if request.POST:
+        if SPForm.is_valid() and sp_period.status == SP_Period.STATUSES_DRAFT:
+            SPForm.save()
         if SP_Period_form.is_valid():
+            if sp_period.status == SP_Period.STATUSES_DRAFT:
+                SP_period = SP_Period_form.save()   
             # can send invitation until the end of exploitation
             if request.POST.get("users") and today < period.end_date:
                 # Invite user to join the SP
@@ -482,8 +491,9 @@ def edit_scientific_program_period(request, id_sp, id_period):
                                     recipient_list=[recipient],
                                     fail_silently=False,
                                 )
+                    
                 else:
-                    return render(request, 'scientific_program/scientific_program_detail_edit.html', {
+                    return render(request, 'scientific_program/scientific_program_period_detail_edit.html', {
                             'id_sp': id_sp,
                             "id_period": id_period,
                             "SPForm": SPForm,
@@ -494,21 +504,8 @@ def edit_scientific_program_period(request, id_sp, id_period):
                             "sp_period": sp_period,
                             "error_message":error_message
                         })
-                SP_period = SP_Period_form.save()
                 # save changes on user list 
-                if request.POST.getlist("user"):
-                    for sp_period_user in users_informations:
-                        if sp_period_user.id not in map(int, request.POST.getlist("user")):
-                            sp_period_user.delete()
-
-                    for user in request.POST.getlist("user"):
-                        user_instance = PyrosUser.objects.get(id=int(user))
-                        if user_instance not in users_informations:
-                            SP_Period_User.objects.create(
-                                SP_Period=sp_period, user=user_instance)
-                else:
-                    SP_Period_User.objects.filter(
-                        SP_Period=sp_period).delete()
+                
                 return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
         if SP_Period_form.is_valid() and request.session.get("role") == "TAC" and sp_period.status != SP_Period.STATUSES_DRAFT:
             # vote TAC
@@ -535,15 +532,16 @@ def edit_scientific_program_period(request, id_sp, id_period):
                     #sp_period.status = SP_Period.STATUSES_EVALUATED
                 sp_period.save()
             return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
-        elif SP_Period_form.is_valid() and request.session.get("role") in ["Unit-PI", "Unit-board"] and sp_period.status in [SP_Period.STATUSES_EVALUATED, SP_Period.STATUSES_ACCEPTED, SP_Period.STATUSES_REJECTED]:
+        elif SP_Period_form.is_valid() and request.session.get("role") in ["Admin","Unit-PI", "Unit-board"] and sp_period.status in [SP_Period.STATUSES_EVALUATED, SP_Period.STATUSES_ACCEPTED, SP_Period.STATUSES_REJECTED]:
             #if request.POST.get("is_valid") != None:
                 #sp_period.status = request.POST.get("is_valid")
             SP_Period_form.save()
-            sp_period.save()
             return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
         else:
             print(SP_Period_form.errors)
-    return render(request, 'scientific_program/scientific_program_detail_edit.html', {
+        return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
+    CAN_VIEW_TAC_VOTES = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
+    return render(request, 'scientific_program/scientific_program_period_detail_edit.html', {
         'id_sp': id_sp,
         "id_period": id_period,
         "SPForm": SPForm,
@@ -552,7 +550,8 @@ def edit_scientific_program_period(request, id_sp, id_period):
         "users_of_sp_period": users_informations,
         "SP_PeriodForm": SP_Period_form,
         "sp_period": sp_period,
-        "error_message":error_message
+        "error_message":error_message,
+        "CAN_VIEW_TAC_VOTES":CAN_VIEW_TAC_VOTES
     })
  
  
@@ -588,7 +587,7 @@ def detail_scientific_program(request, id):
     })
  
  
-@level_required("Admin", "Unit-PI", "Observer", "TAC")
+@level_required("Admin", "Unit-PI", "Observer")
 @login_required
 def detail_scientific_program_period(request, id_sp, id_period):
     scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
@@ -644,12 +643,11 @@ def delete_scientific_program(request, id_sp):
     scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
     sp_periods = SP_Period.objects.filter(scientific_program=scientific_program)
     if sp_periods:
-        for sp_period in sp_periods:
-            SP_Period_User.objects.filter(SP_Period=sp_period).delete()
-            SP_Period_Guest.objects.filter(SP_Period=sp_period).delete()
-        sp_periods.delete()
-    scientific_program.delete()
-    return HttpResponseRedirect(reverse('index_scientific_program'))
+        # can't delete
+        return HttpResponseRedirect(reverse("detail_scientific_program", args=[scientific_program.id ]))
+    else:
+        scientific_program.delete()
+        return HttpResponseRedirect(reverse('index_scientific_program'))
  
 @level_required("Admin", "Unit-PI", "Observer")
 @login_required()
@@ -658,6 +656,7 @@ def delete_scientific_program_period(request, id_sp, id_period):
     sp_period = SP_Period.objects.get(
         scientific_program=scientific_program, period=Period.objects.get(id=id_period))
     if sp_period.status == SP_Period.STATUSES_DRAFT:
+        # Delete only if in draft status
         sp_period_users = SP_Period_User.objects.filter(SP_Period=sp_period)
         sp_period_guests = SP_Period_Guest.objects.filter(SP_Period=sp_period)
         sp_period_guests.delete()
@@ -1153,3 +1152,25 @@ def delete_science_theme(request,id):
         return HttpResponseRedirect(reverse('science_theme_list'))
     return HttpResponseRedirect(reverse('detail_science_theme',args=[science_theme.id]))
  
+def test_tac_auto(request):
+    next_period = Period.objects.next_period()
+    themes = ScienceTheme.objects.all()
+    tac_users = PyrosUser.objects.filter(user_level__name="TAC")
+    sp_id = SP_Period.objects.filter(period=next_period).filter(Q(referee1=None)|Q(referee2=None)).values("scientific_program")
+    sp = ScientificProgram.objects.filter(id__in=sp_id).order_by("name")
+
+    matrix = associate_tac_sp_auto(themes,tac_users,sp)
+    fig,ax = plt.subplots(1,1)
+    plt.xlabel("scientific programs")
+    plt.ylabel("Number of available TAC users")
+    plt.pcolor(matrix,edgecolors='k', linewidths=2)
+    plt.colorbar(ticks=[0,1])
+    ax.set_xticklabels(sp.values_list("name",flat=True))
+    plt.yticks([i for i in range(len(tac_users))],tac_users.values_list("last_name",flat=True),rotation="45")
+    #ax.set_yticklabels()
+    buf = io.BytesIO()
+    fig.savefig(buf,format="png")
+    buf.seek(0)
+    string = base64.b64encode(buf.read())
+    uri = urllib.parse.quote(string)
+    return render(request,"scientific_program/test_tac_auto.html",{"data":uri})
 \ No newline at end of file
@@ -292,7 +292,8 @@ class UserManagerTests(TestCase):
  
         u2 = PyrosUser.objects.get(username="u2@test.fr")
  
-        response = self.client.post(reverse("login_validation"),{"email":u2.email,"password":"password123"})
+        response =  self.client.post(reverse("login_validation"),{"email":u2.email,"password":"password123"})
+        
         self.assertEqual(response.status_code,302)
         response = self.client.get(reverse("users"))
         self.assertEqual(response.status_code,200)