realtime_web Commit - r74:0baa2a7cadef

Fix bugs, change footer

jespinoza -

r74:0baa2a7cadef

parent child

Context file:

r74:0baa2a7cadef

volumes/app/plotter/consumers.py 0 -1

             #!/usr/bin/python
             # -*- coding: UTF-8 -*-
             import os
             import json
             import simplejson
             from datetime import datetime, timedelta
             import numpy
             from pymongo import MongoClient
             # import mongoengine
             from asgiref.sync import async_to_sync
             from channels.generic.websocket import WebsocketConsumer
             # from plotter.models import Experiment, ExpDetail, PlotMeta, PlotData
             # Here we create the db named "dbplots"
             host = os.environ.get('HOST_MONGO', 'localhost')
             # mongoengine.connect('dbplots', host=host, port=27017)
             CLIENT = MongoClient('{}:27017'.format(host))
             DB = CLIENT['dbplots']
             class MainConsumer(WebsocketConsumer):
                 def connect(self):
                     self.group_name = 'main'
                     async_to_sync(self.channel_layer.group_add)(
                         self.group_name,
                         self.channel_name
                     )
                     self.accept()
                 def disconnect(self, close_code):
                     async_to_sync(self.channel_layer.group_discard)(
                         self.group_name,
                         self.channel_name
                     )
                 def receive(self, text_data):
                     pass
                 def zmq_message(self, event):
                     # Send message to WebSocket
                     self.send(text_data=event['message'])
             class PlotConsumer(WebsocketConsumer):
                 def connect(self):
                     if 'realtime' in self.scope['path']:
                         self.realtime = True
                         self.group_name = '{}_{}'.format(
                             self.scope['url_route']['kwargs']['code'],
                             self.scope['url_route']['kwargs']['plot'],
                         )
                         async_to_sync(self.channel_layer.group_add)(
                             self.group_name,
                             self.channel_name
                         )
                     else:
                         self.realtime = False
                     self.accept()
                 def disconnect(self, close_code):
                     if self.realtime:
                         async_to_sync(self.channel_layer.group_discard)(
                             self.group_name,
                             self.channel_name
                         )
                 def receive(self, text_data):
                     ret = {}
                     dt = datetime.strptime(text_data, '%d-%m-%Y')
                     code = self.scope['url_route']['kwargs']['code']
                     plot = self.scope['url_route']['kwargs']['plot']
                     exp = DB.experiment.find_one({'code': int(code)})
                     det0 = DB.exp_detail.find_one({
                         'experiment': exp['_id'],
                         'date': dt-timedelta(days=1)
                         })
                     det1 = DB.exp_detail.find_one({
                         'experiment': exp['_id'],
                         'date': dt
                         })
                     if det1:
                         meta1 = DB.plot_meta.find_one({
                             'exp_detail': det1['_id'],
                             'plot': plot
                             })
                         if meta1:
                             if meta1['metadata']['type'] in ('pcolor', 'image', 'scatter', 'scattermap'):
                                 datas = DB.plot_data.find(
                                     {'plot': meta1['_id']},
                                     ['time', 'data'],
                                     sort=[('time', -1)],
                                     limit=1)[0]
                                 ret['time'] = [datas['time']]
                                 ret['data'] = datas['data']
                                 ret['metadata'] = meta1['metadata']
                             else:
                                 last = det1['last_time']
                                 metas = [meta1['_id']]
                                 if det0:
                                     meta0 = DB.plot_meta.find_one({
                                         'exp_detail': det0['_id'],
                                         'plot': plot
                                         })
                                     if meta0:
                                         metas.append(meta0['_id'])
                                 total = DB.plot_data.count_documents({
                                     'plot': {'$in': metas},
                                     'time': {'$gt': last-12*60*60}
                                 })
                                 skip = 0 if total-720<0 else total-720
                                 datas = DB.plot_data.find({
                                     'plot': {'$in': metas},
                                     'time': {'$gt': last-12*60*60}
                                     }, ['time', 'data'], sort=[('time', 1)], limit=720, skip=skip)
                                 dum = [(d['time'], d['data']) for d in datas]
                                 ret['time'] = [d[0] for d in dum]
                                 dum = numpy.array([d[1] for d in dum])
                                 #if len(dum[0][0])==1:
                                 #    ret['data'] = dum.T[0].tolist()
                                 #else:
                                 ret['data'] = [t for t in map(list, list(zip(*dum.tolist())))]
