views.py
1821 lines
| 55.9 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 | |||
|
r41 | if request.user.is_staff: | ||
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) | ||||
kwargs['menu'] = 'device' | ||||
|
r172 | |||
|
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' | ||||
|
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' | ||||
|
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' | ||||
|
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 | |||
|
r18 | if request.user.is_staff: | ||
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 | ||||
} | ||||
|
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 | |||
if request.user.is_staff: | ||||
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': ' ', | ||||
} | ||||
|
r219 | |||
return render(request, 'confirm.html', kwargs) | ||||
|
r13 | def campaigns(request): | ||
|
r172 | |||
|
r138 | page = request.GET.get('page') | ||
order = ('start_date',) | ||||
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) | ||
|
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' | ||||
|
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' | ||||
|
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' | ||||
|
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': | ||
|
r18 | if request.user.is_staff: | ||
|
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 | ||||
} | ||||
|
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' | ||||
|
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) | ||
|
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 | ||
|
r172 | |||
|
r316 | kwargs['configuration_keys'] = ['name', 'device__ip_address', | ||
'device__port_address', 'device__status'] | ||||
|
r91 | kwargs['configurations'] = configurations | ||
|
r172 | |||
|
r13 | kwargs['title'] = 'Experiment' | ||
kwargs['suptitle'] = 'Details' | ||||
|
r172 | |||
|
r45 | kwargs['button'] = 'Add Configuration' | ||
|
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' | ||||
|
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' | ||||
|
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': | ||
|
r18 | if request.user.is_staff: | ||
|
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' | ||||
|
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 | |||
|
r106 | mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True) | ||
|
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 | } | ||
|
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) | ||||
|
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 | |||
|
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) | ||
|
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' | ||
|
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' | ||||
|
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 | |||
|
r53 | def dev_conf_status(request, id_conf): | ||
|
r172 | |||
|
r53 | conf = get_object_or_404(Configuration, pk=id_conf) | ||
|
r172 | |||
|
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' | ||||
|
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' | ||||
|
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': | ||
|
r18 | if request.user.is_staff: | ||
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 | ||||
} | ||||
|
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 | ||
|
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) | |||