radarsys Commit - r42:21a9f0375b43 · Jicamarca Repository

Task #95: se agrego la funcion "import" para archivos .json ...

Fiorella Quino -

r42:21a9f0375b43

parent child

Context file:

r42:21a9f0375b43

Collapse all files

apps/cgs/files.py created 644 +31 0

@@ -0,0 +1,31
	1	'''
	2	Created on Feb 15, 2016
	3
	4	@author: Miguel Urco
	5	'''
	6
	7	import json
	8
	9	def read_json_file(fp):
	10
	11	kwargs = {}
	12
	13	json_data = fp
	14	data = json.load(json_data)
	15	json_data.close()
	16
	17	frequency0 = data["Frequencies"][0][1]
	18	frequency1 = data["Frequencies"][1][1]
	19	frequency2 = data["Frequencies"][2][1]
	20	frequency3 = data["Frequencies"][3][1]
	21
	22	kwargs['freq0'] = frequency0
	23	kwargs['freq1'] = frequency1
	24	kwargs['freq2'] = frequency2
	25	kwargs['freq3'] = frequency3
	26
	27	return kwargs
	28
	29
	30	def write_json_file(filename):
	31	pass No newline at end of file

apps/cgs/forms.py +6 -6

             from django import forms
             from apps.main.models import Device
             from .models import CGSConfiguration
             class CGSConfigurationForm(forms.ModelForm):
                 #freq0.widget = te
                 def __init__(self, *args, **kwargs):
                     #request = kwargs.pop('request')
                     super(CGSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='cgs')
                         items = devices.values('id', 'name', 'device_type__name', 'ip_address')
                         self.fields['experiment'].widget.attrs['readonly'] = True
                         self.fields['device'].widget.choices = [(item['id'], '[%s]: %s | %s' % (item['device_type__name'], item['name'], item['ip_address'])) for item in items]
                 def clean(self):
                     return
-            #         # Custom validation to force an integer when type of unit = "Unit"
-            #         form_data = self.cleaned_data
-            #         if (form_data['freq0'] or form_data['freq1'] or form_data['freq2'] or form_data['freq3'] < 0):
-            #             raise forms.ValidationError("Please introduce positive Number")
-            #         return form_data
                 class Meta:
                     model = CGSConfiguration
                     #exclude = ('freqs', 'clk_in', 'mult','div',)
             #         exclude = ('freqs',)
                     fields = ('experiment', 'device', 'freq0', 'freq1', 'freq2', 'freq3')
+            class UploadFileForm(forms.Form):
+                title = forms.CharField(label='Extension Type', widget=forms.TextInput(attrs={'readonly':'readonly'}))
+                file = forms.FileField()
  No newline at end of file

apps/cgs/models.py +18 -6

             from django.db import models
             from apps.main.models import Configuration
             #from json_field import JSONField
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Device, Experiment
+            from files import read_json_file
             # Create your models here.
             class CGSConfiguration(Configuration):
-                #device = models.ForeignKey(Device)
-                #exp    = models.ForeignKey(Experiment, default = None)
                 freq0 = models.FloatField(verbose_name='Frequency 0',validators=[MinValueValidator(62.5e6), MaxValueValidator(450e6)], blank=True, null=True)
                 freq1 = models.FloatField(verbose_name='Frequency 1',validators=[MinValueValidator(62.5e6), MaxValueValidator(450e6)], blank=True, null=True)
                 freq2 = models.FloatField(verbose_name='Frequency 2',validators=[MinValueValidator(62.5e6), MaxValueValidator(450e6)], blank=True, null=True)
                 freq3 = models.FloatField(verbose_name='Frequency 3',validators=[MinValueValidator(62.5e6), MaxValueValidator(450e6)], blank=True, null=True)
                 #jfreqs = JSONField(default={"frequencies":[{"f0":freq0,"f1":freq1,"f2":freq2,"f3":freq3}]}, blank=True)
-                #clk_in = models.PositiveIntegerField(default=10e6)
-                #mult = models.PositiveIntegerField(default=40)
-                #div = models.PositiveIntegerField(default=1)
                 def verify_frequencies(self):
                     return True
+                def update_from_file(self, fp):
+                    kwargs = read_json_file(fp)
+                    if not kwargs:
+                        return False
+                    self.freq0 = kwargs['freq0']
+                    self.freq1 = kwargs['freq1']
+                    self.freq2 = kwargs['freq2']
+                    self.freq3 = kwargs['freq3']
+                    return True
                 class Meta:
                     db_table = 'cgs_configurations'

