initial upload

api/base_views.py

@@ -0,0 +1,120 @@
+from django.shortcuts import get_object_or_404
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from utils.numbers import int_or_none
+
+
+def add_envelope(request, data, meta={}):
+    env = {}
+    env['data'] = data
+    env['meta'] = meta
+    env['meta']['request'] = request.build_absolute_uri(request.get_full_path())
+    return env
+
+class BaseView( APIView):
+    def __init__(self, *args, **kwargs):
+        self.rows_found = None
+        super(BaseView, self).__init__(*args, **kwargs)
+
+    def get(self, request, pk=None, format=None):
+        queryset = self._get_queryset(request, pk)
+        srlzr = self._get_serializer_class()
+        serializer = srlzr(queryset, many=self.many, context={'request': request})
+        return self._send_response(serializer.data)
+
+    def _send_response(self, data, meta=None):
+        return Response(data)
+
+    def _get_meta_serializer_function(self): return lambda request, queryset: {}
+
+    def _get_model(self): pass
+    def _get_queryset(self, request, pk): pass
+    def _get_serializer_class(self): pass
+
+
+class StandardListView(BaseView):
+    many = True
+    def _get_queryset(self, request, pk=None):
+        limit = None
+        if 'limit' in request.query_params:
+            val = int_or_none(request.query_params['limit'])
+            if val is not None and val >= 0:
+                limit = val
+        offset = 0
+        if 'offset' in request.query_params:
+            val = int_or_none(request.query_params['offset'])
+            if val is not None and val >= 0:
+                offset = val
+        model = self._get_model()
+        queryset = model.objects.all()
+        self.rows_found = queryset.count()
+        if limit:
+            queryset = queryset[offset:offset + limit]
+        return queryset
+
+
+class StandardDetailView(BaseView):
+    many = False
+    def _get_queryset(self, request, pk):
+        model = self._get_model()
+        queryset = model.objects.get(pk=pk)
+        return queryset
+
+
+class SerializeFunctionDetailView(BaseView):
+    many = False
+    def get(self, request, pk=None, format=None):
+        obj = get_object_or_404(self._get_model(), pk=pk)
+        srlzr = self._get_serializer_function()
+        data = srlzr(obj, request)
+        return self._send_response(data)
+
+
+class SerializeFunctionListView(BaseView):
+    many = True
+    def get(self, request):
+        limit = None
+        if 'limit' in request.query_params:
+            val = int_or_none(request.query_params['limit'])
+            if val is not None and val >= 0:
+                limit = val
+        offset = 0
+        if 'offset' in request.query_params:
+            val = int_or_none(request.query_params['offset'])
+            if val is not None and val >= 0:
+                offset = val
+        srlzr = self._get_serializer_function()
+        meta_srlzr = self._get_meta_serializer_function()
+        queryset = self._get_queryset()
+        queryset = self._filter_queryset(request, queryset)
+        queryset = self._sort_queryset(request, queryset)
+        self.rows_found = queryset.count()
+        if limit:
+            queryset = queryset[offset:offset + limit]
+        data = srlzr(queryset, request)
+        meta = meta_srlzr(queryset, request)
+        return self._send_response(data, meta)
+
+    def _get_queryset(self):
+        model = self._get_model()
+        queryset = model.objects.all()
+        return queryset
+
+    def _filter_queryset(self, request, queryset):
+        return queryset
+
+    def _sort_queryset(self, request, queryset):
+        return queryset
+
+
+class EnvelopeView(BaseView):
+    meta = {}
+
+    def _send_response(self, data, meta=None):
+        if meta is None:
+            meta = {}
+        self.meta.update(meta)
+        self.meta['rows_found'] = self.rows_found
+        self.meta['rows_sent'] = len(data)
+        return Response(add_envelope(self.request, data, self.meta))

api/serializers.py

@@ -0,0 +1,28 @@
+from app import models
+from utils.log import log
+
+def NodeSerializer(objs, request = None):
+	data = {'results':{'nodes':[]},'meta':{'number_of_nodes':0}}
+
+	for obj in objs:
+		node = {
+			'name':node.devicealias,
+			'data':[],
+			'source':node.sourcetype,
+			'long':node.long,
+			'lat':node.lat,
+			'tags':[tag.name for tag in models.tag.objects.filter( node = obj) ]
+		}
+
+		for d in models.data.objects.filter(node = node):
+			data = {
+				'timstamp': d.timestamp,
+				'sensor':d.source,
+				'measurement':d.data,
+
+			}
+			node['data'].append(data)
+
+		data['results']['nodes'].append(node)
+
+	return data

api/urls.py

@@ -0,0 +1,7 @@
+from django.conf.urls import url, include
+from rest_framework import routers
+import views
+
+urlpatterns = [
+	url(r'^data/$', views.NodeListView.as_view()),
+]

