views.py
1589 lines
| 49.2 KiB
| text/x-python
|
PythonLexer
|
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 | ||
|
r88 | from datetime import datetime | ||
|
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 | ||
|
r138 | from .forms import OperationSearchForm, FilterForm | ||
|
r172 | |||
from apps.rc.forms import RCConfigurationForm | ||||
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 | ||
|
r13 | |||
|
r84 | from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment | ||
|
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 | ||
|
r138 | from django.http.request import QueryDict | ||
|
r157 | #from __builtin__ import False | ||
|
r0 | |||
# Create your views here. | ||||
|
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 | } | ||
|
r89 | |||
|
r6 | def index(request): | ||
|
r0 | kwargs = {} | ||
|
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' | ||
|
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 | |||
|
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 | |||
|
r41 | def location_edit(request, id_loc): | ||
|
r172 | |||
|
r41 | location = get_object_or_404(Location, pk=id_loc) | ||
|
r172 | |||
|
r41 | if request.method=='GET': | ||
form = LocationForm(instance=location) | ||||
|
r172 | |||
|
r41 | if request.method=='POST': | ||
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 | |||
|
r41 | def location_delete(request, id_loc): | ||
|
r172 | |||
|
r41 | location = get_object_or_404(Location, pk=id_loc) | ||
|
r172 | |||
|
r41 | 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 = { | ||
'title': 'Delete', | ||||
'suptitle': 'Location', | ||||
|
r172 | 'object': location, | ||
|
r89 | 'previous': location.get_absolute_url(), | ||
'delete': True | ||||
} | ||||
|
r172 | |||
|
r89 | return render(request, 'confirm.html', kwargs) | ||
|
r41 | |||
|
r13 | def devices(request): | ||
|
r172 | |||
|
r138 | page = request.GET.get('page') | ||
order = ('device_type', 'name') | ||||
|
r172 | |||
kwargs = get_paginator(Device, page, order) | ||||
kwargs['keys'] = ['name', 'ip_address', 'port_address', 'device_type'] | ||||
|
r13 | kwargs['title'] = 'Device' | ||
kwargs['suptitle'] = 'List' | ||||
|
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 | ||
kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description'] | ||||
|
r172 | |||
|
r13 | kwargs['title'] = 'Device' | ||
kwargs['suptitle'] = 'Details' | ||||
|
r172 | |||
|
r13 | return render(request, 'device.html', kwargs) | ||
|
r89 | |||
|
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 | |||
|
r19 | def device_edit(request, id_dev): | ||
|
r172 | |||
|
r20 | device = get_object_or_404(Device, pk=id_dev) | ||
|
r172 | |||
|
r13 | if request.method=='GET': | ||
form = DeviceForm(instance=device) | ||||
|
r172 | |||
|
r6 | 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 | |||
|
r19 | def device_delete(request, id_dev): | ||
|
r172 | |||
|
r20 | device = get_object_or_404(Device, pk=id_dev) | ||
|
r172 | |||
|
r18 | 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 = { | ||
'title': 'Delete', | ||||
'suptitle': 'Device', | ||||
|
r172 | 'object': device, | ||
|
r89 | 'previous': device.get_absolute_url(), | ||
'delete': True | ||||
} | ||||
|
r172 | |||
|
r89 | return render(request, 'confirm.html', kwargs) | ||
|
r172 | |||
|
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 | |||
|
r138 | form = FilterForm(initial=request.GET, extra_fields=['range_date', 'tags','template']) | ||
|
r172 | kwargs['keys'] = ['name', 'start_date', 'end_date'] | ||
|
r13 | kwargs['title'] = 'Campaign' | ||
kwargs['suptitle'] = 'List' | ||||
|
r172 | kwargs['form'] = form | ||
|
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 | ||||
|
r89 | kwargs['campaign_keys'] = ['template', 'name', 'start_date', 'end_date', 'tags', 'description'] | ||
|
r172 | |||
|
r89 | kwargs['experiments'] = experiments | ||
|
r138 | 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 | |||
|
r19 | def campaign_new(request): | ||
|
r172 | |||
|
r85 | kwargs = {} | ||
|
r172 | |||
|
r13 | if request.method == 'GET': | ||
|
r172 | |||
|
r85 | if 'template' in request.GET: | ||
if request.GET['template']=='0': | ||||
form = NewForm(initial={'create_from':2}, | ||||
template_choices=Campaign.objects.filter(template=True).values_list('id', 'name')) | ||||
else: | ||||
kwargs['button'] = 'Create' | ||||
|
r172 | 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, | ||||
initial={'name':'{} [{:%Y/%m/%d}]'.format(camp.name, datetime.now()), | ||||
|
r172 | '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(): | ||
campaign = form.save() | ||||
|
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 | |||
|
r19 | def campaign_edit(request, id_camp): | ||
|
r172 | |||
|
r20 | campaign = get_object_or_404(Campaign, pk=id_camp) | ||
|
r172 | |||
|
r13 | if request.method=='GET': | ||
form = CampaignForm(instance=campaign) | ||||
|
r172 | |||
|
r6 | 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 | |||
|
r19 | def campaign_delete(request, id_camp): | ||
|
r172 | |||
|
r20 | campaign = get_object_or_404(Campaign, pk=id_camp) | ||
|
r172 | |||
|
r18 | if request.method=='POST': | ||
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 = { | ||
'title': 'Delete', | ||||
'suptitle': 'Campaign', | ||||
|
r172 | 'object': campaign, | ||
|
r89 | 'previous': campaign.get_absolute_url(), | ||
'delete': True | ||||
} | ||||
|
r172 | |||
|
r89 | return render(request, 'confirm.html', kwargs) | ||
|
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' | ||
filename = '%s_%s.json' %(campaign.name, campaign.id) | ||||
|
r172 | |||
|
r100 | response = HttpResponse(content_type=content_type) | ||
response['Content-Disposition'] = 'attachment; filename="%s"' %filename | ||||
response.write(content) | ||||
|
r172 | |||
|
r100 | return response | ||
|
r18 | |||
|
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(): | ||
|
r172 | |||
|
r108 | parms = campaign.import_from_file(request.FILES['file']) | ||
|
r172 | |||
|
r108 | if parms: | ||
|
r109 | parms['name'] = parms['campaign'] | ||
|
r172 | |||
|
r110 | new_camp = campaign.dict_to_parms(parms, CONF_MODELS) | ||
|
r172 | |||
|
r108 | messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name) | ||
|
r172 | |||
|
r110 | 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() | ||||
kwargs = get_paginator(Experiment, page, order, filters) | ||||
|
r172 | |||
form = FilterForm(initial=request.GET, extra_fields=['tags','template']) | ||||
kwargs['keys'] = ['name', 'radar_system', 'start_time', 'end_time'] | ||||
|
r13 | kwargs['title'] = 'Experiment' | ||
kwargs['suptitle'] = 'List' | ||||
|
r138 | kwargs['form'] = form | ||
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) | ||
|
r172 | |||
|
r41 | configurations = Configuration.objects.filter(experiment=experiment, type=0) | ||
|
r172 | |||
|
r13 | kwargs = {} | ||
|
r172 | |||
|
r138 | kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time'] | ||
|
r13 | kwargs['experiment'] = experiment | ||
|
r172 | |||
|
r121 | 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 | |||
|
r79 | def experiment_new(request, id_camp=None): | ||
|
r172 | |||
|
r85 | kwargs = {} | ||
|
r172 | |||
|
r13 | if request.method == 'GET': | ||
|
r85 | if 'template' in request.GET: | ||
if request.GET['template']=='0': | ||||
form = NewForm(initial={'create_from':2}, | ||||
template_choices=Experiment.objects.filter(template=True).values_list('id', 'name')) | ||||
else: | ||||
kwargs['button'] = 'Create' | ||||
|
r172 | kwargs['configurations'] = Configuration.objects.filter(experiment=request.GET['template']) | ||
|
r85 | kwargs['configuration_keys'] = ['name', 'device__name', 'device__ip_address', 'device__port_address'] | ||
|
r91 | exp=Experiment.objects.get(pk=request.GET['template']) | ||
|
r172 | form = ExperimentForm(instance=exp, | ||
|
r91 | 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(): | ||
experiment = form.save() | ||||
|
r85 | |||
if 'template' in request.GET: | ||||
|
r172 | 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 | |||
|
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 | |||
|
r6 | 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 | |||
|
r19 | def experiment_delete(request, id_exp): | ||
|
r172 | |||
|
r20 | experiment = get_object_or_404(Experiment, pk=id_exp) | ||
|
r172 | |||
|
r18 | if request.method=='POST': | ||
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 = { | ||
'title': 'Delete', | ||||
'suptitle': 'Experiment', | ||||
|
r172 | 'object': experiment, | ||
|
r91 | 'previous': experiment.get_absolute_url(), | ||
'delete': True | ||||
} | ||||
|
r172 | |||
|
r91 | return render(request, 'confirm.html', kwargs) | ||
|
r18 | |||
|
r89 | |||
|
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' | ||
filename = '%s_%s.json' %(experiment.name, experiment.id) | ||||
|
r172 | |||
|
r100 | response = HttpResponse(content_type=content_type) | ||
response['Content-Disposition'] = 'attachment; filename="%s"' %filename | ||||
response.write(content) | ||||
|
r172 | |||
|
r100 | return response | ||
|
r108 | def experiment_import(request, id_exp): | ||
|
r172 | |||
|
r108 | experiment = get_object_or_404(Experiment, pk=id_exp) | ||
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) | ||||
|
r172 | |||
|
r108 | if file_form.is_valid(): | ||
|
r172 | |||
|
r108 | parms = experiment.import_from_file(request.FILES['file']) | ||
|
r172 | |||
|
r108 | if parms: | ||
|
r172 | |||
|
r110 | new_exp = experiment.dict_to_parms(parms, CONF_MODELS) | ||
|
r172 | |||
|
r108 | messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name) | ||
|
r172 | |||
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 | |||
|
r106 | def experiment_mix(request, id_exp): | ||
|
r172 | |||
|
r106 | experiment = get_object_or_404(Experiment, pk=id_exp) | ||
rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp, | ||||
mix=False)] | ||||
|
r172 | |||
|
r106 | if len(rc_confs)<2: | ||
messages.warning(request, 'You need at least two RC Configurations to make a mix') | ||||
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() | ||||
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) | ||||
line.save() | ||||
|
r172 | |||
|
r106 | initial = {'name': mix.name, | ||
'result': parse_mix_result(mix.parameters), | ||||
'delay': 0, | ||||
'mask': [0,1,2,3,4,5,6,7] | ||||
} | ||||
|
r172 | |||
if request.method=='GET': | ||||
|
r106 | form = RCMixConfigurationForm(confs=rc_confs, initial=initial) | ||
|
r172 | |||
|
r112 | 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, | ||
request.POST['experiment'], | ||||
mode, | ||||
operation, | ||||
float(request.POST['delay']), | ||||
parse_mask(request.POST.getlist('mask')) | ||||
) | ||||
|
r106 | else: | ||
|
r112 | result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'], | ||
mode, | ||||
operation, | ||||
float(request.POST['delay']), | ||||
parse_mask(request.POST.getlist('mask')) | ||||
) | ||||
|
r172 | |||
|
r106 | mix.parameters = result | ||
mix.name = request.POST['name'] | ||||
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 = { | ||
'title': 'Experiment', | ||||
'suptitle': 'Mix Configurations', | ||||
'form' : form, | ||||
'extra_button': 'Delete', | ||||
'button': 'Add', | ||||
'cancel': 'Back', | ||||
'previous': experiment.get_absolute_url(), | ||||
'id_exp':id_exp, | ||||
} | ||||
|
r172 | |||
|
r106 | return render(request, 'experiment_mix.html', kwargs) | ||
def experiment_mix_delete(request, id_exp): | ||||
|
r172 | |||
|
r106 | conf = RCConfiguration.objects.get(experiment=id_exp, mix=True) | ||
values = conf.parameters.split('-') | ||||
conf.parameters = '-'.join(values[:-1]) | ||||
conf.save() | ||||
|
r172 | |||
|
r106 | return redirect('url_mix_experiment', id_exp=id_exp) | ||
|
r151 | def experiment_summary(request, id_exp): | ||
|
r172 | |||
|
r151 | import json | ||
|
r157 | import ast | ||
|
r172 | |||
|
r151 | experiment = get_object_or_404(Experiment, pk=id_exp) | ||
experiment_data = json.loads(experiment.parms_to_dict()) | ||||
configurations = Configuration.objects.filter(experiment=experiment, type=0) | ||||
|
r172 | |||
|
r151 | kwargs = {} | ||
|
r172 | |||
|
r151 | kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time'] | ||
kwargs['experiment'] = experiment | ||||
|
r172 | |||
|
r151 | kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status'] | ||
kwargs['configurations'] = configurations | ||||
kwargs['experiment_data'] = experiment_data | ||||
|
r172 | |||
|
r151 | kwargs['title'] = 'Experiment Summary' | ||
kwargs['suptitle'] = 'Details' | ||||
|
r172 | |||
|
r151 | kwargs['button'] = 'Verify Parameters' | ||
|
r172 | |||
|
r157 | jars_conf = False | ||
rc_conf = False | ||||
|
r172 | |||
|
r151 | for configuration in configurations: | ||
|
r157 | #-------------------- JARS -----------------------: | ||
|
r151 | if configuration.device.device_type.name == 'jars': | ||
|
r157 | jars_conf = True | ||
kwargs['jars_conf'] = jars_conf | ||||
kwargs['exp_type'] = EXPERIMENT_TYPE[configuration.exp_type][1] | ||||
channels_number = configuration.channels_number | ||||
exp_type = configuration.exp_type | ||||
fftpoints = configuration.fftpoints | ||||
filter_parms = configuration.filter_parms | ||||
filter_parms = ast.literal_eval(filter_parms) | ||||
spectral_number = configuration.spectral_number | ||||
|
r172 | |||
|
r157 | #--------------------- RC ----------------------: | ||
|
r151 | if configuration.device.device_type.name == 'rc': | ||
|
r157 | rc_conf = True | ||
kwargs['rc_conf'] = rc_conf | ||||
|
r151 | rc_lines = experiment_data['configurations']['rc']['lines'] | ||
|
r157 | ipp = configuration.ipp | ||
|
r154 | if experiment_data['configurations']['rc']['mix'] == 'True': | ||
|
r152 | tx = '' | ||
code = '' | ||||
window = '' | ||||
|
r151 | else: | ||
|
r152 | code = rc_lines[3]['code'] | ||
|
r172 | |||
|
r152 | window_data = rc_lines[6]['params'][0] | ||
h0 = str(window_data['first_height']) | ||||
dh = str(window_data['resolution']) | ||||
nsa = str(window_data['number_of_samples']) | ||||
window = 'Ho='+h0+'km\nDH='+dh+'km\nNSA='+nsa | ||||
|
r172 | |||
|
r152 | tx = '' | ||
if float(rc_lines[1]['delays']) == 0: | ||||
tx = rc_lines[2]['pulse_width'] | ||||
elif float(rc_lines[2]['delays']) == 0: | ||||
tx = rc_lines[1]['pulse_width'] | ||||
else: | ||||
tx = rc_lines[1]['pulse_width']+' | '+rc_lines[2]['pulse_width'] | ||||
|
r172 | |||
|
r151 | kwargs['tx'] = tx | ||
kwargs['code'] = code | ||||
kwargs['window'] = window | ||||
|
r172 | |||
|
r157 | #-------------------- DDS -----------------------: | ||
if configuration.device.device_type.name == 'dds': | ||||
dds_conf = True | ||||
kwargs['dds_conf'] = dds_conf | ||||
|
r172 | |||
|
r157 | #------ RC & JARS ------: | ||
ipp = 937.5 # | ||||
nsa = 200# | ||||
dh = 1.5 # | ||||
channels_number = 5 # | ||||
|
r172 | |||
|
r157 | if rc_conf and jars_conf: | ||
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 | ||||
|
r172 | |||
|
r157 | ipps = (ipp*pow(10,-6))/0.15 | ||
GB = 1048576.0*1024.0 | ||||
Hour = 3600 | ||||
rate = b/ipps | ||||
rate = rate *(1/GB)*(Hour) | ||||
kwargs['rate'] = str(rate)+" GB/h" | ||||
else: | ||||
kwargs['rate'] = '' | ||||
|
r172 | |||
|
r151 | ###### SIDEBAR ###### | ||
kwargs.update(sidebar(experiment=experiment)) | ||||
|
r172 | |||
|
r151 | return render(request, 'experiment_summary.html', kwargs) | ||
|
r157 | def experiment_verify(request, id_exp): | ||
|
r172 | |||
import json | ||||
|
r157 | import ast | ||
|
r172 | |||
|
r157 | experiment = get_object_or_404(Experiment, pk=id_exp) | ||
experiment_data = json.loads(experiment.parms_to_dict()) | ||||
configurations = Configuration.objects.filter(experiment=experiment, type=0) | ||||
|
r172 | |||
|
r157 | kwargs = {} | ||
|
r172 | |||
|
r157 | kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time'] | ||
kwargs['experiment'] = experiment | ||||
|
r172 | |||
|
r157 | kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status'] | ||
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 | ||
rc_conf = False | ||||
dds_conf = False | ||||
|
r172 | |||
|
r157 | for configuration in configurations: | ||
#-------------------- JARS -----------------------: | ||||
if configuration.device.device_type.name == 'jars': | ||||
jars_conf = True | ||||
kwargs['jars_conf'] = jars_conf | ||||
filter_parms = configuration.filter_parms | ||||
filter_parms = ast.literal_eval(filter_parms) | ||||
kwargs['filter_parms'] = filter_parms | ||||
#--Sampling Frequency | ||||
clock = filter_parms['clock'] | ||||
filter_2 = filter_parms['filter_2'] | ||||
filter_5 = filter_parms['filter_5'] | ||||
filter_fir = filter_parms['filter_fir'] | ||||
samp_freq_jars = clock/filter_2/filter_5/filter_fir | ||||
|
r172 | |||
|
r157 | kwargs['samp_freq_jars'] = samp_freq_jars | ||
kwargs['jars'] = configuration | ||||
|
r172 | |||
|
r157 | #--------------------- RC ----------------------: | ||
if configuration.device.device_type.name == 'rc': | ||||
rc_conf = True | ||||
rc_parms = configuration.parms_to_dict() | ||||
if rc_parms['mix'] == 'True': | ||||
pass | ||||
|
r172 | else: | ||
|
r157 | rc_lines = rc_parms['lines'] | ||
dh = rc_lines[6]['params'][0]['resolution'] | ||||
#--Sampling Frequency | ||||
|
r172 | samp_freq_rc = 0.15/dh | ||
|
r157 | kwargs['samp_freq_rc'] = samp_freq_rc | ||
|
r172 | |||
|
r157 | kwargs['rc_conf'] = rc_conf | ||
kwargs['rc'] = configuration | ||||
|
r172 | |||
|
r157 | #-------------------- DDS ----------------------: | ||
if configuration.device.device_type.name == 'dds': | ||||
dds_conf = True | ||||
dds_parms = configuration.parms_to_dict() | ||||
|
r172 | |||
|
r157 | kwargs['dds_conf'] = dds_conf | ||
kwargs['dds'] = configuration | ||||
|
r172 | |||
|
r157 | #------------Validation------------: | ||
#Clock | ||||
if dds_conf and rc_conf and jars_conf: | ||||
if filter_parms['clock'] != rc_parms['clock_in'] and rc_parms['clock_in'] != dds_parms['clock']: | ||||
messages.warning(request, "Devices don't have the same clock.") | ||||
elif rc_conf and jars_conf: | ||||
if filter_parms['clock'] != rc_parms['clock_in']: | ||||
messages.warning(request, "Devices don't have the same clock.") | ||||
elif rc_conf and dds_conf: | ||||
if rc_parms['clock_in'] != dds_parms['clock']: | ||||
messages.warning(request, "Devices don't have the same clock.") | ||||
if float(samp_freq_rc) != float(dds_parms['frequencyA']): | ||||
messages.warning(request, "Devices don't have the same Frequency A.") | ||||
|
r172 | |||
|
r157 | ###### SIDEBAR ###### | ||
kwargs.update(sidebar(experiment=experiment)) | ||||
|
r172 | |||
|
r157 | 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) | ||
if i==0: | ||||
|
r172 | html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format( | ||
|
r112 | conf.name, | ||
mode, | ||||
|
r116 | ' ', | ||
|
r106 | delay, | ||
mask) | ||||
else: | ||||
|
r112 | html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format( | ||
conf.name, | ||||
|
r106 | mode, | ||
|
r112 | operation, | ||
|
r106 | delay, | ||
mask) | ||||
|
r172 | |||
|
r106 | return mark_safe(html) | ||
def parse_mask(l): | ||||
|
r172 | |||
|
r106 | values = [] | ||
|
r172 | |||
|
r106 | for x in range(8): | ||
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') | ||
order = ('type', 'device__device_type', 'experiment') | ||||
filters = request.GET.copy() | ||||
kwargs = get_paginator(Configuration, page, order, filters) | ||||
|
r172 | |||
|
r138 | form = FilterForm(initial=request.GET, extra_fields=['tags','template']) | ||
|
r172 | kwargs['keys'] = ['name', 'experiment', 'type', 'programmed_date'] | ||
|
r14 | kwargs['title'] = 'Configuration' | ||
|
r13 | kwargs['suptitle'] = 'List' | ||
|
r172 | kwargs['form'] = form | ||
|
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 | |||
def dev_conf_new(request, id_exp=0, id_dev=0): | ||||
|
r172 | |||
|
r79 | initial = {} | ||
|
r106 | kwargs = {} | ||
|
r172 | |||
if id_exp!=0: | ||||
|
r79 | initial['experiment'] = id_exp | ||
|
r172 | |||
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: | ||||
if request.GET['template']=='0': | ||||
|
r121 | choices = [(conf.pk, '{}'.format(conf)) for conf in Configuration.objects.filter(template=True)] | ||
|
r106 | form = NewForm(initial={'create_from':2}, | ||
|
r121 | template_choices=choices) | ||
|
r106 | else: | ||
|
r172 | kwargs['button'] = 'Create' | ||
|
r106 | 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, | ||
|
r106 | initial={'name': '{} [{:%Y/%m/%d}]'.format(conf.name, datetime.now()), | ||
|
r116 | 'template': False, | ||
|
r172 | '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(): | ||
|
r106 | conf = form.save() | ||
|
r172 | |||
|
r106 | if 'template' in request.GET and conf.device.device_type.name=='rc': | ||
|
r116 | lines = RCLine.objects.filter(rc_configuration=request.GET['template']) | ||
|
r106 | for line in lines: | ||
line.clone(rc_configuration=conf) | ||||
|
r172 | |||
if conf.device.device_type.name=='jars': | ||||
|
r137 | conf.add_parms_to_filter() | ||
|
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 | |||
|
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 | |||
|
r13 | if request.method=='GET': | ||
|
r172 | form = DevConfForm(instance=conf) | ||
|
r13 | 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 | |||
|
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 | |||
|
r57 | conf.status_device() | ||
|
r172 | |||
|
r53 | return redirect(conf.get_absolute_url()) | ||
|
r89 | |||
|
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 | |||
|
r57 | 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 | |||
def dev_conf_write(request, id_conf): | ||||
|
r172 | |||
|
r30 | conf = get_object_or_404(Configuration, pk=id_conf) | ||
|
r172 | |||
|
r53 | answer = conf.write_device() | ||
|
r57 | conf.status_device() | ||
|
r172 | |||
|
r53 | if answer: | ||
messages.success(request, conf.message) | ||||
|
r172 | |||
#Creating a historical configuration | ||||
|
r157 | conf.clone(type=1, template=False) | ||
|
r172 | |||
|
r57 | #Original configuration | ||
conf = DevConfModel.objects.get(pk=id_conf) | ||||
|
r53 | else: | ||
messages.error(request, conf.message) | ||||
|
r172 | |||
|
r53 | return redirect(conf.get_absolute_url()) | ||
|
r89 | |||
|
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 | |||
|
r53 | if request.method=='GET': | ||
|
r172 | |||
|
r53 | parms = conf.read_device() | ||
|
r57 | 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 | |||
|
r53 | if request.method=='POST': | ||
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 | |||
|
r57 | return render(request, '%s_conf_edit.html' %conf.device.device_type.name, kwargs) | ||
|
r30 | |||
|
r89 | |||
|
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 | |||
|
r53 | parms = conf.import_from_file(request.FILES['file']) | ||
|
r172 | |||
|
r53 | if parms: | ||
messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name) | ||||
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 | |||
|
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 | |||
|
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': | ||
|
r57 | file_form = DownloadFileForm(conf.device.device_type.name, request.POST) | ||
|
r172 | |||
|
r53 | if file_form.is_valid(): | ||
|
r57 | fields = conf.export_to_file(format = file_form.cleaned_data['format']) | ||
|
r172 | |||
|
r53 | response = HttpResponse(content_type=fields['content_type']) | ||
response['Content-Disposition'] = 'attachment; filename="%s"' %fields['filename'] | ||||
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 | |||
|
r19 | def dev_conf_delete(request, id_conf): | ||
|
r172 | |||
|
r20 | conf = get_object_or_404(Configuration, pk=id_conf) | ||
|
r172 | |||
|
r18 | if request.method=='POST': | ||
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 = { | ||
'title': 'Delete', | ||||
'suptitle': 'Experiment', | ||||
|
r172 | 'object': conf, | ||
|
r91 | 'previous': conf.get_absolute_url(), | ||
'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] | ||||
experiments = campaign[0].experiments.all() | ||||
else: | ||||
experiments = [experiment] | ||||
configurations = experiment.configuration_set.filter(type=0) | ||||
side_data['side_experiments'] = experiments | ||||
side_data['side_configurations'] = configurations | ||||
|
r172 | |||
|
r85 | return side_data | ||
|
r46 | |||
|
r138 | def get_paginator(model, page, order, filters={}, n=10): | ||
|
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 | |||
|
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') | ||
|
r138 | if 'tags' in model._meta.get_all_field_names(): | ||
|
r172 | query = query | Q(tags__icontains=tags) | ||
|
r138 | if 'name' in model._meta.get_all_field_names(): | ||
|
r172 | query = query | Q(name__icontains=tags) | ||
|
r138 | if 'location' in model._meta.get_all_field_names(): | ||
query = query | Q(location__name__icontains=tags) | ||||
if 'device' in model._meta.get_all_field_names(): | ||||
|
r172 | query = query | Q(device__name__icontains=tags) | ||
|
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 | |||
|
r50 | def operation(request, id_camp=None): | ||
|
r172 | |||
kwargs = {} | ||||
campaigns = Campaign.objects.filter(start_date__lte=datetime.now(), | ||||
end_date__gte=datetime.now()).order_by('-start_date') | ||||
|
r50 | |||
|
r53 | |||
|
r172 | if id_camp: | ||
campaign = get_object_or_404(Campaign, pk = id_camp) | ||||
form = OperationForm(initial={'campaign': campaign.id}, campaigns=campaigns) | ||||
kwargs['campaign'] = campaign | ||||
else: | ||||
form = OperationForm(campaigns=campaigns) | ||||
kwargs['form'] = form | ||||
return render(request, 'operation.html', kwargs) | ||||
|
r53 | |||
|
r172 | |||
|
r69 | #---Experiment | ||
|
r81 | keys = ['id', 'name', 'start_time', 'end_time', 'status'] | ||
|
r50 | kwargs['experiment_keys'] = keys[1:] | ||
kwargs['experiments'] = experiments | ||||
#---Radar | ||||
|
r172 | kwargs['locations'] = campaign.get_experiments_by_location() | ||
print kwargs['locations'] | ||||
|
r50 | #---Else | ||
|
r53 | kwargs['title'] = 'Campaign' | ||
|
r50 | kwargs['suptitle'] = campaign.name | ||
|
r172 | kwargs['form'] = form | ||
|
r69 | return render(request, 'operation.html', kwargs) | ||
|
r89 | |||
|
r84 | def operation_search(request, id_camp=None): | ||
|
r172 | |||
|
r69 | if not id_camp: | ||
campaigns = Campaign.objects.all().order_by('-start_date') | ||||
|
r172 | |||
|
r69 | if not campaigns: | ||
return render(request, 'operation.html', {}) | ||||
|
r172 | |||
|
r69 | id_camp = campaigns[0].id | ||
|
r84 | campaign = get_object_or_404(Campaign, pk = id_camp) | ||
|
r172 | |||
|
r84 | if request.method=='GET': | ||
|
r69 | form = OperationSearchForm(initial={'campaign': campaign.id}) | ||
|
r172 | |||
|
r69 | if request.method=='POST': | ||
form = OperationSearchForm(request.POST, initial={'campaign':campaign.id}) | ||||
|
r172 | |||
|
r69 | if form.is_valid(): | ||
|
r84 | return redirect('url_operation', id_camp=campaign.id) | ||
|
r172 | |||
|
r84 | #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct() | ||
experiments = Experiment.objects.filter(campaign__pk=campaign.id) | ||||
|
r88 | #for exs in experiments: | ||
# exs.get_status() | ||||
|
r84 | locations= Location.objects.filter(experiment=experiments).distinct() | ||
form = OperationSearchForm(initial={'campaign': campaign.id}) | ||||
|
r172 | |||
|
r84 | kwargs = {} | ||
#---Campaign | ||||
kwargs['campaign'] = campaign | ||||
kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description'] | ||||
#---Experiment | ||||
keys = ['id', 'name', 'start_time', 'end_time', 'status'] | ||||
kwargs['experiment_keys'] = keys[1:] | ||||
kwargs['experiments'] = experiments | ||||
#---Radar | ||||
kwargs['locations'] = locations | ||||
#---Else | ||||
kwargs['title'] = 'Campaign' | ||||
kwargs['suptitle'] = campaign.name | ||||
kwargs['form'] = form | ||||
kwargs['button'] = 'Select' | ||||
kwargs['details'] = True | ||||
kwargs['search_button'] = False | ||||
|
r172 | |||
|
r84 | return render(request, 'operation.html', kwargs) | ||
def radar_play(request, id_camp, id_radar): | ||||
|
r88 | campaign = get_object_or_404(Campaign, pk = id_camp) | ||
radar = get_object_or_404(Location, pk = id_radar) | ||||
|
r90 | today = datetime.today() | ||
now = today.time() | ||||
|
r172 | |||
|
r93 | #--Clear Old Experiments From RunningExperiment Object | ||
|
r95 | running_experiment = RunningExperiment.objects.filter(radar=radar) | ||
|
r93 | if running_experiment: | ||
|
r95 | running_experiment = running_experiment[0] | ||
|
r93 | running_experiment.running_experiment.clear() | ||
running_experiment.save() | ||||
|
r172 | |||
|
r90 | #--If campaign datetime is ok: | ||
if today >= campaign.start_date and today <= campaign.end_date: | ||||
experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar) | ||||
for exp in experiments: | ||||
#--If experiment time is ok: | ||||
if now >= exp.start_time and now <= exp.end_time: | ||||
configurations = Configuration.objects.filter(experiment = exp) | ||||
for conf in configurations: | ||||
if 'cgs' in conf.device.device_type.name: | ||||
conf.status_device() | ||||
else: | ||||
answer = conf.start_device() | ||||
conf.status_device() | ||||
#--Running Experiment | ||||
|
r95 | old_running_experiment = RunningExperiment.objects.filter(radar=radar) | ||
|
r90 | #--If RunningExperiment element exists | ||
|
r93 | if old_running_experiment: | ||
|
r95 | old_running_experiment = old_running_experiment[0] | ||
|
r93 | old_running_experiment.running_experiment.add(exp) | ||
old_running_experiment.status = 3 | ||||
old_running_experiment.save() | ||||
#--Create a new Running_Experiment Object | ||||
|
r90 | else: | ||
|
r93 | new_running_experiment = RunningExperiment( | ||
|
r90 | radar = radar, | ||
status = 3, | ||||
) | ||||
|
r93 | new_running_experiment.save() | ||
new_running_experiment.running_experiment.add(exp) | ||||
new_running_experiment.save() | ||||
|
r172 | |||
|
r90 | if answer: | ||
messages.success(request, conf.message) | ||||
exp.status=2 | ||||
exp.save() | ||||
else: | ||||
messages.error(request, conf.message) | ||||
else: | ||||
if exp.status == 1 or exp.status == 3: | ||||
exp.status=3 | ||||
exp.save() | ||||
|
r172 | |||
|
r84 | route = request.META['HTTP_REFERER'] | ||
route = str(route) | ||||
if 'search' in route: | ||||
return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp])) | ||||
else: | ||||
return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | ||||
|
r88 | |||
|
r84 | def radar_stop(request, id_camp, id_radar): | ||
|
r93 | campaign = get_object_or_404(Campaign, pk = id_camp) | ||
radar = get_object_or_404(Location, pk = id_radar) | ||||
|
r94 | experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar) | ||
|
r172 | |||
|
r94 | for exp in experiments: | ||
configurations = Configuration.objects.filter(experiment = exp) | ||||
for conf in configurations: | ||||
if 'cgs' in conf.device.device_type.name: | ||||
conf.status_device() | ||||
else: | ||||
answer = conf.stop_device() | ||||
conf.status_device() | ||||
|
r172 | |||
|
r94 | if answer: | ||
messages.success(request, conf.message) | ||||
exp.status=1 | ||||
exp.save() | ||||
else: | ||||
messages.error(request, conf.message) | ||||
|
r172 | |||
|
r85 | |||
|
r84 | route = request.META['HTTP_REFERER'] | ||
route = str(route) | ||||
if 'search' in route: | ||||
return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp])) | ||||
else: | ||||
|
r85 | return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | ||
|
r172 | |||
|
r88 | |||
def radar_refresh(request, id_camp, id_radar): | ||||
|
r172 | |||
|
r88 | campaign = get_object_or_404(Campaign, pk = id_camp) | ||
radar = get_object_or_404(Location, pk = id_radar) | ||||
experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar) | ||||
for exs in experiments: | ||||
exs.get_status() | ||||
route = request.META['HTTP_REFERER'] | ||||
route = str(route) | ||||
if 'search' in route: | ||||
return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp])) | ||||
else: | ||||
return HttpResponseRedirect(reverse('url_operation', args=[id_camp])) | ||||
|
r172 | |||