-                                print(ret['data'])
                                 ret['metadata'] = meta1['metadata']
                         self.send(simplejson.dumps(ret, ignore_nan=True))
                     else:
                         self.send(json.dumps({'interval': 0}))
                 def zmq_message(self, event):
                     # Send message to WebSocket
                     self.send(text_data=event['message'])

volumes/app/plotter/templates/footer_igp.html +3 -3

             {% load static %} {% load bootstrap4 %}
             <footer>
                 <div class="container">
                   <div class="row">
                     <div class="col-12 col-lg-6">
                         <div class="footer-tittle">RADIO OBSERVATORIO DE JICAMARCA</div>
                     <ul class="footer-contact">
                         <li>Lunes a Jueves de 7:50 a 17:50</li>
                         <li>Lurigancho-Chosica S/N, Lima 15464 – Perú</li>
                         <li>roj@igp.gob.pe</li>
                         <li>+51 1317-2313</li>
                     </ul>
                     </div>
-                    <div class="col-12 col-lg-4">
+                    <div class="col-12 col-lg-6">
                         <div class="footer-tittle">SOCIAL</div>
                         <div class="row">
                             <div class="col-6">
                                 <ul class="footer-social">
                                     <li><a href="https://www.facebook.com/igp.peru" target="_blank"><i class="fab fa-facebook-square fa-lg" aria-hidden="true"></i> Facebook</a></li>
                                     <li><a href="https://twitter.com/igp_peru" target="_blank"><i class="fab fa-twitter-square fa-lg" aria-hidden="true"></i> Twitter</a></li>
                                     <li><a href="https://www.instagram.com/igp.peru" target="_blank"><i class="fab fa-instagram fa-lg" aria-hidden="true"></i> Instagram</a></li>
                                 </ul>
                             </div>
                             <div class="col-6">
                                 <ul class="footer-social">
                                     <li><a href="https://www.youtube.com/igp_videos" target="_blank"><i class="fab fa-youtube-square fa-lg" aria-hidden="true"></i> YouTube</a></li>
                                     <li><a href="https://www.linkedin.com/company/igpperu/" target="_blank"><i class="fab fa-linkedin fa-lg" aria-hidden="true"></i> Linkedin</a></li>
                                 </ul>
                             </div>
                         </div>
                     </div>
-                    <div class="col-12 col-lg-2">
+                    <!-- div class="col-12 col-lg-2">
                     <img src="{% static 'images/siempre-con-el-pueblo-bn-small.png' %}" class="img-fluid">
-                    </div>
+                    </div -->
                   </div>
                 </div>
             </footer>