api/views.py

@@ -0,0 +1,33 @@
+from api import serializers
+from api import base_views
+from app import models
+
+class NodeListView(base_views.SerializeFunctionListView):
+    def _get_model(self):
+        return models.node
+
+    def _get_serializer_function(self):
+        return serializers.NodeSerializer
+
+    def _filter_queryset(self, request, queryset):
+
+    	# long / lat  filter
+    	if request.query_params.get('loc_start') and request.query_params.get('loc_end'):
+    		pass
+
+    	# tags filter
+    	if request.query_params.get('tags'):
+    		pass
+
+    	# device name
+    	if request.query_params.get('name'):
+    		pass
+
+    	# time filter 
+    	if request.query_params.get('date_st'):
+    		pass
+
+    	if request.query_params.get('end_st'):
+    		pass
+
+    	return queryset

app/admin.py

@@ -0,0 +1,75 @@
+from django.contrib import admin
+from app import models
+from utils.log import log
+from copy import deepcopy
+# Register your models here.
+
+def register_admin(model):
+    """Turn admin.site.register into a decorator."""
+    def wrapper(klass):
+        admin.site.register(model, klass)
+        return klass
+    return wrapper
+
+@admin.register(models.sensor)
+class SensorAdmin(admin.ModelAdmin):
+    list_display = ('name','type','units','mean','std')
+    list_filter = ('type',)
+    search_fields = ['name']
+
+#def reset_nodesim(modeladmin, request, queryset):
+#    for qs in queryset:
+#    	pass
+
+#def stop_nodesim(modeladmin, request, queryset):
+#    for qs in queryset:
+#    	pass
+
+#def start_nodesim(modeladmin, request, queryset):
+#    for qs in queryset:
+#    	pass
+
+def copy_simnode(modeladmin, request, queryset):
+    for qs in queryset:
+        simnode = deepcopy(qs)
+        simnode.name = "%s (copy)" % qs.name
+        simnode.pk = None
+        simnode.save()
+        simnode.sensors.add(*qs.sensors.all())
+
+@admin.register(models.sim_node)
+class SimNodeAdmin(admin.ModelAdmin):
+    list_display = ('name','devicealias','measurement_count')
+
+    search_fields = ['devicealias']
+    search_fields = ['name']
+    filter_horizontal = ('sensors',)
+
+    actions = [copy_simnode]
+
+class TagInline(admin.TabularInline):
+    model = models.tag
+
+@admin.register(models.node)
+class NodeAdmin(admin.ModelAdmin):
+    list_display = ('name','active','long','lat','sourcetype','devicealias','notes')
+    list_filter = ('active','sourcetype')
+    search_fields = ['name']
+    inlines = [
+        TagInline,
+    ]
+    readonly_fields = ('ph_chart', 'temperature_chart','conductivity_chart','turbidity_chart','orp_chart','odo_chart')
+    fieldsets = [
+            ('Node', { 'fields':  [  'active', 'name', 'long', \
+                            'lat', 'devicealias', 'sourcetype','commtype','deviceaddress','hostip','proxy_url','notes' ]}), \
+            ('Ph', { 'fields':  [  'ph_chart',  ]}),
+            ('Temperature', { 'fields':  [  'temperature_chart',  ]}),
+
+            ('Conductivity', { 'fields':  [  'conductivity_chart',  ]}),
+            ('Turbidity', { 'fields':  [  'turbidity_chart',  ]}),
+            ('Oxygen Reduction Potential', { 'fields':  [  'orp_chart',  ]}),
+            ('Dissolved Oxygen', { 'fields':  [  'odo_chart',  ]}),
+    ]
+
+    class Media:
+        js = ("js/node.js",)

app/apps.py

@@ -0,0 +1,7 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class AppConfig(AppConfig):
+    name = 'app'

app/choice.py

@@ -0,0 +1,22 @@
+_COMM_TYPE = (
+	('',''),
+        ('weave','weave'),
+        ('konekt','konekt'),
+)
+
+_SOURCE_TYPE = (
+		('live','live'),
+        ('sim','simulator')
+    )
+
+_SENSOR_TYPE = (
+	('conductivity','Conductivity'),
+	('orp','Oxygen Reduction Potential'),
+	('odo','Dissolved Oxygen'),
+	('turbidity','Turbidity'),
+	('temperature','temperature'),
+	('ph','Ph'),
+
+)
+
+

app/const.py

@@ -0,0 +1,8 @@
+_SENSOR_UNITS = {
+	'conductivity':'uS/cm',
+	'orp':'mV',
+	'odo':'mg/L',
+	'turbidity':'NTU',
+	'temperature':'C',
+	'ph':'pH'		
+}