apps/cgs/urls.py +1 -3

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^(?P<id_conf>-?\d+)/$', 'apps.cgs.views.cgs_conf', name='url_cgs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', 'apps.cgs.views.cgs_conf_edit', name='url_edit_cgs_conf'),
                 #url(r'^(?P<id_conf>-?\d+)/(?P<message>-?\d+)/$', 'apps.cgs.views.cgs_conf', name='url_cgs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', 'apps.cgs.views.cgs_conf_edit', name='url_edit_cgs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.cgs.views.cgs_conf_write', name='url_write_cgs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.cgs.views.cgs_conf_read', name='url_read_cgs_conf'),
-                #url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.main.views.dev_conf_write', name='url_write_cgs_conf'),
+                url(r'^(?P<id_conf>-?\d+)/import/$', 'apps.cgs.views.cgs_conf_import', name='url_import_cgs_conf'),
-                #url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.main.views.dev_conf_read', name='url_read_cgs_conf'),
-                url(r'^(?P<id_conf>-?\d+)/import/$', 'apps.main.views.dev_conf_import', name='url_import_cgs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/export/$', 'apps.cgs.views.cgs_conf_export', name='url_export_cgs_conf'),
                 #url(r'^(?P<id_conf>-?\d+)/export/$', 'apps.main.views.dev_conf_export', name='url_export_cgs_conf'),
             )

apps/cgs/views.py +53 -1

             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from apps.main.models import Experiment, Configuration
             from .models import CGSConfiguration