volumes/app/plotter/views.py +1 -1

             #!/usr/bin/python
             # -*- coding: UTF-8 -*-
             import os
             import time
             from datetime import datetime, timedelta
             from django import forms
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render
             from django.http import HttpResponse
             from django.db.models import Q
             from django.contrib.auth.decorators import login_required
             import mongoengine
             from pymongo import MongoClient
             from plotter.models import Experiment, ExpDetail, PlotMeta, PlotData, JROReport, JROExperiment
             from utils.plots import skynoise_plot, overjro_plot, antennacuts_plot, muf_plot, get_options_MUF
             host = os.environ.get('HOST_MONGO', 'localhost')
             mongoengine.connect('dbplots', host=host, port=27017)
             CLIENT = MongoClient('{}:27017'.format(host))
             DB = CLIENT['dbplots']
             # Forms
             class SearchForm(forms.Form):
                 experiment = forms.ChoiceField()
                 plot = forms.ChoiceField()
                 def __init__(self, *args, **kwargs):
                     exp_choices = kwargs.pop('exp_choices', [])
                     plt_choices = kwargs.pop('plt_choices', [])
                     super(SearchForm, self).__init__(*args, **kwargs)
                     self.fields['experiment'].choices = [(0, 'Select Experiment')] + exp_choices
                     self.fields['plot'].choices = [(0, 'Select Plot')] + plt_choices
             # we use this class to change the parameter in Scatter plot using the function plotly.restyle in jroplot.js
             class ScatterSetupForm(forms.Form):
                 plotdiv = forms.CharField(widget=forms.HiddenInput())
                 ymax = forms.CharField(initial=30)
                 ymin = forms.CharField(initial=10)
             # we use this class to change the parameter in RTI plot using the function plotly.restyle in jroplot.js
             class RTISetupForm(forms.Form):
                 plotdiv = forms.CharField(widget=forms.HiddenInput())
                 colormap = forms.ChoiceField(choices=[('Jet', 'Jet'), ('Viridis', 'Viridis'), ('RdBu', 'RdBu')])
                 zmax = forms.CharField(initial=30)
                 zmin = forms.CharField(initial=10)
                 ymax = forms.CharField(initial=180)
                 ymin = forms.CharField(initial=80)
             # we use this class to change the parameter in SPC plot using the function plotly.restyle in jroplot.js
             class SPCSetupForm(forms.Form):
                 plotdiv = forms.CharField(widget=forms.HiddenInput())
                 colormap = forms.ChoiceField(choices=[('Jet', 'Jet'), ('Viridis', 'Viridis'), ('RdBu', 'RdBu')])
                 #como es un perfil xmin y xmax deben ser iguales a zmin y zmax
                 xmax = forms.CharField(initial=30)
                 xmin = forms.CharField(initial=10)
                 #x2max = forms.CharField(initial=30)
                 #x2min = forms.CharField(initial=10)
                 ymax = forms.CharField(initial=180)
                 ymin = forms.CharField(initial=80)
                 zmax = forms.CharField(initial=30)
                 zmin = forms.CharField(initial=10)
             # Create your views here.
             def main(request, tag=None):
                 kwargs = {}
                 date = request.GET.get('date', datetime.now().strftime('%d-%m-%Y'))
                 exps = ExpDetail.objects(date=datetime.strptime(date, '%d-%m-%Y')).order_by('tag')
                 tmp = {}
                 for exp in exps:
                     label = exp.tag.lower().strip() if exp.tag else 'other'
                     if label in tmp:
                         tmp[label] += 1
                     else:
                         tmp[label] = 1
                 tags = []
                 for key, value in tmp.items():
                     if tag == key:
                         tags.append({'name': key, 'n': tmp[key], 'active': 'primary'})
                     else:
                         tags.append({'name': key, 'n': tmp[key], 'active': 'secondary'})
                 tags.sort(key= lambda x: x['name'])
                 kwargs['tags'] = tags
                 if tags and tag is None:
                     if 'jicamarca' in [t['name'] for t in tags]:
                         tag = 'jicamarca'
                     elif 'julia' in [t['name'] for t in tags]:
                         tag = 'julia'
                     else:
                         tag = tags[0]['name']
                 for t in tags:
                     if tag == t['name']:
                         t['active'] = 'primary'
                 experiments = []
                 if tag:
                     for exp in exps:
                         label = exp.tag.lower().strip() if exp.tag else 'other'
                         if label != tag:
                             continue
                         dum = {}
                         dum['code'] = exp.experiment.code
                         dum['plots'] = []
                         dum['name'] = exp.experiment.name
                         t = time.time()
                         if (t-exp['last_time']) > 6*exp['interval']:
                             status = 'Offline'
                             clase = 'alertas-offline'
                             style = 'danger'
                         elif (t-exp['last_time']) > 3*exp['interval']:
                             status = 'Delayed'
                             clase = 'alertas-delayed'
                             style = 'warning'
                         else:
                             status = 'Online'
                             clase = 'alertas-online'
                             style = 'success'
                         dum['status'] = status
                         dum['class'] = clase
                         dum['style']= style
                         dum['date']= datetime.fromtimestamp(exp['last_time'])
                         for plot in exp.plots():
                             dum['plots'].append({'plot': plot.plot, 'name': plot.plot.replace('_', ' ').title(), 'id':plot.id})
                         experiments.append(dum)
                     kwargs['experiments'] = experiments
                     kwargs['tag'] = tag
                 kwargs['date'] = date
                 kwargs['title'] = 'Experiments'
                 kwargs['slide'] = 'slide-experiments.jpg'
                 kwargs['info'] = 'On this page you can view the Radar Status and some Display of the current experiment'
                 if experiments:
                     kwargs['sidebar'] = 'ok'
                 return render(request, 'home.html', kwargs)
             def about(request):
                 '''
                 '''
                 kwargs = {
                     'title': 'About',
                     'slide': 'slide-about.png',
                 }
                 return render(request, 'about.html', kwargs)
             def tools(request):
                 '''
                 '''
                 kwargs = {
                     'title': 'Tools',
                     'doy': (datetime.today().date()-datetime.today().date().replace(month=1, day=1)).days + 1,
                     'slide': 'slide-tools.png',
                     'info' : 'A list of useful programs for the Jicamarca Radio Observatory researchers'
                 }
                 return render(request, 'tools.html', kwargs)
             def reports(request):
                 '''
                 '''
                 q = request.GET.get('q', None)
                 reports = JROReport.objects.all()
                 years = reports.values_list('date__year').distinct()
                 if q is not None:
                     if q == 'all':
                         reports = reports.order_by('date')
                     else:
                         reports = reports.filter(Q(title__contains=q) | Q(description__contains=q)).order_by('date')
                 else:
                     reports = reports.filter(date__year=datetime.now().year).order_by('date')
                     q = str(datetime.now().year)
                 kwargs = {
                     'title': 'Reports',
                     'reports': reports,
                     'slide': 'slide-reports.png',
                     'years': [str(y[0]) for y in years],
                     'q' : q,
                     'info' : 'Monthly reports of the status of the equatorial ionosphere.'
                 }
                 return render(request, 'reports.html', kwargs)
             def codes(request):
                 '''
                 '''
                 codes = JROExperiment.objects.all().order_by('code')
                 kwargs = {
                     'title': 'Codes',
                     'codes': codes,
                     'info' : 'Monthly reports of the status of the equatorial ionosphere.'
                 }
                 return render(request, 'codes.html', kwargs)
             def update_codes(request):
                 '''
                 '''
                 codes = JROExperiment.objects.all().order_by('code')
                 for code in codes:
                     exp = Experiment.objects(code=code.code).modify(
                         upsert=True, # To add a new row
                         new=True,
                         set__code=code.code,
                         set__name=code.name,
                         )
                     exp.save()
                 return render(request, 'home.html', {})
             @login_required
             def delete_data(request):
                 '''
                 '''
                 date = request.GET.get('date', None)
                 code = request.GET.get('code', None)
                 detail = ExpDetail.objects()
                 if code is not None and date is not None:
                     exp = Experiment.objects.get(code=int(code))
                     detail = detail.filter(experiment=exp, date=datetime.strptime(date, '%d-%m-%Y'))
                 elif code is not None:
                     exp = Experiment.objects.get(code=int(code))
                     detail = detail.filter(experiment=exp)
                 elif date is not None:
                     detail = detail.filter(date=datetime.strptime(date, '%d-%m-%Y'))
                 else:
-                    detail = detail.filter(date__lt=datetime.today().date()-timedelta(days=2))
+                    detail = detail.filter(date__lt=datetime.today().date()-timedelta(days=1))
                 metas = PlotMeta.objects(exp_detail__in=[x.pk for x in detail])
                 datas = PlotData.objects(plot__in=[x.pk for x in metas])
                 d=datas.delete()
                 m=metas.delete()
                 t=detail.delete()
                 messages.error(request, 'Delete: {} data, {} meta, {} details'.format(d, m, t))
                 return render(request, 'home.html', {})
             def plot(request, code=None, plot=None):
                 '''
                 '''
                 realtime = False
                 date = request.GET.get('date', None)
                 if date is None:
                     date = datetime.now().strftime('%d-%m-%Y')
                     realtime = True
                 exp = Experiment.objects.get(code=int(code))
                 detail = ExpDetail.objects.get(experiment=exp, date=datetime.strptime(date, '%d-%m-%Y'))
                 meta = PlotMeta.objects.get(exp_detail=detail, plot=plot)
                 tag = detail.tag.lower().strip() if detail.tag else 'other'
                 kwargs = {
                     'code': code,
                     'plot': plot,
                     'meta':meta,
                     'date': date,
                     'id': meta.pk,
                     'realtime': realtime,
                     'title': 'Experiments',
                     'name' : exp.name,
                     'sidebar': True,
                     'tag' : tag,
                     'plots': [],
                     'slide': 'slide-plot.jpg',
                 }
                 for plt in detail.plots():
                     kwargs['plots'].append({'plot': plt.plot, 'name': plt.plot.replace('_', ' ').title()})
                 # Logic to show my views
                 if meta.metadata['type'] == 'pcolorbuffer':
                     kwargs['setup_form'] = RTISetupForm()
                     kwargs['fn_plot'] = 'PcolorBuffer'
                     return render(request, 'plot.html', kwargs)
                 elif meta.metadata['type'] == 'pcolor':
                     kwargs['setup_form'] = SPCSetupForm()
                     kwargs['fn_plot'] = 'Pcolor'
                     return render(request, 'plot.html', kwargs)
                 elif meta.metadata['type'] == 'scatterbuffer':
                     kwargs['setup_form'] = ScatterSetupForm()
                     kwargs['fn_plot'] = 'ScatterBuffer'
                     return render(request, 'plot.html', kwargs)
                 elif meta.metadata['type'] == 'scatter':
                     kwargs['setup_form'] = ScatterSetupForm()
                     kwargs['fn_plot'] = 'Scatter'
                     return render(request, 'plot.html', kwargs)
                 elif meta.metadata['type'] == 'scattermap':
                     kwargs['setup_form'] = ScatterSetupForm()
                     kwargs['fn_plot'] = 'ScatterMap'
                     return render(request, 'plot.html', kwargs)
                 elif meta.metadata['type'] == 'image':
                     kwargs['image'] = True
                     kwargs['fn_plot'] = 'StaticPlot'
                     return render(request, 'plot.html', kwargs)
                 else:
                     return render(request, 'home.html', {})
             def plot_skynoise(request):
                 date = request.GET.get('date', None)
                 if date is None:
                     date = datetime.now()
                 else:
                     date = datetime.strptime(date, '%Y-%m-%d')
                 data = skynoise_plot(date.year, date.month, date.day)
                 response = HttpResponse(data.getvalue(), content_type='image/png')
                 return response
             def plot_overjro(request):
                 date = request.GET.get('date', None)
                 if date is None:
                     date = datetime.now()
                 else:
                     date = datetime.strptime(date, '%Y-%m-%d')
                 pattern = int(request.GET.get('experiment', '1'))
                 angle = float(request.GET.get('angle', '5'))
                 height = [float(h) for h in request.GET.get('height', '100').split(',')]
                 bodys = (request.GET.get('bodys', '')).split(',')
                 data = overjro_plot(pattern, date, angle, height, bodys)
                 response = HttpResponse(data.getvalue(), content_type='image/png')
                 return response
             def plot_antennacuts(request):
                 date = request.GET.get('date', None)
                 if date is None:
                     date = datetime.now()
                 else:
                     date = datetime.strptime(date, '%Y-%m-%d')
                 pattern = int(request.GET.get('experiment', '1'))
                 angle = float(request.GET.get('angle', '5'))
                 height = [float(h) for h in request.GET.get('height', '100').split(',')]
                 bodys = (request.GET.get('bodys', '')).split(',')
                 data = antennacuts_plot(pattern, date, angle, height, bodys)
                 response = HttpResponse(data.getvalue(), content_type='image/png')
                 return response
             def plot_MUF(request):
                 #Version IRI disponibles: 2007,2012,2016
                 #Por defecto 2016
                 version_IRI=2016
                 date=request.GET.get("date",None)
                 if date is None:
                     date=None
                 else:
                     try:
                         date= datetime.strptime(date,"%Y-%m-%d")
                     except ValueError:
                         date=None
                 valueoption=int(request.GET.get("valueoption","17") )
                 if (valueoption>0):
                     latitude,longitude = get_options_MUF(valueoption)
                 elif (valueoption!=-1):
                     latitude=float(request.GET.get("latitude","-10"))
                     latitude=round(latitude,2)
                     longitude=float(request.GET.get("longitude","-78"))
                     longitude=round(longitude,2)
                 data=muf_plot(latitude,longitude,version_IRI,date)
                 response = HttpResponse(data.getvalue(), content_type='image/png')
                 return response

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