radarsys_met Commit - r445:046e9870ce02

Add users and groups

eynilupu -

r445:046e9870ce02

parent child

Context file:

r445:046e9870ce02

volumes/sirm/apps/accounts/management/commands/create_groups.py created 644 +71 0

@@ -0,0 +1,71
	1	from django.core.management import BaseCommand
	2	from django.contrib.auth.models import User, Group , Permission
	3	import logging
	4
	5	GROUPS = {
	6	"Developer": {
	7	#General permissions
	8	#"log entry" : ["add","delete","change","view"],
	9	#"group" : ["add","delete","change","view"],
	10	#"permission" : ["add","delete","change","view"],
	11	#"user" : ["add","delete","change","view"],
	12	#"content type" : ["add","delete","change","view"],
	13	#"session" : ["add","delete","change","view"],
	14
	15	#Specific permissions
	16	"profile" : ["add","delete","change","view"],
	17	"experiment" : ["add","delete","change","view"],
	18	"configuration" : ["add","delete","change","view"],
	19	"device" : ["add","delete","change","view"],
	20	"device type" : ["add","delete","change","view"],
	21	"generator configuration" : ["add","delete","change","view"],
	22	"pedestal configuration" : ["add","delete","change","view"],
	23	"usrprx configuration" : ["add","delete","change","view"],
	24	"tx code" : ["add","delete","change","view"],
	25	"usrptx configuration" : ["add","delete","change","view"],
	26	},
	27
	28	"Operator": {
	29	#Specific permissions
	30	"profile" : ["view"],
	31	"experiment" : ["view"],
	32	"configuration" : ["view"],
	33	"device" : ["view"],
	34	"device type" : ["view"],
	35	"generator configuration" : ["view"],
	36	"pedestal configuration" : ["view"],
	37	"usrprx configuration" : ["view"],
	38	"tx code" : ["view"],
	39	"usrptx configuration" : ["view"],
	40	},
	41	}
	42
	43	class Command(BaseCommand):
	44
	45	help = "Creates read only default permission groups for users"
	46
	47	def handle(self, args, *options):
	48	for group_name in GROUPS:
	49	try:
	50	Group.objects.get(name=group_name)
	51	self.stdout.write(f'Local group "{group_name}" currently exists')
	52	continue
	53	except:
	54	new_group = Group.objects.create(name=group_name)
	55	# Loop models in group
	56	for app_model in GROUPS[group_name]:
	57
	58	# Loop permissions in group/model
	59	for permission_name in GROUPS[group_name][app_model]:
	60
	61	# Generate permission name as Django would generate it
	62	name = "Can {} {}".format(permission_name, app_model)
	63	self.stdout.write(f'Creating "{name}"')
	64
	65	try:
	66	model_add_perm = Permission.objects.get(name=name)
	67	except Permission.DoesNotExist:
	68	logging.warning("Permission not found with name '{}'.".format(name))
	69	continue
	70
	71	new_group.permissions.add(model_add_perm) No newline at end of file

volumes/sirm/apps/accounts/management/commands/create_users.py created 644 +60 0

@@ -0,0 +1,60
	1	import os
	2	from django.core.management.base import BaseCommand
	3	from django.contrib.auth.models import User, Group
	4
	5	class Command(BaseCommand):
	6	"""
	7	Create a superuser and user if none exist
	8	Example:
	9	manage.py create_users
	10	"""
	11
	12	help = "Create a superuser and user if none exist"
	13
	14	def handle(self, args, *options):
	15
	16	users = {
	17	'Superuser': {
	18	'username': os.environ.get('SIRM_SUPER_USER', 'superuser'),
	19	'password': os.environ.get('SIRM_SUPER_PASSWORD', 'SuperuseROJ'),
	20	'email' : os.environ.get('SIRM_SUPER_EMAIL', 'superuser@igp.gob.pe')},
	21	'Developer': {
	22	'username': os.environ.get('SIRM_DEV_USER', 'developer'),
	23	'password': os.environ.get('SIRM_DEV_PASSWORD', 'DevelopeROJ'),
	24	'email' : os.environ.get('SIRM_DEV_EMAIL', 'developer@igp.gob.pe')},
	25	'Operator': {
	26	'username': os.environ.get('SIRM_USER', 'operator'),
	27	'password': os.environ.get('SIRM_PASSWORD', 'OperatoROJ'),
	28	'email' : os.environ.get('SIRM_EMAIL', 'operator@igp.gob.pe')}
	29	}
	30
	31	for key, value in users.items():
	32	if key == 'Superuser':
	33	if User.objects.filter(is_superuser=True):
	34	self.stdout.write(f'Local {key} currently exists')
	35	else:
	36	user, created = User.objects.get_or_create(username=value["username"], first_name=value["username"], email=value["email"], is_superuser = True, is_staff = True)
	37	if created:
	38	user.set_password(value["password"])
	39	user.save()
	40	self.stdout.write(f'Local {key} "{value["username"]}" was created')
	41	else:
	42	self.stdout.write(f'Unable to create this local superuser: "superuser already exists"')
	43	else:
	44	if User.objects.filter(groups__name=key):
	45	if User.objects.filter(groups__name=key, is_superuser=True):
	46	self.stdout.write(f"{key} group must not have a superuser, remove superusers and create a new user")
	47	else:
	48	self.stdout.write(f"Local {key} currently exists")
	49	else:
	50	user, created = User.objects.get_or_create(username=value["username"], first_name=value["username"], email=value["email"])
	51	if created:
	52	user.set_password(value["password"])
	53	user.save()
	54	self.stdout.write(f'Local {key} "{value["username"]}" was created')
	55
	56	group = Group.objects.get(name=key)
	57	group.user_set.add(user)
	58	self.stdout.write(f'Local {key} "{value["username"]}" was added to {key} group')
	59	else:
	60	self.stdout.write(f'Unable to create and join to {key} group this local user: "user already exists"') No newline at end of file

.env +10 0

             #General settings
             TZ=America/Lima
             LC_ALL=C.UTF-8
             SIRM_SITE=<SIRM SITE>
             PROC_SITE=<PROC SITE>
             CAM_SITE=<CAM SITE>
             SCHAIN_SITE=<SCHAIN SITE>
             GENERAL_PORT=<GENERAL PORT>
             BROKER_URL=<BROKER SITE>
             SOPHY_TOPIC=<SOPHY TOPIC>
             TXA_SITE=<IP TXA>
             TXB_SITE=<IP TXB>
             SIRM_MAX_UPLOAD_SIZE_MB=<SIZE MB>
             #Pedestal - az offset
             AZ_OFFSET=<AZ OFFSET>
             #Postgres settings
             POSTGRES_PORT_5432_TCP_ADDR=sirm-postgres
             POSTGRES_PORT_5432_TCP_PORT=5432
             DB_NAME=radarsys
             DB_USER=docker
             DB_PASSWORD=docker
             PGDATA=/var/lib/postgresql/data
             #Volumes - path
             EXPOSE_SIRM=./volumes/sirm
             EXPOSE_PROC=./volumes/proc
             EXPOSE_CAM=/path/to/cam
             EXPOSE_SCHAIN=./volumes/schain
             EXPOSE_NAS=/path/to/nas_data
             EXPOSE_PGDATA=/path/to/pg_data
             EXPOSE_CERTS=/path/to/certs
             EXPOSE_DHPARAM=/path/to/dhparam
             #Superuser settings