-            from .forms import CGSConfigurationForm
+            from .forms import CGSConfigurationForm, UploadFileForm
             from apps.main.views import sidebar
             import requests
             import json
             #from __builtin__ import None
             # Create your views here.
             def cgs_conf(request, id_conf):
                 conf = get_object_or_404(CGSConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 kwargs = {}
                 if request.method=='GET':
                     #r: response = icon, status
                     try:
                         route = "http://" + str(ip) + ":" + str(port) + "/status/ad9548"
                         r = requests.get(route)
                         response = str(r.text)
                         response = response.split(";")
                         icon = response[0]
                         status = response[-1]
                         #print r.text
                         #"icon" could be: "alert" or "okay"
                         # Si hay alerta pero esta conectado
                         if "alert" in icon:
                             if "Starting Up" in status: #No Esta conectado
                                 kwargs['connected'] = False
                             else:
                                 kwargs['connected'] = True
                         elif "okay" in icon:
                             kwargs['connected'] = True
                         else:
                             kwargs['connected'] = False
                     except:
                         kwargs['connected'] = False
                         status = "The Device is not connected."
                 if not kwargs['connected']:
                     messages.error(request, message=status)
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['experiment', 'device',
                                            'freq0', 'freq1',
                                            'freq2', 'freq3']
                 kwargs['title'] = 'CGS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'cgs_conf.html', kwargs)
             def cgs_conf_edit(request, id_conf):
                 conf = get_object_or_404(CGSConfiguration, pk=id_conf)
                 if request.method=='GET':
                     form = CGSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = CGSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         if conf.verify_frequencies():
                             if conf.freq0 == None:  conf.freq0 = 0
                             if conf.freq1 == None:  conf.freq0 = 0
                             if conf.freq2 == None:  conf.freq0 = 0
                             if conf.freq3 == None:  conf.freq0 = 0
                             data = {'f0': str(conf.freq0), 'f1': str(conf.freq1),
                                     'f2': str(conf.freq2), 'f3': str(conf.freq3)}
                             json_data = json.dumps(data)
                             conf.parameters = json_data
                             conf.save()
                             return redirect('url_cgs_conf', id_conf=conf.id)
                         ##ERRORS
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'cgs_conf_edit.html', kwargs)
             def cgs_conf_write(request, id_conf):
                 conf = get_object_or_404(CGSConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 #Frequencies from form
                 if conf.freq0 == None:  conf.freq0 = 0
                 if conf.freq1 == None:  conf.freq0 = 0
                 if conf.freq2 == None:  conf.freq0 = 0
                 if conf.freq3 == None:  conf.freq0 = 0
                 f0 = int(conf.freq0)
                 f1 = int(conf.freq1)
                 f2 = int(conf.freq2)
                 f3 = int(conf.freq3)
                 try:
                     post_data = {"f0":f0, "f1":f1, "f2":f2, "f3":f3}
                     route = "http://" + str(ip) + ":" + str(port) + "/frequencies/"
                     r = requests.post(route, post_data)
                     text = r.text
                     text = text.split(',')
                     try:
                         if len(text)>1:
                             title = text[0]
                             status = text[1]
                             status_ok = r.status_code
                             if title == "okay":
                                 messages.success(request, status)
                             else:
                                 messages.error(request, status)
                         else:
                             title = text[0]
                             messages.error(request, title)
                     except:
                         messages.error(request, "An hardware error was found.")
                 except:
                     messages.error(request, "Could not write parameters.")
                 return redirect('url_cgs_conf', id_conf=conf.id)
             def cgs_conf_read(request, id_conf):
                 conf = get_object_or_404(CGSConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 if request.method=='POST':
                     form = CGSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         cgs_model = form.save(commit=False)
                         if cgs_model.verify_frequencies():
                             cgs_model.save()
                             return redirect('url_cgs_conf', id_conf=conf.id)
                     messages.error(request, "Parameters could not be saved. Invalid parameters")
                     data = {}
                 if request.method=='GET':
                     #r: response = icon, status
                     route = "http://" + str(ip) + ":" + str(port) + "/status/ad9548"
                     try:
                         r = requests.get(route)
                         response = str(r.text)
                         response = response.split(";")
                         icon = response[0]
                         status = response[-1]
                         print r.text
                         #"icon" could be: "alert" or "okay"
                         if  "okay" in icon:
                             messages.success(request, status)
                         else:
                             messages.error(request, status)
                         #Get Frequencies
                         route = "http://" + str(ip) + ":" + str(port) + "/frequencies/"
                         #frequencies = requests.get('http://10.10.10.175:8080/frequencies/')
                         frequencies = requests.get(route)
                         frequencies = frequencies.json()
                         frequencies = frequencies.get("Frecuencias")
                         f0 = frequencies.get("f0")
                         f1 = frequencies.get("f1")
                         f2 = frequencies.get("f2")
                         f3 = frequencies.get("f3")
                         print f0,f1,f2,f3
                         if not response:
                             messages.error(request, "Could not read parameters from Device")
                             return redirect('url_cgs_conf', id_conf=conf.id)
                         data = {'experiment' : conf.experiment.id,
                                 'device' : conf.device.id,
                                 'freq0' : f0,
                                 'freq1' : f1,
                                 'freq2' : f2,
                                 'freq3' : f3,
                                 }
                     except:
                         messages.error(request, "Could not read parameters from Device")
                         data = {'experiment' : conf.experiment.id,
                                 'device' : conf.device.id,
                                 'freq0' : None,
                                 'freq1' : None,
                                 'freq2' : None,
                                 'freq3' : None,
                                 }
                         return redirect('url_cgs_conf', id_conf=conf.id)
                     form = CGSConfigurationForm(initial = data)
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'cgs_conf_edit.html', kwargs)
+            def cgs_conf_import(request, id_conf):
+                conf = get_object_or_404(CGSConfiguration, pk=id_conf)
+                if request.method == 'POST':
+                    file_form = UploadFileForm(request.POST, request.FILES)
+                    if file_form.is_valid():
+                        try:
+                            if conf.update_from_file(request.FILES['file']):
+                                try:
+                                    conf.full_clean()
+                                except ValidationError as e:
+                                    messages.error(request, e)
+                                else:
+                                    conf.save()
+                                    messages.success(request, "Parameters imported from file: '%s'." %request.FILES['file'].name)
+                                    #messages.warning(request,"")
+                                    return redirect('url_cgs_conf', id_conf=conf.id)
+                        except:
+                            messages.error(request, "No JSON object could be decoded.")
+                    messages.error(request, "Could not import parameters from file")
+                else:
+                    file_form = UploadFileForm(initial={'title': '.json'})
+                kwargs = {}
+                kwargs['id_dev'] = conf.id
+                kwargs['title'] = 'Device Configuration'
+                kwargs['form'] = file_form
+                kwargs['suptitle'] = 'Importing file'
+                kwargs['button'] = 'Import'
+                kwargs.update(sidebar(conf))
+                return render(request, 'cgs_conf_import.html', kwargs)
+            def handle_uploaded_file(f):
+                data = {'freq0' : 62500000,
+                        'freq1' : 62500000,
+                        'freq2' : 62500000,
+                        'freq3' : 62500000,
+                        }
+                return data
             def cgs_conf_export(request, id_conf):
                 conf = get_object_or_404(CGSConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 if request.method=='POST':
                     return HttpResponse(conf.parameters, content_type="application/json")
                 return render(request, 'cgs_conf.html')
                 #return redirect(conf.get_absolute_url())

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

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

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