views.py
1864 lines
| 57.7 KiB
| text/x-python
|
PythonLexer
|
r239 | import ast | |
import json | |||
|
r316 | import hashlib | |
|
r306 | from datetime import datetime, timedelta | |
|
r196 | ||
|
r20 | from django.shortcuts import render, redirect, get_object_or_404, HttpResponse | |
|
r106 | from django.utils.safestring import mark_safe | |
|
r84 | from django.http import HttpResponseRedirect | |
from django.core.urlresolvers import reverse | |||
|
r138 | from django.db.models import Q | |
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger | |||
|
r30 | from django.contrib import messages | |
|
r172 | from django.http.request import QueryDict | |
|
r316 | from django.contrib.auth.decorators import login_required, user_passes_test | |
|
r172 | ||
try: | |||
from urllib.parse import urlencode | |||
except ImportError: | |||
from urllib import urlencode | |||
|
r6 | ||
|
r85 | from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm | |
|
r219 | from .forms import OperationSearchForm, FilterForm, ChangeIpForm | |
|
r172 | ||
r311 | from .tasks import task_start | ||
|
r196 | ||
|
r238 | from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm | |
|
r172 | from apps.dds.forms import DDSConfigurationForm | |
|
r13 | from apps.jars.forms import JARSConfigurationForm | |
|
r172 | from apps.cgs.forms import CGSConfigurationForm | |
|
r13 | from apps.abs.forms import ABSConfigurationForm | |
|
r172 | from apps.usrp.forms import USRPConfigurationForm | |
|
r295 | from .utils import Params | |
|
r13 | ||
|
r252 | from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES | |
|
r6 | from apps.cgs.models import CGSConfiguration | |
|
r151 | from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE | |
|
r13 | from apps.usrp.models import USRPConfiguration | |
|
r6 | from apps.abs.models import ABSConfiguration | |
|
r106 | from apps.rc.models import RCConfiguration, RCLine, RCLineType | |
|
r6 | from apps.dds.models import DDSConfiguration | |
|
r0 | ||
r311 | from radarsys.celery import app | ||
|
r211 | ||
|
r13 | CONF_FORMS = { | |
'rc': RCConfigurationForm, | |||
'dds': DDSConfigurationForm, | |||
'jars': JARSConfigurationForm, | |||
'cgs': CGSConfigurationForm, | |||
'abs': ABSConfigurationForm, | |||
'usrp': USRPConfigurationForm, | |||
} | |||
CONF_MODELS = { | |||
|
r6 | 'rc': RCConfiguration, | |
'dds': DDSConfiguration, | |||
'jars': JARSConfiguration, | |||
'cgs': CGSConfiguration, | |||
'abs': ABSConfiguration, | |||
|
r13 | 'usrp': USRPConfiguration, | |
|
r6 | } | |
|
r106 | MIX_MODES = { | |
|
r112 | '0': 'P', | |
'1': 'S', | |||
} | |||
MIX_OPERATIONS = { | |||
|
r106 | '0': 'OR', | |
'1': 'XOR', | |||
'2': 'AND', | |||
|
r112 | '3': 'NAND', | |
|
r106 | } | |
|
r316 | ||
def is_developer(user): | |||
groups = [str(g.name) for g in user.groups.all()] | |||
return 'Developer' in groups or user.is_staff | |||
def is_operator(user): | |||
groups = [str(g.name) for g in user.groups.all()] | |||
return 'Operator' in groups or user.is_staff | |||
def has_been_modified(model): | |||
prev_hash = model.hash | |||
new_hash = hashlib.sha256(str(model.parms_to_dict)).hexdigest() | |||
if prev_hash != new_hash: | |||
model.hash = new_hash | |||
model.save() | |||
return True | |||
return False | |||
|
r6 | def index(request): | |
|
r316 | kwargs = {'no_sidebar': True} | |
|
r172 | ||
|
r13 | return render(request, 'index.html', kwargs) | |
|
r89 | ||
|
r41 | def locations(request): | |
|
r172 | ||
|
r138 | page = request.GET.get('page') | |
order = ('name',) | |||
|
r172 | ||
kwargs = get_paginator(Location, page, order) | |||
|
r138 | kwargs['keys'] = ['name', 'description'] | |
kwargs['title'] = 'Radar System' | |||
|
r41 | kwargs['suptitle'] = 'List' | |
|
r196 | kwargs['no_sidebar'] = True | |
|
r172 | ||
|
r138 | return render(request, 'base_list.html', kwargs) | |
|
r41 | ||
|
r89 | ||
|
r41 | def location(request, id_loc): | |
|
r172 | ||
|
r41 | location = get_object_or_404(Location, pk=id_loc) | |
|
r172 | ||
|
r41 | kwargs = {} | |
kwargs['location'] = location | |||
kwargs['location_keys'] = ['name', 'description'] | |||
|
r172 | ||
|
r41 | kwargs['title'] = 'Location' | |
kwargs['suptitle'] = 'Details' | |||
|
r172 | ||
|
r41 | return render(request, 'location.html', kwargs) | |
|
r69 | ||
|
r316 | @login_required | |
|
r41 | def location_new(request): | |
|
r172 | ||
|
r41 | if request.method == 'GET': | |
form = LocationForm() | |||
|
r172 | ||
|
r41 | if request.method == 'POST': | |
form = LocationForm(request.POST) | |||
|
r172 | ||
|
r41 | if form.is_valid(): | |
form.save() | |||
return redirect('url_locations') | |||
|
r172 | ||
|
r41 | kwargs = {} | |
kwargs['form'] = form | |||
|
r138 | kwargs['title'] = 'Radar System' | |
|
r41 | kwargs['suptitle'] = 'New' | |
kwargs['button'] = 'Create' | |||
|
r172 | ||
|
r138 | return render(request, 'base_edit.html', kwargs) | |
|
r41 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r41 | def location_edit(request, id_loc): | |
|
r172 | ||
|
r41 | location = get_object_or_404(Location, pk=id_loc) | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r41 | form = LocationForm(instance=location) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r41 | form = LocationForm(request.POST, instance=location) | |
|
r172 | ||
|
r41 | if form.is_valid(): | |
form.save() | |||
return redirect('url_locations') | |||
|
r172 | ||
|
r41 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Location' | |||
kwargs['suptitle'] = 'Edit' | |||
kwargs['button'] = 'Update' | |||
|
r172 | ||
|
r138 | return render(request, 'base_edit.html', kwargs) | |
|
r41 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r41 | def location_delete(request, id_loc): | |
|
r172 | ||
|
r41 | location = get_object_or_404(Location, pk=id_loc) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r172 | ||
|
r320 | if is_developer(request.user): | |
|
r41 | location.delete() | |
return redirect('url_locations') | |||
|
r172 | ||
|
r89 | messages.error(request, 'Not enough permission to delete this object') | |
return redirect(location.get_absolute_url()) | |||
|
r172 | ||
|
r89 | kwargs = { | |
|
r316 | 'title': 'Delete', | |
'suptitle': 'Location', | |||
'object': location, | |||
'delete': True | |||
} | |||
|
r172 | ||
|
r89 | return render(request, 'confirm.html', kwargs) | |
|
r41 | ||
|
r13 | def devices(request): | |
|
r172 | ||
|
r138 | page = request.GET.get('page') | |
|
r316 | order = ('location', 'device_type') | |
|
r172 | ||
|
r316 | filters = request.GET.copy() | |
kwargs = get_paginator(Device, page, order, filters) | |||
form = FilterForm(initial=request.GET, extra_fields=['tags']) | |||
kwargs['keys'] = ['device_type', 'location', | |||
'ip_address', 'port_address', 'actions'] | |||
|
r13 | kwargs['title'] = 'Device' | |
kwargs['suptitle'] = 'List' | |||
|
r196 | kwargs['no_sidebar'] = True | |
|
r316 | kwargs['form'] = form | |
kwargs['add_url'] = reverse('url_add_device') | |||
filters.pop('page', None) | |||
kwargs['q'] = urlencode(filters) | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r138 | return render(request, 'base_list.html', kwargs) | |
|
r2 | ||
|
r89 | ||
|
r13 | def device(request, id_dev): | |
|
r172 | ||
|
r20 | device = get_object_or_404(Device, pk=id_dev) | |
|
r172 | ||
|
r2 | kwargs = {} | |
|
r13 | kwargs['device'] = device | |
|
r316 | kwargs['device_keys'] = ['device_type', | |
'ip_address', 'port_address', 'description'] | |||
|
r172 | ||
|
r13 | kwargs['title'] = 'Device' | |
kwargs['suptitle'] = 'Details' | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'device.html', kwargs) | |
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def device_new(request): | |
|
r172 | ||
|
r13 | if request.method == 'GET': | |
form = DeviceForm() | |||
|
r172 | ||
|
r13 | if request.method == 'POST': | |
form = DeviceForm(request.POST) | |||
|
r172 | ||
|
r13 | if form.is_valid(): | |
form.save() | |||
return redirect('url_devices') | |||
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Device' | |||
kwargs['suptitle'] = 'New' | |||
kwargs['button'] = 'Create' | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r172 | ||
|
r138 | return render(request, 'base_edit.html', kwargs) | |
|
r6 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def device_edit(request, id_dev): | |
|
r172 | ||
|
r20 | device = get_object_or_404(Device, pk=id_dev) | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r13 | form = DeviceForm(instance=device) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r13 | form = DeviceForm(request.POST, instance=device) | |
|
r172 | ||
|
r2 | if form.is_valid(): | |
form.save() | |||
|
r89 | return redirect(device.get_absolute_url()) | |
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Device' | |||
kwargs['suptitle'] = 'Edit' | |||
kwargs['button'] = 'Update' | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r172 | ||
|
r138 | return render(request, 'base_edit.html', kwargs) | |
|
r6 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def device_delete(request, id_dev): | |
|
r172 | ||
|
r20 | device = get_object_or_404(Device, pk=id_dev) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r172 | ||
|
r320 | if is_developer(request.user): | |
|
r18 | device.delete() | |
return redirect('url_devices') | |||
|
r172 | ||
|
r89 | messages.error(request, 'Not enough permission to delete this object') | |
return redirect(device.get_absolute_url()) | |||
|
r172 | ||
|
r89 | kwargs = { | |
|
r316 | 'title': 'Delete', | |
'suptitle': 'Device', | |||
'object': device, | |||
'delete': True | |||
} | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r172 | ||
|
r89 | return render(request, 'confirm.html', kwargs) | |
|
r172 | ||
|
r316 | @login_required | |
|
r219 | def device_change_ip(request, id_dev): | |
device = get_object_or_404(Device, pk=id_dev) | |||
|
r316 | if request.method == 'POST': | |
|
r219 | ||
|
r320 | if is_developer(request.user): | |
|
r219 | device.change_ip(**request.POST.dict()) | |
|
r236 | level, message = device.message.split('|') | |
messages.add_message(request, level, message) | |||
|
r219 | else: | |
|
r316 | messages.error( | |
request, 'Not enough permission to delete this object') | |||
|
r219 | return redirect(device.get_absolute_url()) | |
kwargs = { | |||
|
r316 | 'title': 'Device', | |
'suptitle': 'Change IP', | |||
'object': device, | |||
'previous': device.get_absolute_url(), | |||
'form': ChangeIpForm(initial={'ip_address': device.ip_address}), | |||
'message': ' ', | |||
} | |||
|
r320 | kwargs['menu_devices'] = 'active' | |
|
r219 | ||
return render(request, 'confirm.html', kwargs) | |||
|
r13 | def campaigns(request): | |
|
r172 | ||
|
r138 | page = request.GET.get('page') | |
|
r320 | order = ('-start_date',) | |
|
r138 | filters = request.GET.copy() | |
kwargs = get_paginator(Campaign, page, order, filters) | |||
|
r172 | ||
|
r316 | form = FilterForm(initial=request.GET, extra_fields=[ | |
'range_date', 'tags', 'template']) | |||
kwargs['keys'] = ['name', 'start_date', 'end_date', 'actions'] | |||
|
r13 | kwargs['title'] = 'Campaign' | |
kwargs['suptitle'] = 'List' | |||
|
r196 | kwargs['no_sidebar'] = True | |
|
r172 | kwargs['form'] = form | |
|
r316 | kwargs['add_url'] = reverse('url_add_campaign') | |
|
r138 | filters.pop('page', None) | |
|
r172 | kwargs['q'] = urlencode(filters) | |
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r138 | return render(request, 'base_list.html', kwargs) | |
|
r13 | ||
|
r89 | ||
|
r13 | def campaign(request, id_camp): | |
|
r172 | ||
|
r20 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r53 | experiments = Experiment.objects.filter(campaign=campaign) | |
|
r172 | ||
|
r13 | form = CampaignForm(instance=campaign) | |
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['campaign'] = campaign | |||
|
r316 | kwargs['campaign_keys'] = ['template', 'name', | |
'start_date', 'end_date', 'tags', 'description'] | |||
|
r172 | ||
|
r89 | kwargs['experiments'] = experiments | |
|
r316 | kwargs['experiment_keys'] = [ | |
'name', 'radar_system', 'start_time', 'end_time'] | |||
|
r172 | ||
|
r13 | kwargs['title'] = 'Campaign' | |
kwargs['suptitle'] = 'Details' | |||
|
r172 | ||
|
r13 | kwargs['form'] = form | |
kwargs['button'] = 'Add Experiment' | |||
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'campaign.html', kwargs) | |
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def campaign_new(request): | |
|
r172 | ||
|
r85 | kwargs = {} | |
|
r172 | ||
|
r13 | if request.method == 'GET': | |
|
r172 | ||
|
r85 | if 'template' in request.GET: | |
|
r316 | if request.GET['template'] == '0': | |
form = NewForm(initial={'create_from': 2}, | |||
|
r85 | template_choices=Campaign.objects.filter(template=True).values_list('id', 'name')) | |
else: | |||
kwargs['button'] = 'Create' | |||
|
r316 | kwargs['experiments'] = Configuration.objects.filter( | |
experiment=request.GET['template']) | |||
|
r85 | kwargs['experiment_keys'] = ['name', 'start_time', 'end_time'] | |
|
r91 | camp = Campaign.objects.get(pk=request.GET['template']) | |
form = CampaignForm(instance=camp, | |||
|
r316 | initial={'name': '{}_{:%Y%m%d}'.format(camp.name, datetime.now()), | |
'template': False}) | |||
|
r85 | elif 'blank' in request.GET: | |
kwargs['button'] = 'Create' | |||
form = CampaignForm() | |||
else: | |||
form = NewForm() | |||
|
r172 | ||
|
r13 | if request.method == 'POST': | |
|
r85 | kwargs['button'] = 'Create' | |
post = request.POST.copy() | |||
experiments = [] | |||
|
r172 | ||
|
r85 | for id_exp in post.getlist('experiments'): | |
exp = Experiment.objects.get(pk=id_exp) | |||
new_exp = exp.clone(template=False) | |||
experiments.append(new_exp) | |||
|
r172 | ||
|
r85 | post.setlist('experiments', []) | |
|
r172 | ||
|
r85 | form = CampaignForm(post) | |
|
r172 | ||
|
r13 | if form.is_valid(): | |
|
r316 | campaign = form.save(commit=False) | |
campaign.author = request.user | |||
|
r85 | for exp in experiments: | |
campaign.experiments.add(exp) | |||
campaign.save() | |||
|
r13 | return redirect('url_campaign', id_camp=campaign.id) | |
|
r172 | ||
|
r13 | kwargs['form'] = form | |
kwargs['title'] = 'Campaign' | |||
kwargs['suptitle'] = 'New' | |||
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'campaign_edit.html', kwargs) | |
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def campaign_edit(request, id_camp): | |
|
r172 | ||
|
r20 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r13 | form = CampaignForm(instance=campaign) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r91 | exps = campaign.experiments.all().values_list('pk', flat=True) | |
post = request.POST.copy() | |||
new_exps = post.getlist('experiments') | |||
post.setlist('experiments', []) | |||
form = CampaignForm(post, instance=campaign) | |||
|
r172 | ||
|
r13 | if form.is_valid(): | |
|
r91 | camp = form.save() | |
for id_exp in new_exps: | |||
if int(id_exp) in exps: | |||
exps.pop(id_exp) | |||
else: | |||
exp = Experiment.objects.get(pk=id_exp) | |||
if exp.template: | |||
camp.experiments.add(exp.clone(template=False)) | |||
else: | |||
camp.experiments.add(exp) | |||
|
r172 | ||
|
r91 | for id_exp in exps: | |
camp.experiments.remove(Experiment.objects.get(pk=id_exp)) | |||
|
r172 | ||
|
r13 | return redirect('url_campaign', id_camp=id_camp) | |
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Campaign' | |||
kwargs['suptitle'] = 'Edit' | |||
kwargs['button'] = 'Update' | |||
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'campaign_edit.html', kwargs) | |
|
r6 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def campaign_delete(request, id_camp): | |
|
r172 | ||
|
r20 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r320 | if is_developer(request.user): | |
|
r172 | ||
|
r85 | for exp in campaign.experiments.all(): | |
for conf in Configuration.objects.filter(experiment=exp): | |||
conf.delete() | |||
exp.delete() | |||
|
r18 | campaign.delete() | |
|
r172 | ||
|
r18 | return redirect('url_campaigns') | |
|
r172 | ||
|
r89 | messages.error(request, 'Not enough permission to delete this object') | |
return redirect(campaign.get_absolute_url()) | |||
|
r172 | ||
|
r89 | kwargs = { | |
|
r316 | 'title': 'Delete', | |
'suptitle': 'Campaign', | |||
'object': campaign, | |||
'delete': True | |||
} | |||
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r89 | return render(request, 'confirm.html', kwargs) | |
|
r211 | ||
|
r316 | @login_required | |
|
r100 | def campaign_export(request, id_camp): | |
|
r172 | ||
|
r100 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r172 | content = campaign.parms_to_dict() | |
|
r100 | content_type = 'application/json' | |
|
r316 | filename = '%s_%s.json' % (campaign.name, campaign.id) | |
|
r172 | ||
|
r100 | response = HttpResponse(content_type=content_type) | |
|
r316 | response['Content-Disposition'] = 'attachment; filename="%s"' % filename | |
|
r266 | response.write(json.dumps(content, indent=2)) | |
|
r172 | ||
|
r100 | return response | |
|
r18 | ||
|
r108 | ||
|
r316 | @login_required | |
|
r108 | def campaign_import(request, id_camp): | |
|
r172 | ||
|
r108 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r172 | ||
|
r108 | if request.method == 'GET': | |
file_form = UploadFileForm() | |||
|
r172 | ||
|
r108 | if request.method == 'POST': | |
file_form = UploadFileForm(request.POST, request.FILES) | |||
|
r172 | ||
|
r108 | if file_form.is_valid(): | |
|
r316 | new_camp = campaign.dict_to_parms( | |
json.load(request.FILES['file']), CONF_MODELS) | |||
messages.success( | |||
request, "Parameters imported from: '%s'." % request.FILES['file'].name) | |||
|
r266 | return redirect(new_camp.get_absolute_url_edit()) | |
|
r172 | ||
|
r108 | messages.error(request, "Could not import parameters from file") | |
|
r172 | ||
|
r108 | kwargs = {} | |
kwargs['title'] = 'Campaign' | |||
kwargs['form'] = file_form | |||
kwargs['suptitle'] = 'Importing file' | |||
kwargs['button'] = 'Import' | |||
|
r320 | kwargs['menu_campaigns'] = 'active' | |
|
r172 | ||
|
r108 | return render(request, 'campaign_import.html', kwargs) | |
|
r13 | def experiments(request): | |
|
r172 | ||
|
r138 | page = request.GET.get('page') | |
order = ('location',) | |||
filters = request.GET.copy() | |||
|
r316 | if 'my experiments' in filters: | |
filters.pop('my experiments', None) | |||
filters['mine'] = request.user.id | |||
|
r138 | kwargs = get_paginator(Experiment, page, order, filters) | |
|
r172 | ||
|
r316 | fields = ['tags', 'template'] | |
if request.user.is_authenticated: | |||
fields.append('my experiments') | |||
|
r172 | ||
|
r316 | form = FilterForm(initial=request.GET, extra_fields=fields) | |
kwargs['keys'] = ['name', 'radar_system', | |||
'start_time', 'end_time', 'actions'] | |||
|
r13 | kwargs['title'] = 'Experiment' | |
kwargs['suptitle'] = 'List' | |||
|
r196 | kwargs['no_sidebar'] = True | |
|
r138 | kwargs['form'] = form | |
|
r316 | kwargs['add_url'] = reverse('url_add_experiment') | |
filters = request.GET.copy() | |||
|
r138 | filters.pop('page', None) | |
|
r172 | kwargs['q'] = urlencode(filters) | |
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r138 | return render(request, 'base_list.html', kwargs) | |
|
r13 | ||
|
r89 | ||
|
r13 | def experiment(request, id_exp): | |
|
r172 | ||
|
r20 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r266 | ||
|
r316 | configurations = Configuration.objects.filter( | |
experiment=experiment, type=0) | |||
|
r172 | ||
|
r13 | kwargs = {} | |
|
r172 | ||
|
r316 | kwargs['experiment_keys'] = ['template', 'radar_system', | |
'name', 'freq', 'start_time', 'end_time'] | |||
|
r13 | kwargs['experiment'] = experiment | |
|
r316 | kwargs['configuration_keys'] = ['name', 'device__ip_address', | |
'device__port_address', 'device__status'] | |||
|
r91 | kwargs['configurations'] = configurations | |
|
r13 | kwargs['title'] = 'Experiment' | |
kwargs['suptitle'] = 'Details' | |||
|
r45 | kwargs['button'] = 'Add Configuration' | |
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r85 | ###### SIDEBAR ###### | |
kwargs.update(sidebar(experiment=experiment)) | |||
|
r172 | ||
|
r13 | return render(request, 'experiment.html', kwargs) | |
|
r85 | ||
|
r316 | @login_required | |
|
r79 | def experiment_new(request, id_camp=None): | |
|
r172 | ||
|
r316 | if not is_developer(request.user): | |
messages.error( | |||
request, 'Developer required, to create new Experiments') | |||
return redirect('index') | |||
|
r85 | kwargs = {} | |
|
r172 | ||
|
r13 | if request.method == 'GET': | |
|
r85 | if 'template' in request.GET: | |
|
r316 | if request.GET['template'] == '0': | |
form = NewForm(initial={'create_from': 2}, | |||
|
r85 | template_choices=Experiment.objects.filter(template=True).values_list('id', 'name')) | |
else: | |||
kwargs['button'] = 'Create' | |||
|
r316 | kwargs['configurations'] = Configuration.objects.filter( | |
experiment=request.GET['template']) | |||
kwargs['configuration_keys'] = ['name', 'device__name', | |||
'device__ip_address', 'device__port_address'] | |||
exp = Experiment.objects.get(pk=request.GET['template']) | |||
|
r172 | form = ExperimentForm(instance=exp, | |
|
r266 | initial={'name': '{}_{:%y%m%d}'.format(exp.name, datetime.now()), | |
|
r172 | 'template': False}) | |
|
r85 | elif 'blank' in request.GET: | |
kwargs['button'] = 'Create' | |||
form = ExperimentForm() | |||
else: | |||
form = NewForm() | |||
|
r172 | ||
|
r6 | if request.method == 'POST': | |
|
r138 | form = ExperimentForm(request.POST) | |
|
r6 | if form.is_valid(): | |
|
r316 | experiment = form.save(commit=False) | |
experiment.author = request.user | |||
experiment.save() | |||
|
r85 | ||
if 'template' in request.GET: | |||
|
r316 | configurations = Configuration.objects.filter( | |
experiment=request.GET['template'], type=0) | |||
|
r85 | for conf in configurations: | |
conf.clone(experiment=experiment, template=False) | |||
|
r172 | ||
|
r13 | return redirect('url_experiment', id_exp=experiment.id) | |
|
r172 | ||
|
r13 | kwargs['form'] = form | |
|
r6 | kwargs['title'] = 'Experiment' | |
kwargs['suptitle'] = 'New' | |||
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'experiment_edit.html', kwargs) | |
|
r6 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def experiment_edit(request, id_exp): | |
|
r172 | ||
|
r20 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r172 | ||
|
r13 | if request.method == 'GET': | |
form = ExperimentForm(instance=experiment) | |||
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r13 | form = ExperimentForm(request.POST, instance=experiment) | |
|
r172 | ||
|
r6 | if form.is_valid(): | |
|
r13 | experiment = form.save() | |
return redirect('url_experiment', id_exp=experiment.id) | |||
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Experiment' | |||
kwargs['suptitle'] = 'Edit' | |||
kwargs['button'] = 'Update' | |||
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r13 | return render(request, 'experiment_edit.html', kwargs) | |
|
r2 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def experiment_delete(request, id_exp): | |
|
r172 | ||
|
r20 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r320 | if is_developer(request.user): | |
|
r91 | for conf in Configuration.objects.filter(experiment=experiment): | |
|
r172 | conf.delete() | |
|
r18 | experiment.delete() | |
|
r85 | return redirect('url_experiments') | |
|
r172 | ||
|
r91 | messages.error(request, 'Not enough permission to delete this object') | |
|
r172 | return redirect(experiment.get_absolute_url()) | |
|
r91 | kwargs = { | |
|
r316 | 'title': 'Delete', | |
'suptitle': 'Experiment', | |||
'object': experiment, | |||
'delete': True | |||
} | |||
|
r172 | ||
|
r91 | return render(request, 'confirm.html', kwargs) | |
|
r18 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r100 | def experiment_export(request, id_exp): | |
|
r172 | ||
|
r100 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r172 | content = experiment.parms_to_dict() | |
|
r100 | content_type = 'application/json' | |
|
r316 | filename = '%s_%s.json' % (experiment.name, experiment.id) | |
|
r172 | ||
|
r100 | response = HttpResponse(content_type=content_type) | |
|
r316 | response['Content-Disposition'] = 'attachment; filename="%s"' % filename | |
|
r266 | response.write(json.dumps(content, indent=2)) | |
|
r172 | ||
|
r100 | return response | |
|
r211 | ||
|
r316 | @login_required | |
|
r108 | def experiment_import(request, id_exp): | |
|
r172 | ||
|
r316 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r108 | configurations = Configuration.objects.filter(experiment=experiment) | |
|
r172 | ||
|
r108 | if request.method == 'GET': | |
file_form = UploadFileForm() | |||
|
r172 | ||
|
r108 | if request.method == 'POST': | |
file_form = UploadFileForm(request.POST, request.FILES) | |||
|
r243 | ||
|
r108 | if file_form.is_valid(): | |
|
r316 | new_exp = experiment.dict_to_parms( | |
json.load(request.FILES['file']), CONF_MODELS) | |||
messages.success( | |||
request, "Parameters imported from: '%s'." % request.FILES['file'].name) | |||
|
r266 | return redirect(new_exp.get_absolute_url_edit()) | |
|
r108 | ||
messages.error(request, "Could not import parameters from file") | |||
|
r172 | ||
|
r108 | kwargs = {} | |
kwargs['title'] = 'Experiment' | |||
kwargs['form'] = file_form | |||
kwargs['suptitle'] = 'Importing file' | |||
kwargs['button'] = 'Import' | |||
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r108 | kwargs.update(sidebar(experiment=experiment)) | |
|
r172 | ||
|
r108 | return render(request, 'experiment_import.html', kwargs) | |
|
r100 | ||
|
r211 | ||
|
r316 | @login_required | |
|
r240 | def experiment_start(request, id_exp): | |
|
r241 | ||
|
r266 | exp = get_object_or_404(Experiment, pk=id_exp) | |
|
r251 | ||
|
r252 | if exp.status == 2: | |
|
r266 | messages.warning(request, 'Experiment {} already runnnig'.format(exp)) | |
|
r240 | else: | |
|
r266 | exp.status = exp.start() | |
|
r316 | if exp.status == 0: | |
|
r240 | messages.error(request, 'Experiment {} not start'.format(exp)) | |
|
r316 | if exp.status == 2: | |
|
r240 | messages.success(request, 'Experiment {} started'.format(exp)) | |
|
r266 | ||
|
r252 | exp.save() | |
|
r240 | ||
return redirect(exp.get_absolute_url()) | |||
|
r316 | @login_required | |
|
r240 | def experiment_stop(request, id_exp): | |
|
r241 | ||
|
r240 | exp = get_object_or_404(Experiment, pk=id_exp) | |
|
r254 | ||
|
r240 | if exp.status == 2: | |
|
r266 | exp.status = exp.stop() | |
|
r240 | exp.save() | |
|
r266 | messages.success(request, 'Experiment {} stopped'.format(exp)) | |
|
r240 | else: | |
|
r241 | messages.error(request, 'Experiment {} not running'.format(exp)) | |
|
r240 | ||
return redirect(exp.get_absolute_url()) | |||
|
r266 | def experiment_status(request, id_exp): | |
exp = get_object_or_404(Experiment, pk=id_exp) | |||
exp.get_status() | |||
return redirect(exp.get_absolute_url()) | |||
|
r316 | @login_required | |
|
r106 | def experiment_mix(request, id_exp): | |
|
r172 | ||
|
r106 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r316 | rc_confs = [conf for conf in RCConfiguration.objects.filter( | |
experiment=id_exp, | |||
type=0, | |||
mix=False)] | |||
if len(rc_confs) < 2: | |||
messages.warning( | |||
request, 'You need at least two RC Configurations to make a mix') | |||
|
r106 | return redirect(experiment.get_absolute_url()) | |
|
r172 | ||
|
r320 | mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True, type=0) | |
|
r172 | ||
|
r106 | if mix_confs: | |
mix = mix_confs[0] | |||
else: | |||
mix = RCConfiguration(experiment=experiment, | |||
device=rc_confs[0].device, | |||
ipp=rc_confs[0].ipp, | |||
clock_in=rc_confs[0].clock_in, | |||
clock_divider=rc_confs[0].clock_divider, | |||
|
r172 | mix=True, | |
|
r106 | parameters='') | |
mix.save() | |||
|
r241 | ||
|
r106 | line_type = RCLineType.objects.get(name='mix') | |
for i in range(len(rc_confs[0].get_lines())): | |||
line = RCLine(rc_configuration=mix, line_type=line_type, channel=i) | |||
|
r241 | line.save() | |
|
r172 | ||
|
r241 | initial = {'name': mix.name, | |
'result': parse_mix_result(mix.parameters), | |||
'delay': 0, | |||
|
r316 | 'mask': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] | |
|
r106 | } | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r106 | form = RCMixConfigurationForm(confs=rc_confs, initial=initial) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r106 | result = mix.parameters | |
if '{}|'.format(request.POST['experiment']) in result: | |||
messages.error(request, 'Configuration already added') | |||
else: | |||
|
r112 | if 'operation' in request.POST: | |
operation = MIX_OPERATIONS[request.POST['operation']] | |||
else: | |||
|
r116 | operation = ' ' | |
|
r172 | ||
|
r112 | mode = MIX_MODES[request.POST['mode']] | |
|
r172 | ||
|
r106 | if result: | |
|
r112 | result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters, | |
|
r316 | request.POST['experiment'], | |
mode, | |||
operation, | |||
float( | |||
request.POST['delay']), | |||
parse_mask( | |||
request.POST.getlist('mask')) | |||
) | |||
|
r106 | else: | |
|
r112 | result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'], | |
|
r316 | mode, | |
operation, | |||
float(request.POST['delay']), | |||
parse_mask( | |||
request.POST.getlist('mask')) | |||
) | |||
|
r172 | ||
|
r106 | mix.parameters = result | |
mix.save() | |||
mix.update_pulses() | |||
|
r172 | ||
|
r106 | initial['result'] = parse_mix_result(result) | |
initial['name'] = mix.name | |||
|
r172 | ||
|
r106 | form = RCMixConfigurationForm(initial=initial, confs=rc_confs) | |
|
r172 | ||
|
r106 | kwargs = { | |
|
r316 | 'title': 'Experiment', | |
'suptitle': 'Mix Configurations', | |||
'form': form, | |||
'extra_button': 'Delete', | |||
'button': 'Add', | |||
'cancel': 'Back', | |||
'previous': experiment.get_absolute_url(), | |||
'id_exp': id_exp, | |||
|
r106 | ||
|
r316 | } | |
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r106 | return render(request, 'experiment_mix.html', kwargs) | |
|
r316 | @login_required | |
|
r106 | def experiment_mix_delete(request, id_exp): | |
|
r172 | ||
r311 | conf = RCConfiguration.objects.get(experiment=id_exp, mix=True, type=0) | ||
|
r106 | values = conf.parameters.split('-') | |
conf.parameters = '-'.join(values[:-1]) | |||
conf.save() | |||
|
r172 | ||
|
r106 | return redirect('url_mix_experiment', id_exp=id_exp) | |
|
r241 | def experiment_summary(request, id_exp): | |
|
r214 | ||
|
r316 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
configurations = Configuration.objects.filter( | |||
experiment=experiment, type=0) | |||
|
r172 | ||
|
r151 | kwargs = {} | |
|
r316 | kwargs['experiment_keys'] = ['radar_system', | |
'name', 'freq', 'start_time', 'end_time'] | |||
|
r151 | kwargs['experiment'] = experiment | |
|
r239 | kwargs['configurations'] = [] | |
|
r151 | kwargs['title'] = 'Experiment Summary' | |
kwargs['suptitle'] = 'Details' | |||
kwargs['button'] = 'Verify Parameters' | |||
|
r172 | ||
|
r316 | c_vel = 3.0*(10**8) # m/s | |
ope_freq = experiment.freq*(10**6) # 1/s | |||
radar_lambda = c_vel/ope_freq # m | |||
|
r266 | kwargs['radar_lambda'] = radar_lambda | |
|
r316 | ipp = None | |
nsa = 1 | |||
|
r266 | code_id = 0 | |
tx_line = {} | |||
|
r172 | ||
|
r316 | for configuration in configurations.filter(device__device_type__name = 'rc'): | |
|
r266 | ||
|
r316 | 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: | |||
|
r266 | codes_num = 7 | |
|
r316 | 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) | |||
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r172 | ||
|
r151 | ###### SIDEBAR ###### | |
kwargs.update(sidebar(experiment=experiment)) | |||
|
r172 | ||
|
r151 | return render(request, 'experiment_summary.html', kwargs) | |
|
r211 | ||
|
r316 | @login_required | |
|
r157 | def experiment_verify(request, id_exp): | |
|
r172 | ||
|
r316 | experiment = get_object_or_404(Experiment, pk=id_exp) | |
|
r266 | experiment_data = experiment.parms_to_dict() | |
|
r316 | configurations = Configuration.objects.filter( | |
experiment=experiment, type=0) | |||
|
r172 | ||
|
r157 | kwargs = {} | |
|
r172 | ||
|
r316 | kwargs['experiment_keys'] = ['template', | |
'radar_system', 'name', 'start_time', 'end_time'] | |||
|
r157 | kwargs['experiment'] = experiment | |
|
r172 | ||
|
r316 | kwargs['configuration_keys'] = ['name', 'device__ip_address', | |
'device__port_address', 'device__status'] | |||
|
r157 | kwargs['configurations'] = configurations | |
kwargs['experiment_data'] = experiment_data | |||
|
r172 | ||
|
r157 | kwargs['title'] = 'Verify Experiment' | |
kwargs['suptitle'] = 'Parameters' | |||
|
r172 | ||
|
r157 | kwargs['button'] = 'Update' | |
|
r172 | ||
|
r157 | jars_conf = False | |
|
r316 | rc_conf = False | |
dds_conf = False | |||
|
r172 | ||
|
r157 | for configuration in configurations: | |
#-------------------- JARS -----------------------: | |||
if configuration.device.device_type.name == 'jars': | |||
jars_conf = True | |||
|
r229 | jars = configuration | |
|
r316 | kwargs['jars_conf'] = jars_conf | |
filter_parms = json.loads(jars.filter_parms) | |||
|
r157 | kwargs['filter_parms'] = filter_parms | |
#--Sampling Frequency | |||
|
r316 | clock = filter_parms['clock'] | |
filter_2 = filter_parms['cic_2'] | |||
filter_5 = filter_parms['cic_5'] | |||
filter_fir = filter_parms['fir'] | |||
|
r157 | samp_freq_jars = clock/filter_2/filter_5/filter_fir | |
|
r172 | ||
|
r157 | kwargs['samp_freq_jars'] = samp_freq_jars | |
|
r316 | kwargs['jars'] = configuration | |
|
r172 | ||
|
r157 | #--------------------- RC ----------------------: | |
|
r239 | if configuration.device.device_type.name == 'rc' and not configuration.mix: | |
|
r157 | rc_conf = True | |
|
r229 | rc = configuration | |
|
r241 | ||
|
r157 | rc_parms = configuration.parms_to_dict() | |
|
r241 | ||
|
r239 | win_lines = rc.get_lines(line_type__name='windows') | |
if win_lines: | |||
dh = json.loads(win_lines[0].params)['params'][0]['resolution'] | |||
|
r157 | #--Sampling Frequency | |
|
r172 | samp_freq_rc = 0.15/dh | |
|
r157 | kwargs['samp_freq_rc'] = samp_freq_rc | |
|
r241 | ||
|
r239 | kwargs['rc_conf'] = rc_conf | |
|
r316 | kwargs['rc'] = configuration | |
|
r172 | ||
|
r157 | #-------------------- DDS ----------------------: | |
if configuration.device.device_type.name == 'dds': | |||
dds_conf = True | |||
|
r229 | dds = configuration | |
|
r157 | dds_parms = configuration.parms_to_dict() | |
|
r172 | ||
|
r157 | kwargs['dds_conf'] = dds_conf | |
|
r316 | kwargs['dds'] = configuration | |
|
r172 | ||
|
r157 | #------------Validation------------: | |
#Clock | |||
if dds_conf and rc_conf and jars_conf: | |||
|
r266 | 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']): | |
|
r157 | messages.warning(request, "Devices don't have the same clock.") | |
elif rc_conf and jars_conf: | |||
|
r266 | if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']): | |
|
r157 | messages.warning(request, "Devices don't have the same clock.") | |
elif rc_conf and dds_conf: | |||
|
r266 | if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']): | |
|
r157 | messages.warning(request, "Devices don't have the same clock.") | |
|
r266 | if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']): | |
|
r316 | messages.warning( | |
request, "Devices don't have the same Frequency A.") | |||
|
r172 | ||
|
r229 | #------------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: | |||
|
r316 | filter_parms = jars.filter_parms | |
filter_parms = ast.literal_eval(filter_parms) | |||
|
r229 | 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: | |||
|
r316 | filter_parms = jars.filter_parms | |
filter_parms = ast.literal_eval(filter_parms) | |||
|
r229 | 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() | |||
|
r172 | ||
|
r320 | kwargs['menu_experiments'] = 'active' | |
|
r157 | kwargs.update(sidebar(experiment=experiment)) | |
return render(request, 'experiment_verify.html', kwargs) | |||
|
r151 | ||
|
r106 | def parse_mix_result(s): | |
|
r172 | ||
|
r106 | values = s.split('-') | |
|
r172 | html = 'EXP MOD OPE DELAY MASK\r\n' | |
|
r112 | if not values or values[0] in ('', ' '): | |
return mark_safe(html) | |||
|
r172 | ||
|
r106 | for i, value in enumerate(values): | |
if not value: | |||
continue | |||
|
r112 | pk, mode, operation, delay, mask = value.split('|') | |
|
r106 | conf = RCConfiguration.objects.get(pk=pk) | |
|
r316 | if i == 0: | |
|
r172 | html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format( | |
|
r316 | conf.name, | |
mode, | |||
' ', | |||
delay, | |||
mask) | |||
|
r106 | else: | |
|
r112 | html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format( | |
|
r316 | conf.name, | |
mode, | |||
operation, | |||
delay, | |||
mask) | |||
|
r172 | ||
|
r106 | return mark_safe(html) | |
|
r316 | ||
|
r106 | def parse_mask(l): | |
|
r172 | ||
|
r106 | values = [] | |
|
r172 | ||
|
r316 | for x in range(16): | |
|
r106 | if '{}'.format(x) in l: | |
values.append(1) | |||
else: | |||
values.append(0) | |||
|
r172 | ||
|
r106 | values.reverse() | |
|
r172 | ||
|
r106 | return int(''.join([str(x) for x in values]), 2) | |
|
r172 | ||
|
r106 | ||
|
r13 | def dev_confs(request): | |
|
r172 | ||
|
r138 | page = request.GET.get('page') | |
|
r316 | order = ('programmed_date', ) | |
|
r138 | filters = request.GET.copy() | |
|
r316 | if 'my configurations' in filters: | |
filters.pop('my configurations', None) | |||
filters['mine'] = request.user.id | |||
|
r138 | kwargs = get_paginator(Configuration, page, order, filters) | |
|
r316 | fields = ['tags', 'template', 'historical'] | |
if request.user.is_authenticated: | |||
fields.append('my configurations') | |||
form = FilterForm(initial=request.GET, extra_fields=fields) | |||
kwargs['keys'] = ['name', 'experiment', | |||
'type', 'programmed_date', 'actions'] | |||
|
r14 | kwargs['title'] = 'Configuration' | |
|
r13 | kwargs['suptitle'] = 'List' | |
|
r196 | kwargs['no_sidebar'] = True | |
|
r172 | kwargs['form'] = form | |
|
r316 | kwargs['add_url'] = reverse('url_add_dev_conf', args=[0]) | |
filters = request.GET.copy() | |||
|
r138 | filters.pop('page', None) | |
|
r172 | kwargs['q'] = urlencode(filters) | |
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r138 | return render(request, 'base_list.html', kwargs) | |
|
r13 | ||
|
r89 | ||
|
r13 | def dev_conf(request, id_conf): | |
|
r172 | ||
|
r20 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r79 | return redirect(conf.get_absolute_url()) | |
|
r172 | ||
|
r79 | ||
|
r316 | @login_required | |
|
r79 | def dev_conf_new(request, id_exp=0, id_dev=0): | |
|
r172 | ||
|
r316 | if not is_developer(request.user): | |
messages.error( | |||
request, 'Developer required, to create new configurations') | |||
return redirect('index') | |||
|
r79 | initial = {} | |
|
r106 | kwargs = {} | |
|
r172 | ||
|
r316 | if id_exp != 0: | |
|
r79 | initial['experiment'] = id_exp | |
|
r172 | ||
|
r316 | if id_dev != 0: | |
|
r79 | initial['device'] = id_dev | |
|
r13 | ||
if request.method == 'GET': | |||
|
r172 | ||
|
r106 | if id_dev: | |
kwargs['button'] = 'Create' | |||
|
r79 | device = Device.objects.get(pk=id_dev) | |
DevConfForm = CONF_FORMS[device.device_type.name] | |||
|
r172 | initial['name'] = request.GET['name'] | |
form = DevConfForm(initial=initial) | |||
|
r106 | else: | |
if 'template' in request.GET: | |||
|
r316 | if request.GET['template'] == '0': | |
choices = [(conf.pk, '{}'.format(conf)) | |||
for conf in Configuration.objects.filter(template=True)] | |||
form = NewForm(initial={'create_from': 2}, | |||
|
r121 | template_choices=choices) | |
|
r106 | else: | |
|
r172 | kwargs['button'] = 'Create' | |
|
r316 | conf = Configuration.objects.get( | |
pk=request.GET['template']) | |||
|
r119 | id_dev = conf.device.pk | |
|
r106 | DevConfForm = CONF_FORMS[conf.device.device_type.name] | |
|
r172 | form = DevConfForm(instance=conf, | |
|
r266 | initial={'name': '{}_{:%y%m%d}'.format(conf.name, datetime.now()), | |
|
r116 | 'template': False, | |
|
r316 | 'experiment': id_exp}) | |
|
r106 | elif 'blank' in request.GET: | |
|
r172 | kwargs['button'] = 'Create' | |
|
r106 | form = ConfigurationForm(initial=initial) | |
else: | |||
|
r172 | form = NewForm() | |
|
r6 | if request.method == 'POST': | |
|
r172 | ||
|
r79 | device = Device.objects.get(pk=request.POST['device']) | |
|
r47 | DevConfForm = CONF_FORMS[device.device_type.name] | |
|
r172 | ||
|
r79 | form = DevConfForm(request.POST) | |
|
r122 | kwargs['button'] = 'Create' | |
|
r6 | if form.is_valid(): | |
|
r316 | conf = form.save(commit=False) | |
conf.author = request.user | |||
conf.save() | |||
|
r172 | ||
|
r316 | if 'template' in request.GET and conf.device.device_type.name == 'rc': | |
lines = RCLine.objects.filter( | |||
rc_configuration=request.GET['template']) | |||
|
r106 | for line in lines: | |
line.clone(rc_configuration=conf) | |||
|
r172 | ||
|
r266 | new_lines = conf.get_lines() | |
for line in new_lines: | |||
line_params = json.loads(line.params) | |||
if 'TX_ref' in line_params: | |||
ref_line = RCLine.objects.get(pk=line_params['TX_ref']) | |||
|
r316 | line_params['TX_ref'] = ['{}'.format( | |
l.pk) for l in new_lines if l.get_name() == ref_line.get_name()][0] | |||
|
r266 | line.params = json.dumps(line_params) | |
line.save() | |||
|
r172 | return redirect('url_dev_conf', id_conf=conf.pk) | |
|
r79 | kwargs['id_exp'] = id_exp | |
|
r6 | kwargs['form'] = form | |
|
r13 | kwargs['title'] = 'Configuration' | |
|
r6 | kwargs['suptitle'] = 'New' | |
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r99 | if id_dev != 0: | |
device = Device.objects.get(pk=id_dev) | |||
|
r119 | kwargs['device'] = device.device_type.name | |
|
r172 | ||
|
r13 | return render(request, 'dev_conf_edit.html', kwargs) | |
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def dev_conf_edit(request, id_conf): | |
|
r172 | ||
|
r20 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r13 | DevConfForm = CONF_FORMS[conf.device.device_type.name] | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r172 | form = DevConfForm(instance=conf) | |
|
r316 | if request.method == 'POST': | |
|
r172 | form = DevConfForm(request.POST, instance=conf) | |
|
r13 | if form.is_valid(): | |
form.save() | |||
return redirect('url_dev_conf', id_conf=id_conf) | |||
|
r172 | ||
|
r13 | kwargs = {} | |
kwargs['form'] = form | |||
kwargs['title'] = 'Device Configuration' | |||
kwargs['suptitle'] = 'Edit' | |||
kwargs['button'] = 'Update' | |||
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r30 | ###### SIDEBAR ###### | |
|
r85 | kwargs.update(sidebar(conf=conf)) | |
|
r172 | ||
|
r91 | return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs) | |
|
r13 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r53 | def dev_conf_start(request, id_conf): | |
|
r172 | ||
|
r53 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r53 | if conf.start_device(): | |
messages.success(request, conf.message) | |||
else: | |||
messages.error(request, conf.message) | |||
|
r172 | ||
|
r185 | #conf.status_device() | |
|
r172 | ||
|
r53 | return redirect(conf.get_absolute_url()) | |
|
r89 | ||
|
r316 | @login_required | |
|
r53 | def dev_conf_stop(request, id_conf): | |
|
r172 | ||
|
r30 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r53 | if conf.stop_device(): | |
messages.success(request, conf.message) | |||
else: | |||
messages.error(request, conf.message) | |||
|
r172 | ||
|
r185 | #conf.status_device() | |
|
r172 | ||
|
r53 | return redirect(conf.get_absolute_url()) | |
|
r89 | ||
|
r326 | @login_required | |
|
r53 | def dev_conf_status(request, id_conf): | |
|
r172 | ||
|
r53 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r326 | if conf.device.device_type.name == 'abs': | |
abs = request.user.profile.abs_active | |||
if abs<>conf: | |||
url = '#' if abs is None else abs.get_absolute_url() | |||
label = 'None' if abs is None else abs.label | |||
messages.warning( | |||
request, | |||
mark_safe('The current configuration has not been written in the modules, the active configuration is <a href="{}">{}</a>'.format( | |||
url, | |||
label | |||
)) | |||
) | |||
return redirect(conf.get_absolute_url()) | |||
|
r53 | if conf.status_device(): | |
messages.success(request, conf.message) | |||
else: | |||
messages.error(request, conf.message) | |||
|
r172 | ||
|
r53 | return redirect(conf.get_absolute_url()) | |
|
r30 | ||
|
r316 | @login_required | |
|
r266 | 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()) | |||
|
r316 | @login_required | |
|
r30 | def dev_conf_write(request, id_conf): | |
|
r172 | ||
|
r30 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r185 | if conf.write_device(): | |
|
r211 | messages.success(request, conf.message) | |
|
r316 | if has_been_modified(conf): | |
conf.clone(type=1, template=False) | |||
|
r53 | else: | |
messages.error(request, conf.message) | |||
|
r172 | ||
|
r306 | return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url()) | |
|
r53 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r53 | def dev_conf_read(request, id_conf): | |
|
r172 | ||
|
r53 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r53 | DevConfForm = CONF_FORMS[conf.device.device_type.name] | |
|
r172 | ||
|
r316 | if request.method == 'GET': | |
|
r172 | ||
|
r53 | parms = conf.read_device() | |
|
r185 | #conf.status_device() | |
|
r172 | ||
|
r53 | if not parms: | |
messages.error(request, conf.message) | |||
return redirect(conf.get_absolute_url()) | |||
|
r172 | ||
|
r53 | form = DevConfForm(initial=parms, instance=conf) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r53 | form = DevConfForm(request.POST, instance=conf) | |
|
r172 | ||
|
r53 | if form.is_valid(): | |
|
r57 | form.save() | |
return redirect(conf.get_absolute_url()) | |||
|
r172 | ||
|
r53 | messages.error(request, "Parameters could not be saved") | |
|
r172 | ||
|
r53 | kwargs = {} | |
kwargs['id_dev'] = conf.id | |||
kwargs['form'] = form | |||
kwargs['title'] = 'Device Configuration' | |||
kwargs['suptitle'] = 'Parameters read from device' | |||
kwargs['button'] = 'Save' | |||
|
r172 | ||
|
r53 | ###### SIDEBAR ###### | |
|
r85 | kwargs.update(sidebar(conf=conf)) | |
|
r172 | ||
|
r316 | return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs) | |
|
r30 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r30 | def dev_conf_import(request, id_conf): | |
|
r172 | ||
|
r30 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | DevConfForm = CONF_FORMS[conf.device.device_type.name] | |
|
r53 | if request.method == 'GET': | |
file_form = UploadFileForm() | |||
|
r172 | ||
|
r53 | if request.method == 'POST': | |
file_form = UploadFileForm(request.POST, request.FILES) | |||
|
r172 | ||
|
r53 | if file_form.is_valid(): | |
|
r172 | ||
|
r266 | data = conf.import_from_file(request.FILES['file']) | |
|
r316 | parms = Params(data=data).get_conf( | |
dtype=conf.device.device_type.name) | |||
|
r172 | ||
|
r53 | if parms: | |
|
r266 | ||
|
r53 | form = DevConfForm(initial=parms, instance=conf) | |
|
r172 | ||
|
r53 | 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() | |||
|
r172 | ||
|
r53 | ###### SIDEBAR ###### | |
|
r85 | kwargs.update(sidebar(conf=conf)) | |
|
r172 | ||
|
r316 | messages.success( | |
request, "Parameters imported from: '%s'." % request.FILES['file'].name) | |||
|
r266 | ||
|
r79 | return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs) | |
|
r53 | ||
messages.error(request, "Could not import parameters from file") | |||
|
r172 | ||
|
r53 | kwargs = {} | |
kwargs['id_dev'] = conf.id | |||
kwargs['title'] = 'Device Configuration' | |||
kwargs['form'] = file_form | |||
kwargs['suptitle'] = 'Importing file' | |||
kwargs['button'] = 'Import' | |||
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r85 | kwargs.update(sidebar(conf=conf)) | |
|
r172 | ||
|
r53 | return render(request, 'dev_conf_import.html', kwargs) | |
|
r30 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r30 | def dev_conf_export(request, id_conf): | |
|
r172 | ||
|
r30 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r53 | if request.method == 'GET': | |
|
r57 | file_form = DownloadFileForm(conf.device.device_type.name) | |
|
r172 | ||
|
r53 | if request.method == 'POST': | |
|
r316 | file_form = DownloadFileForm( | |
conf.device.device_type.name, request.POST) | |||
|
r172 | ||
|
r53 | if file_form.is_valid(): | |
|
r316 | fields = conf.export_to_file( | |
format=file_form.cleaned_data['format']) | |||
|
r276 | if not fields['content']: | |
messages.error(request, conf.message) | |||
return redirect(conf.get_absolute_url_export()) | |||
|
r53 | response = HttpResponse(content_type=fields['content_type']) | |
|
r316 | response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename'] | |
|
r53 | response.write(fields['content']) | |
|
r172 | ||
|
r53 | return response | |
|
r172 | ||
|
r53 | messages.error(request, "Could not export parameters") | |
|
r172 | ||
|
r53 | kwargs = {} | |
kwargs['id_dev'] = conf.id | |||
kwargs['title'] = 'Device Configuration' | |||
kwargs['form'] = file_form | |||
kwargs['suptitle'] = 'Exporting file' | |||
kwargs['button'] = 'Export' | |||
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r53 | return render(request, 'dev_conf_export.html', kwargs) | |
|
r30 | ||
|
r89 | ||
|
r316 | @login_required | |
|
r19 | def dev_conf_delete(request, id_conf): | |
|
r172 | ||
|
r20 | conf = get_object_or_404(Configuration, pk=id_conf) | |
|
r172 | ||
|
r316 | if request.method == 'POST': | |
|
r320 | if is_developer(request.user): | |
|
r18 | conf.delete() | |
|
r91 | return redirect('url_dev_confs') | |
|
r172 | ||
|
r91 | messages.error(request, 'Not enough permission to delete this object') | |
|
r172 | return redirect(conf.get_absolute_url()) | |
|
r91 | kwargs = { | |
|
r316 | 'title': 'Delete', | |
'suptitle': 'Configuration', | |||
'object': conf, | |||
'delete': True | |||
} | |||
|
r320 | kwargs['menu_configurations'] = 'active' | |
|
r172 | ||
|
r91 | return render(request, 'confirm.html', kwargs) | |
|
r25 | ||
|
r85 | ||
def sidebar(**kwargs): | |||
|
r172 | ||
|
r85 | side_data = {} | |
|
r172 | ||
|
r85 | conf = kwargs.get('conf', None) | |
experiment = kwargs.get('experiment', None) | |||
|
r172 | ||
|
r85 | if not experiment: | |
experiment = conf.experiment | |||
|
r172 | ||
|
r85 | if experiment: | |
side_data['experiment'] = experiment | |||
campaign = experiment.campaign_set.all() | |||
if campaign: | |||
side_data['campaign'] = campaign[0] | |||
|
r316 | experiments = campaign[0].experiments.all().order_by('name') | |
|
r85 | else: | |
experiments = [experiment] | |||
configurations = experiment.configuration_set.filter(type=0) | |||
side_data['side_experiments'] = experiments | |||
|
r316 | side_data['side_configurations'] = configurations.order_by( | |
'device__device_type__name') | |||
|
r172 | ||
|
r85 | return side_data | |
|
r46 | ||
|
r316 | ||
def get_paginator(model, page, order, filters={}, n=8): | |||
|
r172 | ||
|
r138 | kwargs = {} | |
query = Q() | |||
if isinstance(filters, QueryDict): | |||
filters = filters.dict() | |||
[filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')] | |||
filters.pop('page', None) | |||
|
r172 | ||
|
r306 | fields = [f.name for f in model._meta.get_fields()] | |
|
r186 | if 'template' in filters: | |
filters['template'] = True | |||
|
r306 | if 'historical' in filters: | |
filters.pop('historical') | |||
filters['type'] = 1 | |||
elif 'type' in fields: | |||
filters['type'] = 0 | |||
|
r138 | 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: | |||
|
r172 | tags = filters.pop('tags') | |
|
r186 | if 'tags' in fields: | |
|
r172 | query = query | Q(tags__icontains=tags) | |
|
r316 | if 'label' in fields: | |
query = query | Q(label__icontains=tags) | |||
|
r186 | if 'location' in fields: | |
|
r138 | query = query | Q(location__name__icontains=tags) | |
|
r186 | if 'device' in fields: | |
query = query | Q(device__device_type__name__icontains=tags) | |||
|
r316 | query = query | Q(device__location__name__icontains=tags) | |
if 'device_type' in fields: | |||
query = query | Q(device_type__name__icontains=tags) | |||
|
r138 | ||
|
r316 | if 'mine' in filters: | |
filters['author_id'] = filters['mine'] | |||
filters.pop('mine') | |||
|
r138 | object_list = model.objects.filter(query, **filters).order_by(*order) | |
paginator = Paginator(object_list, n) | |||
|
r172 | ||
|
r138 | try: | |
objects = paginator.page(page) | |||
except PageNotAnInteger: | |||
objects = paginator.page(1) | |||
except EmptyPage: | |||
objects = paginator.page(paginator.num_pages) | |||
|
r172 | ||
|
r138 | kwargs['objects'] = objects | |
kwargs['offset'] = (int(page)-1)*n if page else 0 | |||
|
r172 | ||
|
r138 | return kwargs | |
|
r46 | ||
|
r316 | ||
|
r50 | def operation(request, id_camp=None): | |
|
r172 | ||
kwargs = {} | |||
|
r196 | kwargs['title'] = 'Radars Operation' | |
|
r175 | kwargs['no_sidebar'] = True | |
|
r320 | kwargs['menu_operation'] = 'active' | |
|
r172 | campaigns = Campaign.objects.filter(start_date__lte=datetime.now(), | |
end_date__gte=datetime.now()).order_by('-start_date') | |||
|
r174 | ||
|
r172 | if id_camp: | |
|
r316 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
form = OperationForm( | |||
initial={'campaign': campaign.id}, campaigns=campaigns) | |||
|
r172 | kwargs['campaign'] = campaign | |
else: | |||
|
r306 | # form = OperationForm(campaigns=campaigns) | |
kwargs['campaigns'] = campaigns | |||
|
r172 | return render(request, 'operation.html', kwargs) | |
|
r69 | #---Experiment | |
|
r81 | keys = ['id', 'name', 'start_time', 'end_time', 'status'] | |
|
r50 | kwargs['experiment_keys'] = keys[1:] | |
kwargs['experiments'] = experiments | |||
#---Radar | |||
|
r211 | kwargs['locations'] = campaign.get_experiments_by_radar() | |
kwargs['form'] = form | |||
|
r172 | ||
|
r69 | return render(request, 'operation.html', kwargs) | |
|
r89 | ||
|
r211 | @login_required | |
|
r196 | def radar_start(request, id_camp, id_radar): | |
|
r211 | ||
|
r316 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r196 | experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments'] | |
|
r306 | now = datetime.now() | |
|
r196 | for exp in experiments: | |
|
r306 | start = datetime.combine(datetime.now().date(), exp.start_time) | |
r311 | end = datetime.combine(datetime.now().date(), exp.end_time) | ||
|
r306 | if end < start: | |
end += timedelta(1) | |||
|
r316 | ||
|
r196 | if exp.status == 2: | |
|
r316 | messages.warning( | |
request, 'Experiment {} already running'.format(exp)) | |||
|
r196 | continue | |
|
r211 | ||
|
r196 | if exp.status == 3: | |
|
r316 | messages.warning( | |
request, 'Experiment {} already programmed'.format(exp)) | |||
|
r196 | continue | |
|
r211 | ||
|
r306 | if start > campaign.end_date or start < campaign.start_date: | |
|
r196 | messages.warning(request, 'Experiment {} out of date'.format(exp)) | |
continue | |||
|
r211 | ||
|
r306 | if now > start and now <= end: | |
r311 | exp.status = 3 | ||
exp.save() | |||
task = task_start.delay(exp.id) | |||
|
r196 | exp.status = task.wait() | |
|
r316 | if exp.status == 0: | |
|
r196 | messages.error(request, 'Experiment {} not start'.format(exp)) | |
|
r316 | if exp.status == 2: | |
|
r196 | messages.success(request, 'Experiment {} started'.format(exp)) | |
else: | |||
|
r316 | task = task_start.apply_async( | |
(exp.pk, ), eta=start+timedelta(hours=5)) | |||
r311 | exp.task = task.id | ||
|
r196 | exp.status = 3 | |
|
r316 | messages.success( | |
request, 'Experiment {} programmed to start at {}'.format(exp, start)) | |||
|
r211 | ||
|
r196 | exp.save() | |
|
r172 | ||
|
r196 | return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | |
|
r84 | ||
|
r88 | ||
|
r211 | @login_required | |
|
r84 | def radar_stop(request, id_camp, id_radar): | |
|
r211 | ||
|
r316 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r211 | experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments'] | |
for exp in experiments: | |||
r311 | if exp.task: | ||
app.control.revoke(exp.task) | |||
|
r196 | if exp.status == 2: | |
r311 | exp.stop() | ||
|
r211 | messages.warning(request, 'Experiment {} stopped'.format(exp)) | |
r311 | exp.status = 1 | ||
exp.save() | |||
|
r85 | ||
|
r196 | return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | |
|
r172 | ||
|
r88 | ||
|
r211 | @login_required | |
|
r88 | def radar_refresh(request, id_camp, id_radar): | |
|
r172 | ||
|
r316 | campaign = get_object_or_404(Campaign, pk=id_camp) | |
|
r211 | experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments'] | |
for exp in experiments: | |||
|
r196 | exp.get_status() | |
|
r88 | ||
|
r196 | return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | |
|
r282 | ||
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' | |||
r311 | return render(request, 'real_time.html', kwargs) | ||
|
r320 | ||
def theme(request, theme): | |||
user = request.user | |||
user.profile.theme = theme | |||
user.save() | |||
return redirect('index') |