+            SIRM_SUPER_USER=*****
+            SIRM_SUPER_PASSWORD=*******
+            SIRM_SUPER_EMAIL=*****@igp.gob.pe
+            #Developer user settings
+            SIRM_DEV_USER=*****
+            SIRM_DEV_PASSWORD=*******
+            SIRM_DEV_EMAIL=*****@igp.gob.pe
+            #Operator user settings
             SIRM_USER=*****
             SIRM_PASSWORD=*******
             SIRM_EMAIL=*****@igp.gob.pe

docker-compose.yml +8 -2

             # docker-compose up -d --build
             version: '3'
             volumes:
               sirm_web:
                 name: sirm_web
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_SIRM}"
               sirm_pgdata:
                 name: sirm_pgdata
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_PGDATA}"
               sirm_certs:
                 name: sirm_certs
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_CERTS}"
               sirm_dhparam:
                 name: sirm_dhparam
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_DHPARAM}"
               sirm_proc:
                 name: sirm_proc
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_PROC}"
               sirm_nas:
                 name: sirm_nas
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_NAS}"
               sirm_cam:
                 name: sirm_cam
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_CAM}"
               sirm_schain:
                 name: sirm_schain
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_SCHAIN}"
             services:
               sirm-nginx-proxy:
                 container_name: sirm-nginx-proxy
                 restart: always
                 build:
                   context: ./images/
                   dockerfile: nginx-proxy/Dockerfile
                   args:
                     - SIRM_MAX_UPLOAD_SIZE_MB=${SIRM_MAX_UPLOAD_SIZE_MB}
                 depends_on:
                   - sirm-web
                 networks:
                   - frontend_sirm
                   - backend_sirm
                 ports:
                   - 0.0.0.0:${GENERAL_PORT}:80
                 volumes:
                   - /var/run/docker.sock:/tmp/docker.sock:ro
                   - sirm_certs:/etc/nginx/certs:ro
                   - sirm_dhparam:/etc/nginx/dhparam
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-web:
                 container_name: 'sirm-web'
                 restart: always
                 build:
                   context: .
                 environment:
                   - LC_ALL=${LC_ALL}
                   - DB_USER=${DB_USER}
                   - DB_NAME=${DB_NAME}
                   - DB_PASSWORD=${DB_PASSWORD}
                   - POSTGRES_PORT_5432_TCP_ADDR=${POSTGRES_PORT_5432_TCP_ADDR}
                   - POSTGRES_PORT_5432_TCP_PORT=${POSTGRES_PORT_5432_TCP_PORT}
                   - EXPOSE_NAS=${EXPOSE_NAS}
                   - PROC_SITE=${PROC_SITE}
                   - SCHAIN_SITE=${SCHAIN_SITE}
+                  - SIRM_SUPER_USER=${SIRM_SUPER_USER}
+                  - SIRM_SUPER_PASSWORD=${SIRM_SUPER_PASSWORD}
+                  - SIRM_SUPER_EMAIL=${SIRM_SUPER_EMAIL}
+                  - SIRM_DEV_USER=${SIRM_DEV_USER}
+                  - SIRM_DEV_PASSWORD=${SIRM_DEV_PASSWORD}
+                  - SIRM_DEV_EMAIL=${SIRM_DEV_EMAIL}
                   - SIRM_USER=${SIRM_USER}
                   - SIRM_PASSWORD=${SIRM_PASSWORD}
                   - SIRM_EMAIL=${SIRM_EMAIL}
                   - AZ_OFFSET=${AZ_OFFSET}
                   - VIRTUAL_HOST=${SIRM_SITE}
                 volumes:
                   - 'sirm_web:/workspace/sirm'
                   - 'sirm_nas:/data'
                 depends_on:
                   - sirm-postgres
                 networks:
                   - frontend_sirm
                   - backend_sirm
                 labels:
                   ofelia.enabled: "true"
                   ofelia.job-exec.restart-reception.schedule: "0 1/5 * * * *"
                   ofelia.job-exec.restart-reception.command: "python manage.py restart_reception"
                   ofelia.job-exec.restart-pedestal.schedule: "0 2/10 * * * *"
                   ofelia.job-exec.restart-pedestal.command: "python manage.py restart_pedestal"
                   ofelia.job-exec.restart-experiment.schedule: "0 0 5 * * *"
                   ofelia.job-exec.restart-experiment.command: "python manage.py restart_experiment"
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-job:
                 container_name: 'sirm-job'
-                image: mcuadros/ofelia:latest
+                image: mcuadros/ofelia:v0.3.6
                 depends_on:
                   - sirm-web
                 networks:
-                  - frontend_sirm
+                  #- frontend_sirm
                   - backend_sirm
                 command: daemon --docker
                 volumes:
                   - /var/run/docker.sock:/var/run/docker.sock:ro
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-postgres:
                 container_name: 'sirm-postgres'
                 restart: always
                 build:
                   context: ./images/
                   dockerfile: postgres/Dockerfile
                   args:
                     - PGDATA=${PGDATA}
                 environment:
                   - LC_ALL=${LC_ALL}
                   - DB_USER=${DB_USER}
                   - DB_NAME=${DB_NAME}
                   - DB_PASSWORD=${DB_PASSWORD}
                   - POSTGRES_PORT_5432_TCP_ADDR=${POSTGRES_PORT_5432_TCP_ADDR}
                   - POSTGRES_PORT_5432_TCP_PORT=${POSTGRES_PORT_5432_TCP_PORT}
                 volumes:
                   - sirm_pgdata:/var/lib/postgresql/data
                 networks:
                   - backend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-proc:
                 container_name: 'sirm-proc'
                 restart: always
                 build:
                   context: ./volumes/proc/
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - SOPHY_TOPIC=${SOPHY_TOPIC}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                   - SCHAIN_SITE=${SCHAIN_SITE}
                   - VIRTUAL_HOST=${PROC_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-monitor:
                 container_name: 'sirm-monitor'
                 restart: always
                 image: 'sirm_sirm-proc'
                 command: ["python", "monitor.py"]
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 depends_on:
                   - sirm-proc
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-acq:
                 container_name: 'sirm-acq'
                 restart: always
                 image: 'sirm_sirm-proc'
                 command: ["python", "acq.py"]
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                   - PROC_SITE=${PROC_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 depends_on:
                   - sirm-proc
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-cam:
                 container_name: 'sirm-cam'
                 image: bkjaya1952/ivms4200-v2.8.2.2_ml-linux
                 restart: always
                 environment:
                   - VIRTUAL_HOST=${CAM_SITE}
                 volumes:
                   - 'sirm_cam:/root/.wine/drive_c/iVMS-4200'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-schain:
                 container_name: 'sirm-schain'
                 restart: always
                 build:
                   context: ./volumes/schain/
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - BACKEND=Agg
                   - TZ=${TZ}
                   - VIRTUAL_HOST=${SCHAIN_SITE}
                 volumes:
                   - 'sirm_nas:/data'
                   - 'sirm_schain:/app'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
             networks:
               frontend_sirm:
                 name: frontend_sirm
               backend_sirm:
                 name: backend_sirm

setup/start_realtime.sh +5 -2

             #!/bin/bash
             python ../setup/prerun.py || { echo '[DJANGO prerun] FAILED. Exiting...' ; exit 1; }
             if [ -f .gitkeep ];
               then
                 echo "The commands 'makemigrations', 'migrate' and '.gitkeep' were not exectued"
               else
                 # Apply database makemigrations
                 echo "Apply makemigrations"
                 python manage.py makemigrations
                 # Apply database migrations
                 echo "Apply database migrations"
                 python manage.py migrate
                 python manage.py loaddata main
                 python manage.py loaddata tx
                 # Collect static files
                 #echo "Collect static files"
                 #python manage.py collectstatic --noinput
                 # Create ".gitkeep" file in "setup" folder
                 echo "Create .gitkeep"
                 touch .gitkeep
             fi
-            echo "Create Superuser"
+            echo "Create Groups"
-            python manage.py createsuperuser_if_none_exists
+            python manage.py create_groups
+            echo "Create User"
+            python manage.py create_users
             echo "Run server"
             python manage.py runserver 0.0.0.0:8080

volumes/sirm/apps/generator/views.py +15 0

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import GeneratorConfiguration
             from .forms import GeneratorConfigurationForm, GeneratorImportForm
+            def is_developer(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Developer' in groups or user.is_staff
+                return 'Developer' in groups or user.is_superuser
+            def is_operator(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Operator' in groups or user.is_staff
+                return 'Operator' in groups or user.is_superuser
             def conf(request, conf_id):
                 conf = get_object_or_404(GeneratorConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 if conf.enable_2:
                     kwargs['dev_conf_keys'] = ['delay', 'periode_1', 'width_1', 'ntx_1', 'periode_2', 'width_2', 'ntx_2', 'selector']
                 else:
                     kwargs['dev_conf_keys'] = ['delay', 'periode_1', 'width_1', 'ntx_1', 'selector']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'generator_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(GeneratorConfiguration, pk=conf_id)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this configuration')
+                    return redirect(conf.get_absolute_url())
                 if request.method=='GET':
                     form = GeneratorConfigurationForm(instance=conf)
                 elif request.method=='POST':
                     form = GeneratorConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'Generator configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'Generator Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'generator_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(GeneratorConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = GeneratorImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = GeneratorImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Generator Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'generator_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(GeneratorConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

volumes/sirm/apps/main/models.py +1 -1

             import os
             import json
             import requests
             import time
             from datetime import datetime
             import base64
             try:
                 from polymorphic.models import PolymorphicModel
             except:
                 from polymorphic import PolymorphicModel
             from django.template.base import kwarg_re
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from django.contrib.auth.models import User
             from django.db.models.signals import post_save
             from django.dispatch import receiver
             from apps.main.utils import Params
             DEV_PORTS = {
                             'pedestal'      : 80,
                             'pedestal_dev'  : 80,
                             'generator'     : 80,
                             'usrp_rx'       : 2000,
                             'usrp_tx'       : 2000,
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'Unknown'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Offline'),
                          )
             DEV_TYPES = (
                             ('', 'Select a  device type'),
                             ('pedestal', 'Pedestal Controller'),
                             ('pedestal_dev', 'Pedestal Controller Dev Mode'),
                             ('generator', 'Pulse Generator'),
                             ('usrp_rx', 'Universal Software Radio Peripheral Rx'),
                             ('usrp_tx', 'Universal Software Radio Peripheral Tx'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Cancelled'),             #YELLOW
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #BLUE
                              (4,'Unknown'),               #WHITE
                              (5,'Other'),                 #ORANGE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Profile(models.Model):
                 user = models.OneToOneField(User, on_delete=models.CASCADE)
                 theme = models.CharField(max_length=30, default='spacelab')
             @receiver(post_save, sender=User)
             def create_user_profile(sender, instance, created, **kwargs):
                 if created:
                     Profile.objects.create(user=instance)
             @receiver(post_save, sender=User)
             def save_user_profile(sender, instance, **kwargs):
                 instance.profile.save()
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 15, choices = DEV_TYPES, default = 'pedestal')
                 sequence = models.PositiveSmallIntegerField(default=55)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.name.title()
             class Device(models.Model):
                 device_type  = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
                 ip_address   = models.GenericIPAddressField(verbose_name = 'IP address', protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description  = models.TextField(blank=True, null=True)
                 status       = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
                 conf_active  = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     ret = self.device_type
                     return str(ret)
                 @property
                 def name(self):
                     return str(self)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "primary"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_device', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='pedestal':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip      = [int(x) for x in ip_address.split('.')]
                         dns     = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet  = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message    = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Experiment(PolymorphicModel):
                 name       = models.CharField(max_length=40, default='', unique=True)
                 pedestal   = models.ForeignKey('pedestal.PedestalConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "pedestal_conf")
                 generator = models.ForeignKey('Device', null=False, blank=False, on_delete=models.PROTECT, default=2, editable=False, limit_choices_to={'device_type__name': 'generator'}, related_name = "generator_conf")
                 reception_rx    = models.ForeignKey('usrp_rx.USRPRXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "usrp_rx_CONF")
                 transmission_tx = models.ForeignKey('usrp_tx.USRPTXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "usrp_tx")
                 task       = models.CharField(max_length=36, default='', blank=True, null=True)
                 status     = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
                 author     = models.ForeignKey(User, null=True, blank=True, on_delete=models.CASCADE)
                 hash       = models.CharField(default='', max_length=64, null=True, blank=True)
                 latitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 longitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 altitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 heading = models.FloatField(null=True, blank=True)
                 mode_stop = models.CharField(max_length=3, null=False, blank=False, default='web', editable=False)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % (self.name)
                 def jsonify(self):
                     data = {}
                     ignored = []
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['configurations'] = ['{}'.format(conf.pk) for
                         conf in Configuration.objects.filter(experiment=self, type=0)]
                     return data
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self)
                     return self
                 def generator_start(self):
                     try:
                         experiment = get_object_or_404(Experiment, pk=self.id)
                         generator_url = experiment.generator.url()
                         period = self.transmission_tx.ipp*2/0.3
                         if self.transmission_tx.enable_2:
                             payload = {"Delay": 1 + self.transmission_tx.delay, "periode1": period, "width1": self.transmission_tx.pulse_1 + 6, "repeatability1": self.transmission_tx.repetitions_1, "periode2": period, "width2": self.transmission_tx.pulse_2 + 6, "repeatability2": self.transmission_tx.repetitions_2, "enable": 1}
                         else:
                             payload = {"Delay": 1 + self.transmission_tx.delay, "periode1": period, "width1": self.transmission_tx.pulse_1 + 6, "repeatability1": 1, "periode2": period, "width2": self.transmission_tx.pulse_1 + 6, "repeatability2": 1, "enable": 1}
                         json_trmode = json.dumps(payload)
                         base64_trmode = base64.standard_b64encode(json_trmode.encode('ascii'))
                         trmode_url = generator_url + "trmode?params="
                         complete_url_trmode = trmode_url + base64_trmode.decode('ascii')
                         requests.get(complete_url_trmode)
                     except:
                         return False
                     return True
                 def generator_stop(self):
                     try:
                         experiment = get_object_or_404(Experiment, pk=self.id)
                         generator_url = experiment.generator.url()
                         payload = {"enable": 0}
                         json_trmode_selector = json.dumps(payload)
                         base64_trmode_selector = base64.standard_b64encode(json_trmode_selector.encode('ascii'))
                         trmode_url = generator_url + "trmode?params="
                         url_trmode_selector = trmode_url + base64_trmode_selector.decode('ascii')
                         requests.get(url_trmode_selector)
                     except:
                         return False
                     return True
                 def start(self):
                     '''
                     Configure and start experiments's devices
                     '''
                     all_status = Experiment.objects.filter(status=2)
                     if self.status != 2:
                         if len(all_status) == 0:
                             data = {
                                 'name': '{}@{}'.format(self.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S')),
                                 'latitude': self.latitude,
                                 'longitude': self.longitude,
                                 'altitude': self.altitude,
                                 'heading': self.heading
                             }
                             try:
                                 data['pedestal'] = self.pedestal.start_device(name_experiment=data['name'])
                                 time.sleep(1.0)
                                 self.generator_start()
                                 time.sleep(1.0)
                                 data['usrp_tx'] = self.transmission_tx.start_device(name_experiment=data['name'])
                                 time.sleep(1.0)
                                 data['usrp_rx'] = self.reception_rx.start_device(name_experiment=data['name'])
                                 time.sleep(0.1)
                                 proc_url = 'http://'+os.environ['PROC_SITE']+'/start'
                                 requests.post(proc_url, json=data)
                             except:
                                 return 0
                             return 2
                         else:
                             return 5
                     else:
                         return 2
                 def stop(self):
                     '''
                     Stop experiments's devices
                     PEDESTAL, GENERATOR & USRP's
                     '''
                     try:
                         self.transmission_tx.stop_device()
                         time.sleep(1.0)
                         self.generator_stop()
                         time.sleep(0.1)
                         self.reception_rx.stop_device()
                         time.sleep(0.1)
                         self.pedestal.reset_device()
-                        time.sleep(14)
+                        time.sleep(0.1)
                         self.pedestal.stop_device()
                         time.sleep(0.1)
                         proc_url = 'http://'+os.environ['PROC_SITE']+'/stop'
                         requests.get(proc_url)
                     except:
                         return 0
                     return 4
                 def get_status(self):
                     if self.status == 3:
                         return
                     confs =  Configuration.objects.filter(experiment=self, type=0)
                     for conf in confs:
                         conf.status_device()
                     total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
                     if total==2*confs.count():
                         status = 1
                     elif total == 3*confs.count():
                         status = 2
                     else:
                         status = 0
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "info"
                     return color
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device     = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model      = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 id              = models.AutoField(primary_key=True)
                 experiment      = models.CharField(default='empty', editable=False, max_length=64, null=True, blank=True)
                 experiment_date = models.DateTimeField(default=datetime.now, editable=False)
                 device          = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
                 type            = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date    = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters      = models.TextField(default='{}')
                 author          = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash            = models.CharField(default='', max_length=64, null=True, blank=True)
                 message         = ""
                 class Meta:
                     db_table = 'db_configurations'
                     ordering = ('device__device_type__name',)
                 def __str__(self):
                     ret = u'{} '.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             ret = '{} MIX '.format(self.device.device_type.name.upper())
                     if 'label' in [f.name for f in self._meta.get_fields()]:
                         ret += '{}'.format(self.label)
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 @property
                 def label(self):
                     return str(self)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'device',
                                'experiment', 'author')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     return data
                 def clone(self, **kwargs):
                     before_id = self.id
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     self.id = before_id
                     return self
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'configurations')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def status_device(self):
                     self.message = 'Function not supported'
                     return False
                 def stop_device(self):
                     self.message = 'Function not supported'
                     return False
                 def start_device(self):
                     self.message = 'Function not supported'
                     return False
                 def write_device(self):
                     self.message = 'Function not supported'
                     return False
                 def read_device(self):
                     self.message = 'Function not supported'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_dev_conf', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_dev_conf', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write(self):
                     return reverse('url_write_dev_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_dev_conf', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_dev_conf', args=[str(self.id)])
                 def get_absolute_url_status(self):
                     return reverse('url_status_dev_conf', args=[str(self.id)])

volumes/sirm/apps/main/views.py +39 -11

             import ast
             import json
             import hashlib
             from datetime import datetime, timedelta
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.utils.safestring import mark_safe
             from django.http import HttpResponseRedirect
             from django.urls import reverse
             from django.db.models import Q
             from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
             from django.contrib import messages
             from django.http.request import QueryDict
             from django.contrib.auth.decorators import login_required, user_passes_test
             from django.utils.timezone import is_aware
             try:
                 from urllib.parse import urlencode
             except ImportError:
                 from urllib import urlencode
             from .forms import ExperimentForm, ExperimentEditionForm, DeviceForm, ConfigurationForm, UploadFileForm, DownloadFileForm, NewForm
             from .forms import FilterForm, ChangeIpForm
             from apps.pedestal.forms import PedestalConfigurationForm, PedestalEditionForm
             from apps.generator.forms import GeneratorConfigurationForm
             from apps.usrp_rx.forms import USRPRXConfigurationForm, USRPRXEditionForm
             from apps.usrp_tx.forms import USRPTXConfigurationForm, USRPTXEditionForm
             from .utils import Params
             from .models              import Experiment, Device, Configuration, DEV_STATES
             from apps.pedestal.models       import PedestalConfiguration
             from apps.generator.models     import GeneratorConfiguration
             from apps.usrp_rx.models     import USRPRXConfiguration
             from apps.usrp_tx.models     import USRPTXConfiguration
             from apps.usrp_tx.validations import validation_usrp_tx_code
             from .gps import gps_response
             #comentario test
             CONF_FORMS = {
                 'pedestal': PedestalConfigurationForm,
                 'generator': GeneratorConfigurationForm,
                 'usrp_rx': USRPRXConfigurationForm,
                 'usrp_tx': USRPTXConfigurationForm,
             }
             CONF_MODELS = {
                 'pedestal': PedestalConfiguration,
                 'generator': GeneratorConfiguration,
                 'usrp_rx': USRPRXConfiguration,
                 'usrp_tx': USRPTXConfiguration,
             }
             MIX_MODES = {
                 '0': 'P',
                 '1': 'S',
             }
             MIX_OPERATIONS = {
                 '0': 'OR',
                 '1': 'XOR',
                 '2': 'AND',
                 '3': 'NAND',
             }
             def is_developer(user):
                 groups = [str(g.name) for g in user.groups.all()]
-                return 'Developer' in groups or user.is_staff
+                #return 'Developer' in groups or user.is_staff
+                return 'Developer' in groups or user.is_superuser
             def is_operator(user):
                 groups = [str(g.name) for g in user.groups.all()]
-                return 'Operator' in groups or user.is_staff
+                #return 'Operator' in groups or user.is_staff
+                return 'Operator' in groups or user.is_superuser
             def has_been_modified(model):
                 prev_hash = model.hash
                 new_hash = hashlib.sha256(str(model.parms_to_dict).encode()).hexdigest()
                 if prev_hash != new_hash:
                     model.hash = new_hash
                     model.save()
                     return True
                 return False
             def index(request):
                 kwargs = {'no_sidebar': True}
                 return render(request, 'index.html', kwargs)
             def devices(request):
                 page = request.GET.get('page')
                 order = ('device_type',)
                 filters = request.GET.copy()
                 kwargs = get_paginator(Device, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=['tags'])
                 kwargs['keys'] = ['device_type',
                                   'ip_address', 'port_address', 'actions']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_device')
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def device(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 kwargs = {}
                 kwargs['device'] = device
                 kwargs['device_keys'] = ['device_type',
                                          'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'device.html', kwargs)
             @login_required
             def device_new(request):
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to create a new experiment')
+                    return redirect('url_devices')
                 if request.method == 'GET':
                     form = DeviceForm()
                 if request.method == 'POST':
                     form = DeviceForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_edit(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this object')
+                    return redirect(device.get_absolute_url())
                 if request.method == 'GET':
                     form = DeviceForm(instance=device)
                 if request.method == 'POST':
                     form = DeviceForm(request.POST, instance=device)
                     if form.is_valid():
                         form.save()
                         return redirect(device.get_absolute_url())
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.delete()
                         return redirect('url_devices')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Device',
                     'object': device,
                     'delete': True
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def device_change_ip(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.change_ip(**request.POST.dict())
                         level, message = device.message.split('|')
                         messages.add_message(request, level, message)
                     else:
                         messages.error(
                             request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Device',
                     'suptitle': 'Change IP',
                     'object': device,
                     'previous': device.get_absolute_url(),
                     'form': ChangeIpForm(initial={'ip_address': device.ip_address}),
                     'message': ' ',
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def experiments(request):
                 page = request.GET.get('page')
                 order = ('id',)
                 filters = request.GET.copy()
                 if 'my experiments' in filters:
                     filters.pop('my experiments', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Experiment, page, order, filters)
                 fields = ['tags']
                 if request.user.is_authenticated:
                     fields.append('my experiments')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'pedestal', 'reception_rx', 'transmission_tx', 'actions']
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_experiment')
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 id_p = experiment.pedestal_id
                 id_rx = experiment.reception_rx_id
                 id_tx = experiment.transmission_tx_id
                 conf_pedestal = PedestalConfiguration.objects.get(id = id_p)
                 conf_rx = USRPRXConfiguration.objects.get(id = id_rx)
                 conf_tx = USRPTXConfiguration.objects.get(id = id_tx)
                 gps_data = gps_response(experiment.generator.ip_address)
                 experiment.latitude = gps_data["statusRpt"]["lat"]
                 experiment.longitude = gps_data["statusRpt"]["lng"]
                 experiment.altitude = gps_data["statusRpt"]["alt"]
                 experiment.save()
                 kwargs = {}
                 kwargs['experiment_keys'] = ['name', 'latitude', 'longitude', 'altitude', 'heading']
                 kwargs['experiment'] = experiment
                 if conf_pedestal.mode == 'position':
                     kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'angle']
                 elif conf_pedestal.mode == 'speed':
                     kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'speed']
                 else:
                     kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'speed', 'angle', 'min_value', 'max_value']
                 kwargs['experiment_pedestal'] = conf_pedestal
                 kwargs['experiment_rx_keys'] = ['ip_address_rx', 'daughterboard_rx', 'antenna_rx', 'samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
                 kwargs['experiment_rx'] = conf_rx
                 if not conf_tx.enable_2:
                     kwargs['experiment_tx_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1', 'code_type_1', 'code_1', 'repetitions_1']
                 else:
                     kwargs['experiment_tx_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1', 'code_type_1', 'code_1', 'repetitions_1',
                                                 'pulse_2', 'code_type_2', 'code_2', 'repetitions_2']
                 kwargs['experiment_tx'] = conf_tx
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Configuration'
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(confs=[conf_pedestal, conf_rx, conf_tx]))
                 return render(request, 'experiment.html', kwargs)
             @login_required
             def experiment_new(request, id_camp=None):
                 if not is_developer(request.user):
-                    messages.error(
+                    messages.error(request, 'You must be an developer to create a new experiment')
-                        request, 'Developer required, to create new Experiments')
+                    return redirect('url_experiments')
-                    return redirect('index')
                 kwargs = {}
                 if request.method == 'GET':
                     kwargs['button'] = 'Create'
                     form = ExperimentForm()
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST)
                     if form.is_valid():
                         experiment = form.save(commit=False)
                         experiment.author = request.user
                         experiment.save()
                         messages.success(request, 'Experiment configuration successfully created')
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this experiment')
+                    return redirect(experiment.get_absolute_url())
                 id_p = experiment.pedestal_id
                 id_rx = experiment.reception_rx_id
                 id_tx = experiment.transmission_tx_id
                 conf_pedestal = PedestalConfiguration.objects.get(id = id_p)
                 conf_rx = USRPRXConfiguration.objects.get(id = id_rx)
                 conf_tx = USRPTXConfiguration.objects.get(id = id_tx)
                 if request.method == 'GET':
                     form = ExperimentEditionForm(instance=experiment)
                     form_pedestal = PedestalEditionForm(instance=conf_pedestal)
                     form_rx = USRPRXEditionForm(instance=conf_rx)
                     form_tx = USRPTXEditionForm(instance=conf_tx)
                 if request.method == 'POST':
                     form = ExperimentEditionForm(request.POST, instance=experiment)
                     form_pedestal = PedestalEditionForm(request.POST, instance=conf_pedestal)
                     form_rx = USRPRXEditionForm(request.POST, instance=conf_rx)
                     form_tx = USRPTXEditionForm(request.POST, instance=conf_tx)
                     if form.is_valid() and form_pedestal.is_valid() and form_rx.is_valid() and form_tx.is_valid():
                         experiment = form.save(commit=False)
                         pedestal = form_pedestal.save(commit=False)
                         rx = form_rx.save(commit=False)
                         tx = form_tx.save(commit=False)
                         pedestal.save()
                         rx.save()
                         validation_usrp_tx_code(request, tx)
                         tx.save()
                         messages.success(request, 'Experiment configuration successfully updated')
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs                     = {}
                 kwargs['form']             = form
                 kwargs['form_pedestal']    = form_pedestal
                 kwargs['form_rx']          = form_rx
                 kwargs['form_tx']          = form_tx
                 kwargs['title']            = 'Experiment'
                 kwargs['suptitle']         = 'Edit'
                 kwargs['button']           = 'Update'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         #for conf in Configuration.objects.filter(experiment=experiment):
                             #conf.delete()
                         experiment.delete()
                         return redirect('url_experiments')
-                    messages.error(request, 'Not enough permission to delete this object')
+                    messages.error(request, 'Not enough permission to delete this experiment')
                     return redirect(experiment.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Experiment',
                     'object': experiment,
                     'delete': True
                 }
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def experiment_export(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 content = experiment.parms_to_dict()
                 content_type = 'application/json'
                 filename = '%s_%s.json' % (experiment.name, experiment.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
                 response.write(json.dumps(content, indent=2))
                 return response
             @login_required
             def experiment_import(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         new_exp = experiment.dict_to_parms(
                             json.load(request.FILES['file']), CONF_MODELS)
                         messages.success(
                             request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                         return redirect(new_exp.get_absolute_url_edit())
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['title'] = 'Experiment'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_import.html', kwargs)
             @login_required
             def experiment_start(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
+                if not is_developer(request.user) and not is_operator(request.user):
+                    messages.error(request, 'You must be an developer or operator to start this experiment')
+                    return redirect(exp.get_absolute_url())
                 if exp.status == 2:
                     messages.warning(request, 'Experiment {} already runnnig'.format(exp.name))
                 else:
                     exp.status = exp.start()
                     if exp.status == 5:
                         messages.warning(request, 'Experiment {} already runnnig'.format(Experiment.objects.filter(status=2)[0]))
                     if exp.status == 0:
                         messages.error(request, 'Experiment {} not start'.format(exp))
                     if exp.status == 2:
                         messages.success(request, 'Experiment {} started'.format(exp))
                     exp.save()
                 return redirect(exp.get_absolute_url())
             @login_required
             def experiment_stop(request, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 exp = get_object_or_404(Experiment, pk=id_exp)
+                if not is_developer(request.user) and not is_operator(request.user):
+                    messages.error(request, 'You must be an developer or operator to stop this experiment')
+                    return redirect(exp.get_absolute_url())
                 if exp.status == 2 or exp.status == 4 or exp.status == 5:
                     for one_exp in all_status:
                         if one_exp != exp:
                             one_exp.status = 4
                             one_exp.mode_stop = 'web'
                             one_exp.save()
                     exp.status = exp.stop()
                     exp.mode_stop = 'web'
                     exp.save()
                     messages.success(request, 'Experiment {} stopped'.format(exp))
                 else:
                     messages.error(request, 'Experiment {} not running'.format(exp))
                 return redirect(exp.get_absolute_url())
             def experiment_status(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 exp.get_status()
                 return redirect(exp.get_absolute_url())
             def experiment_summary(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['radar_system',
                                              'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configurations'] = []
                 kwargs['title'] = 'Experiment Summary'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Verify Parameters'
                 c_vel = 3.0*(10**8)  # m/s
                 ope_freq = experiment.freq*(10**6)  # 1/s
                 radar_lambda = c_vel/ope_freq  # m
                 kwargs['radar_lambda'] = radar_lambda
                 ipp = None
                 nsa = 1
                 code_id = 0
                 tx_line = {}
                 for configuration in configurations.filter(device__device_type__name = 'pedestal'):
                     if configuration.mix:
                         continue
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['NTxs'] = configuration.ntx
                     conf['keys'].append('NTxs')
                     ipp = configuration.ipp
                     conf['IPP'] = ipp
                     conf['keys'].append('IPP')
                     lines = configuration.get_lines(line_type__name='tx')
                     for tx_line in lines:
                         tx_params = json.loads(tx_line.params)
                         conf[tx_line.get_name()] = '{} Km'.format(tx_params['pulse_width'])
                         conf['keys'].append(tx_line.get_name())
                         delays = tx_params['delays']
                         if delays not in ('', '0'):
                             n = len(delays.split(','))
                             taus = '{} Taus: {}'.format(n, delays)
                         else:
                             taus = '-'
                         conf['Taus ({})'.format(tx_line.get_name())] = taus
                         conf['keys'].append('Taus ({})'.format(tx_line.get_name()))
                         for code_line in configuration.get_lines(line_type__name='codes'):
                             code_params = json.loads(code_line.params)
                             code_id = code_params['code']
                             if tx_line.pk == int(code_params['TX_ref']):
                                 conf['Code ({})'.format(tx_line.get_name())] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
                                                                 '-'.join(code_params['codes']))
                                 conf['keys'].append('Code ({})'.format(tx_line.get_name()))
                         for windows_line in configuration.get_lines(line_type__name='windows'):
                             win_params = json.loads(windows_line.params)
                             if tx_line.pk == int(win_params['TX_ref']):
                                 windows = ''
                                 nsa = win_params['params'][0]['number_of_samples']
                                 for i, params in enumerate(win_params['params']):
                                     windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(
                                         i, **params)
                                 conf['Window'] = mark_safe(windows)
                                 conf['keys'].append('Window')
                     kwargs['configurations'].append(conf)
                 for configuration in configurations.filter(device__device_type__name = 'jars'):
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['Type of Data'] = EXPERIMENT_TYPE[configuration.exp_type][1]
                     conf['keys'].append('Type of Data')
                     channels_number = configuration.channels_number
                     exp_type = configuration.exp_type
                     fftpoints = configuration.fftpoints
                     filter_parms = json.loads(configuration.filter_parms)
                     spectral_number = configuration.spectral_number
                     acq_profiles = configuration.acq_profiles
                     cohe_integr = configuration.cohe_integr
                     profiles_block = configuration.profiles_block
                     conf['Num of Profiles'] = acq_profiles
                     conf['keys'].append('Num of Profiles')
                     conf['Prof per Block'] = profiles_block
                     conf['keys'].append('Prof per Block')
                     conf['Blocks per File'] = configuration.raw_data_blocks
                     conf['keys'].append('Blocks per File')
                     if exp_type == 0:  # Short
                         bytes_ = 2
                         b = nsa*2*bytes_*channels_number
                     else:  # Float
                         bytes_ = 4
                         channels = channels_number + spectral_number
                         b = nsa*2*bytes_*fftpoints*channels
                     codes_num = 7
                     if code_id == 2:
                         codes_num = 7
                     elif code_id == 12:
                         codes_num = 15
                     #Jars filter values:
                     clock = float(filter_parms['clock'])
                     filter_2 = int(filter_parms['cic_2'])
                     filter_5 = int(filter_parms['cic_5'])
                     filter_fir = int(filter_parms['fir'])
                     Fs_MHz = clock/(filter_2*filter_5*filter_fir)
                     #Jars values:
                     if ipp is not None:
                         IPP_units = ipp/0.15*Fs_MHz
                         IPP_us = IPP_units / Fs_MHz
                         IPP_s = IPP_units / (Fs_MHz * (10**6))
                         Ts = 1/(Fs_MHz*(10**6))
                         Va = radar_lambda/(4*Ts*cohe_integr)
                         rate_bh = ((nsa-codes_num)*channels_number*2 *
                                     bytes_/IPP_us)*(36*(10**8)/cohe_integr)
                         rate_gh = rate_bh/(1024*1024*1024)
                         conf['Time per Block'] = IPP_s * profiles_block * cohe_integr
                         conf['keys'].append('Time per Block')
                         conf['Acq time'] = IPP_s * acq_profiles
                         conf['keys'].append('Acq time')
                         conf['Data rate'] = str(rate_gh)+" (GB/h)"
                         conf['keys'].append('Data rate')
                         conf['Va (m/s)'] = Va
                         conf['keys'].append('Va (m/s)')
                         conf['Vrange (m/s)'] = 3/(2*IPP_s*cohe_integr)
                         conf['keys'].append('Vrange (m/s)')
                     kwargs['configurations'].append(conf)
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_summary.html', kwargs)
             @login_required
             def experiment_verify(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 experiment_data = experiment.parms_to_dict()
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__ip_address',
                                                 'device__port_address', 'device__status']
                 kwargs['configurations'] = configurations
                 kwargs['experiment_data'] = experiment_data
                 kwargs['title'] = 'Verify Experiment'
                 kwargs['suptitle'] = 'Parameters'
                 kwargs['button'] = 'Update'
                 jars_conf = False
                 rc_conf = False
                 dds_conf = False
                 for configuration in configurations:
                     #-------------------- JARS -----------------------:
                     if configuration.device.device_type.name == 'jars':
                         jars_conf = True
                         jars = configuration
                         kwargs['jars_conf'] = jars_conf
                         filter_parms = json.loads(jars.filter_parms)
                         kwargs['filter_parms'] = filter_parms
                         #--Sampling Frequency
                         clock = filter_parms['clock']
                         filter_2 = filter_parms['cic_2']
                         filter_5 = filter_parms['cic_5']
                         filter_fir = filter_parms['fir']
                         samp_freq_jars = clock/filter_2/filter_5/filter_fir
                         kwargs['samp_freq_jars'] = samp_freq_jars
                         kwargs['jars'] = configuration
                     #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'pedestal' and not configuration.mix:
                         rc_conf = True
                         rc = configuration
                         rc_parms = configuration.parms_to_dict()
                         win_lines = rc.get_lines(line_type__name='windows')
                         if win_lines:
                             dh = json.loads(win_lines[0].params)['params'][0]['resolution']
                             #--Sampling Frequency
                             samp_freq_rc = 0.15/dh
                             kwargs['samp_freq_rc'] = samp_freq_rc
                             kwargs['rc_conf'] = rc_conf
                             kwargs['rc'] = configuration
                     #-------------------- DDS ----------------------:
                     if configuration.device.device_type.name == 'dds':
                         dds_conf = True
                         dds = configuration
                         dds_parms = configuration.parms_to_dict()
                         kwargs['dds_conf'] = dds_conf
                         kwargs['dds'] = configuration
                 #------------Validation------------:
                 #Clock
                 if dds_conf and rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and dds_conf:
                     if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                     if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
                         messages.warning(
                             request, "Devices don't have the same Frequency A.")
                 #------------POST METHOD------------:
                 if request.method == 'POST':
                     if request.POST['suggest_clock']:
                         try:
                             suggest_clock = float(request.POST['suggest_clock'])
                         except:
                             messages.warning(request, "Invalid value in CLOCK IN.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_clock = ""
                     if suggest_clock:
                         if rc_conf:
                             rc.clock_in = suggest_clock
                             rc.save()
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['clock'] = suggest_clock
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.clock = suggest_clock
                             dds.save()
                     if request.POST['suggest_frequencyA']:
                         try:
                             suggest_frequencyA = float(request.POST['suggest_frequencyA'])
                         except:
                             messages.warning(request, "Invalid value in FREQUENCY A.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_frequencyA = ""
                     if suggest_frequencyA:
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['fch'] = suggest_frequencyA
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
                             dds.save()
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_verify.html', kwargs)
             def dev_confs(request):
                 page = request.GET.get('page')
                 order = ('-programmed_date', )
                 filters = request.GET.copy()
                 if 'my configurations' in filters:
                     filters.pop('my configurations', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Configuration, page, order, filters)
                 fields = ['tags', 'historical']
                 if request.user.is_authenticated:
                     fields.append('my configurations')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'device', 'type', 'actions']
                 if request.GET.get('historical') == 'on':
                     kwargs['keys'].insert(3, 'experiment')
                     kwargs['keys'].insert(4, 'experiment_date')
                 else:
                     kwargs['keys'].insert(3, 'programmed_date')
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_dev_conf', args=[0])
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def dev_conf(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_new(request, id_exp=0, id_dev=0):
                 if not is_developer(request.user):
                     messages.error(
                         request, 'Developer required, to create new configurations')
-                    return redirect('index')
+                    return redirect('url_dev_confs')
                 initial = {}
                 kwargs = {}
                 if id_exp != 0:
                     initial['experiment'] = id_exp
                 if id_dev != 0:
                     initial['device'] = id_dev
                 if request.method == 'GET':
                     if id_dev:
                         kwargs['button'] = 'Create'
                         device = Device.objects.get(pk=id_dev)
                         DevConfForm = CONF_FORMS[device.device_type.name]
                         initial['name'] = request.GET['name']
                         form = DevConfForm(initial=initial)
                     else:
                         kwargs['button'] = 'Create'
                         form = ConfigurationForm(initial=initial)
                 if request.method == 'POST':
                     device = Device.objects.get(pk=request.POST['device'])
                     DevConfForm = CONF_FORMS[device.device_type.name]
                     form = DevConfForm(request.POST)
                     kwargs['button'] = 'Create'
                     if form.is_valid():
                         conf = form.save(commit=False)
                         if device.device_type.name == 'usrp_tx':
                             validation_usrp_tx_code(request, conf)
                         conf.save()
                         conf.author = request.user
                         messages.success(request,  device.device_type.name + ' configuration successfully created')
                         return redirect('url_dev_conf', id_conf=conf.pk)
                 kwargs['id_exp'] = id_exp
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_configurations'] = 'active'
                 if id_dev != 0:
                     device = Device.objects.get(pk=id_dev)
                     kwargs['device'] = device.device_type.name
                 return render(request, 'dev_conf_edit.html', kwargs)
             @login_required
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     form = DevConfForm(instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect('url_dev_conf', id_conf=id_conf)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_configurations'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_start(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
+                if not is_developer(request.user) and not is_operator(request.user):
+                    messages.error(request, 'You must be an developer or operator to start this configuration')
+                    return redirect(conf.get_absolute_url())
                 if conf.start_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_stop(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
+                if not is_developer(request.user) and not is_operator(request.user):
+                    messages.error(request, 'You must be an developer or operator to stop this configuration')
+                    return redirect(conf.get_absolute_url())
                 if conf.stop_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_status(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 conf_active = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if conf_active!=conf:
                     url = '#' if conf_active is None else conf_active.get_absolute_url()
                     label = 'None' if conf_active is None else conf_active.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written to device, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_reset(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.reset_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if conf.write_device():
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         messages.success(request, conf.message)
                         if has_been_modified(conf):
                             conf.clone(type=1)
                     else:
                         messages.error(request, conf.message)
                     return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
                 kwargs = {
                     'title': 'Write Configuration',
                     'suptitle': conf.label,
                     'message': 'Are you sure yo want to write this {} configuration?'.format(conf.device),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     parms = conf.read_device()
                     #conf.status_device()
                     if not parms:
                         messages.error(request, conf.message)
                         return redirect(conf.get_absolute_url())
                     form = DevConfForm(initial=parms, instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect(conf.get_absolute_url())
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         data = conf.import_from_file(request.FILES['file'])
                         parms = Params(data=data).get_conf(
                             dtype=conf.device.device_type.name)
                         if parms:
                             form = DevConfForm(initial=parms, instance=conf)
                             kwargs = {}
                             kwargs['id_dev'] = conf.id
                             kwargs['form'] = form
                             kwargs['title'] = 'Device Configuration'
                             kwargs['suptitle'] = 'Parameters imported'
                             kwargs['button'] = 'Save'
                             kwargs['action'] = conf.get_absolute_url_edit()
                             kwargs['previous'] = conf.get_absolute_url()
                             ###### SIDEBAR ######
                             kwargs.update(sidebar(conf=conf))
                             messages.success(
                                 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                             return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_configurations'] = 'active'
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'dev_conf_import.html', kwargs)
             @login_required
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'GET':
                     file_form = DownloadFileForm(conf.device.device_type.name)
                 if request.method == 'POST':
                     file_form = DownloadFileForm(
                         conf.device.device_type.name, request.POST)
                     if file_form.is_valid():
                         fields = conf.export_to_file(
                             format=file_form.cleaned_data['format'])
                         if not fields['content']:
                             messages.error(request, conf.message)
                             return redirect(conf.get_absolute_url_export())
                         response = HttpResponse(content_type=fields['content_type'])
                         response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename']
                         response.write(fields['content'])
                         return response
                     messages.error(request, "Could not export parameters")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Exporting file'
                 kwargs['button'] = 'Export'
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'dev_conf_export.html', kwargs)
             @login_required
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         try:
                             conf.delete()
                         except Exception as e:
                             messages.error(request, "The device configuration is protected")
                         return redirect('url_dev_confs')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(conf.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Configuration',
                     'object': conf,
                     'delete': True
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def sidebar(**kwargs):
                 side_data = {}
                 conf = kwargs.get('conf', None)
                 confs = kwargs.get('confs', None)
                 experiment = kwargs.get('experiment', None)
                 if confs:
                     side_data['side_configurations'] = confs
                 if experiment:
                     side_data['experiment'] = experiment
                     experiments = [experiment]
                     #configurations = experiment.configuration_set.filter(type=0)
                     side_data['side_experiments'] = experiments
                     #side_data['side_configurations'] = configurations.order_by('device__device_type__name')
                 return side_data
             def get_paginator(model, page, order, filters={}, n=8):
                 kwargs = {}
                 query = Q()
                 if isinstance(filters, QueryDict):
                     filters = filters.dict()
                 [filters.pop(key) for key in list(filters) if filters[key] in ('', ' ')]
                 filters.pop('page', None)
                 fields = [f.name for f in model._meta.get_fields()]
                 if 'historical' in filters:
                     filters.pop('historical')
                     filters['type'] = 1
                 elif 'type' in fields:
                     filters['type'] = 0
                 if 'start_date' in filters:
                     filters['start_date__gte'] = filters.pop('start_date')
                 if 'end_date' in filters:
                     filters['start_date__lte'] = filters.pop('end_date')
                 if 'tags' in filters:
                     tags = filters.pop('tags')
                     if 'tags' in fields:
                         query = query | Q(tags__icontains=tags)
                     if 'label' in fields:
                         query = query | Q(label__icontains=tags)
                     if 'device' in fields:
                         query = query | Q(device__device_type__name__icontains=tags)
                     if 'device_type' in fields:
                         query = query | Q(device_type__name__icontains=tags)
                 if 'mine' in filters:
                     filters['author_id'] = filters['mine']
                     filters.pop('mine')
                 object_list = model.objects.filter(query, **filters).order_by(*order)
                 paginator = Paginator(object_list, n)
                 try:
                     objects = paginator.page(page)
                 except PageNotAnInteger:
                     objects = paginator.page(1)
                 except EmptyPage:
                     objects = paginator.page(paginator.num_pages)
                 kwargs['objects'] = objects
                 kwargs['offset'] = (int(page)-1)*n if page else 0
                 return kwargs
             @login_required
             def revoke_tasks(request, id_camp):
                 i         = app.control.inspect()
                 scheduled = list(i.scheduled().values())[0]
                 revoked   = list(i.revoked().values())[0]
                 for t in scheduled:
                     if t['request']['id'] in revoked:
                         continue
                     app.control.revoke(t['request']['id'])
                     exp  = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
                     eta  = t['eta']
                     task = t['request']['name'].split('.')[-1]
                     messages.warning(request, 'Scheduled {} at {} for experiment {} revoked'.format(task, eta, exp.name))
                 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             @login_required
             def show_tasks(request, id_camp):
                 i         = app.control.inspect()
                 scheduled = list(i.scheduled().values())[0]
                 revoked   = list(i.revoked().values())[0]
                 for t in scheduled:
                     if t['request']['id'] in revoked:
                         continue
                     exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
                     eta = t['eta']
                     task = t['request']['name'].split('.')[-1]
                     messages.success(request, 'Task {} scheduled at {} for experiment {}'.format(task, eta, exp.name))
                 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def real_time(request):
                 graphic_path = "/home/fiorella/Pictures/catwbeanie.jpg"
                 kwargs = {}
                 kwargs['title'] = 'CLAIRE'
                 kwargs['suptitle'] = 'Real Time'
                 kwargs['no_sidebar'] = True
                 kwargs['graphic_path'] = graphic_path
                 kwargs['graphic1_path'] = 'http://www.bluemaize.net/im/girls-accessories/shark-beanie-11.jpg'
                 return render(request, 'real_time.html', kwargs)
             def theme(request, theme):
                 user = request.user
                 user.profile.theme = theme
                 user.save()
                 return redirect('index')

volumes/sirm/apps/pedestal/views.py +18 0

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import PedestalConfiguration
             from .forms import PedestalConfigurationForm, PedestalImportForm
+            def is_developer(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Developer' in groups or user.is_staff
+                return 'Developer' in groups or user.is_superuser
+            def is_operator(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Operator' in groups or user.is_staff
+                return 'Operator' in groups or user.is_superuser
             def conf(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 if conf.mode == 'position':
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'angle']
                 elif conf.mode == 'speed':
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'speed']
                 else:
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'speed', 'angle', 'min_value', 'max_value']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'pedestal_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this configuration')
+                    return redirect(conf.get_absolute_url())
                 if request.method=='GET':
                     form = PedestalConfigurationForm(instance=conf)
                     if conf.mode == 'position':
                         form.fields['speed'].disabled = True
                         form.fields['max_value'].disabled = True
                         form.fields['min_value'].disabled = True
                     elif conf.mode == 'speed':
                         form.fields['angle'].disabled = True
                         form.fields['max_value'].disabled = True
                         form.fields['min_value'].disabled = True
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     #classified post fields
                     form = PedestalConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'Pedestal configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'pedestal_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = PedestalImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = PedestalImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'pedestal_import.html', kwargs)
             @login_required
             def conf_reset(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
+                if not is_developer(request.user) and not is_operator(request.user):
+                    messages.error(request, 'You must be an developer or operator to reset this pedestal')
+                    return redirect(conf.get_absolute_url())
                 if conf.reset_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

volumes/sirm/apps/usrp_rx/views.py +14 -2

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import USRPRXConfiguration
             from .forms import USRPRXConfigurationForm, USRPRXImportForm
+            def is_developer(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Developer' in groups or user.is_staff
+                return 'Developer' in groups or user.is_superuser
+            def is_operator(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Operator' in groups or user.is_staff
+                return 'Operator' in groups or user.is_superuser
             def conf(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['ip_address_rx', 'daughterboard_rx', 'antenna_rx', 'samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'usrp_rx_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this configuration')
+                    return redirect(conf.get_absolute_url())
                 if request.method=='GET':
                     form = USRPRXConfigurationForm(instance=conf)
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                     form = USRPRXConfigurationForm(conf_data, instance=conf)
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'USRP Rx configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'USRP Rx Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'usrp_rx_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = USRPRXImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = USRPRXImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'USRP Rx Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'usrp_rx_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

volumes/sirm/apps/usrp_tx/views.py +15 0

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import USRPTXConfiguration, TXCode
             from .forms import USRPTXConfigurationForm, USRPTXImportForm
             from .validations import validation_usrp_tx_code
+            def is_developer(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Developer' in groups or user.is_staff
+                return 'Developer' in groups or user.is_superuser
+            def is_operator(user):
+                groups = [str(g.name) for g in user.groups.all()]
+                #return 'Operator' in groups or user.is_staff
+                return 'Operator' in groups or user.is_superuser
             def conf(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 if not conf.enable_2:
                     kwargs['dev_conf_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1',
                                             'code_type_1', 'code_1', 'repetitions_1']
                 else:
                     kwargs['dev_conf_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1',
                                             'code_type_1', 'code_1', 'repetitions_1', 'pulse_2', 'code_type_2', 'code_2', 'repetitions_2']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'usrp_tx_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
+                if not is_developer(request.user):
+                    messages.error(request, 'You must be an developer to edit this configuration')
+                    return redirect(conf.get_absolute_url())
                 if request.method=='GET':
                     form = USRPTXConfigurationForm(instance=conf)
                 elif request.method=='POST':
                     form = USRPTXConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         tx = form.save(commit=False)
                         validation_usrp_tx_code(request, tx)
                         tx.save()
                         messages.success(request, 'USRP Tx configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'USRP Tx Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'usrp_tx_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = USRPTXImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             #conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = USRPTXImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'USRP Tx Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'usrp_tx_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

volumes/sirm/apps/accounts/management/commands/createsuperuser_if_none_exists.py removed 0 -26

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages