irie 0.0.0__py3-none-any.whl

irie/apps/events/tests_events.py

@@ -0,0 +1,240 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Author: Claudio Perez
+#
+#----------------------------------------------------------------------------#
+from django.test import TestCase
+from django.contrib.auth.models import User
+import json
+
+test_user = {"username": "testuser", "password": "testpassword"}
+event_file = "../tests/58658_007_20210426_10.09.54.P.zip"
+
+class QuakeEventTest(TestCase):
+    def setUp(self):
+        new_user = User.objects.create(username=test_user["username"])
+        new_user.set_password(test_user["password"])
+        new_user.save()
+
+    def get_token(self):
+        res = self.client.post(
+            "/api/token/",
+            data=json.dumps(
+                {
+                    "username": test_user["username"],
+                    "password": test_user["password"],
+                }
+            ),
+            content_type="application/json",
+        )
+        result = json.loads(res.content)
+        self.assertTrue("access" in result)
+        return result["access"]
+
+    def test_add_events_forbidden(self):
+        with open(event_file, "rb") as fp:
+            res = self.client.post(
+                "/api/events/",
+                {
+                    "upload_data": {"name": "name"},
+                    "event_file": fp,
+                },
+                #content_type="multipart/form-data",
+            )
+        self.assertEquals(res.status_code, 401)
+        res = self.client.post(
+            "/api/events/",
+            {
+                "upload_data": {"name": "2"},
+                "event_file": open(event_file,"rb")
+            },
+            #content_type="multipart/form-data",
+            HTTP_AUTHORIZATION=f"Bearer WRONG TOKEN",
+        )
+        self.assertEquals(res.status_code, 401)
+
+    def test_add_events_ok(self):
+        token = self.get_token()
+        with open(event_file,"rb") as fp:
+            res = self.client.post(
+                "/api/events/",
+                {
+                    "upload_data": '{"name": "2"}',
+                    "event_file": fp
+                },
+                #content_type="multipart/form-data",
+                HTTP_AUTHORIZATION=f"Bearer {token}",
+            )
+        self.assertEquals(res.status_code, 201)
+        print("res.content: ",res.content)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(result["upload_data"]["name"], "2")
+
+    def test_add_events_wrong_data(self):
+        token = self.get_token()
+        res = self.client.post(
+            "/api/events/",
+            data=json.dumps(
+                {
+                    "upload_data": '{"name": "2020-01-01"}',
+                    "item": "Hard Drive",
+                    "price": -1,
+                    "quantity": 10,
+                }
+            ),
+            content_type="multipart/form-data",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 400)
+
+        res = self.client.post(
+            "/api/events/",
+            data=json.dumps(
+                {
+                    "upload_data": '{"name": "2020-01-01"}',
+                    "item": "Hard Drive",
+                    "price": 1,
+                    "quantity": -10,
+                }
+            ),
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 400)
+
+        res = self.client.post(
+            "/api/events/",
+            data=json.dumps(
+                {
+                    "upload_data": '{"date": "2020-01-01"}',
+                    "item": "",
+                    "price": 1,
+                    "quantity": 10,
+                }
+            ),
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 400)
+
+    def test_add_events_calculate(self):
+        token = self.get_token()
+        res = self.client.post(
+            "/api/events/",
+            {
+                "upload_data": '{"name": "2020-01-01"}',
+            },
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 201)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(result["amount"], 35)  # should be calculated
+
+    #  -------------------------- GET RECORDS -------------------------------------------
+
+    def test_get_records(self):
+        token = self.get_token()
+        with open(event_file, "rb") as fp:
+            res = self.client.post(
+                "/api/events/",
+                {"upload_data": '{"name":"1"}', "event_file": fp},
+                #content_type="multipart/form-data",
+                HTTP_AUTHORIZATION=f"Bearer {token}",
+            )
+        self.assertEquals(res.status_code, 201)
+        id1 = json.loads(res.content)["data"]["id"]
+
+        with open(event_file, "rb") as fp:
+            res = self.client.post(
+                "/api/events/",
+                {"upload_data": '{"name":"2"}', "event_file": fp},
+                #content_type="multipart/form-data",
+                HTTP_AUTHORIZATION=f"Bearer {token}",
+            )
+        self.assertEquals(res.status_code, 201)
+        id2 = json.loads(res.content)["data"]["id"]
+        
+
+        # Perform GET requests
+        res = self.client.get(
+            "/api/events/",
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+
+        self.assertEquals(res.status_code, 200)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(len(result), 2)  # 2 records
+        self.assertTrue(result[0]["id"] == id1 or result[1]["id"] == id1)
+        self.assertTrue(result[0]["id"] == id2 or result[1]["id"] == id2)
+
+        res = self.client.get(
+            f"/api/events/{id1}/",
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 200)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(result["upload_data"]["name"], "1")
+
+
+    #  -------------------------- PUT AND DELETE RECORDS --------------------------------------
+
+    def test_put_delete_records(self):
+        token = self.get_token()
+        with open(event_file, "rb") as fp:
+            res = self.client.post(
+                "/api/events/",
+                {
+                    "upload_data": '{"name":"test_put_delete_records"}',
+                    "event_file": fp
+                },
+                #content_type="multipart/form-data",
+                HTTP_AUTHORIZATION=f"Bearer {token}",
+            )
+        self.assertEquals(res.status_code, 201)
+        id = json.loads(res.content)["data"]["id"]
+
+        with open(event_file, "rb") as fp:
+            res = self.client.put(
+                f"/api/events/{id}/",
+                {"name": "new_name", "event_file": fp},
+                #content_type="multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW",
+                content_type="multipart/form-data",
+                HTTP_AUTHORIZATION=f"Bearer {token}",
+            )
+
+        print(res.content)
+        self.assertEquals(res.status_code, 200)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(result["upload_data"]["name"], "new_name")
+
+        res = self.client.get(
+            f"/api/events/{id}/",
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 200)
+        result = json.loads(res.content)["data"]
+        self.assertEquals(result["upload_data"]["name"], "new_name")
+
+
+        res = self.client.delete(
+            f"/api/events/{id}/",
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 410)  # Gone
+
+        res = self.client.get(
+            f"/api/events/{id}/",
+            content_type="application/json",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEquals(res.status_code, 404)  # Not found
+

irie/apps/events/urls.py

@@ -0,0 +1,29 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Author: Claudio Perez
+#
+#----------------------------------------------------------------------------#
+import rest_framework_simplejwt.views as jwt_views
+
+from django.urls import path
+from django.conf.urls.static import static
+
+from . import views_events, views
+
+
+urlpatterns = [
+    path("event-table/",                      views.event_table, name="event_table"),
+    path("event-table.html", views.event_table),
+
+    path("events/", views_events.index),
+    path('api/token/', jwt_views.TokenObtainPairView.as_view(), name='token_obtain_pair'),
+    path('api/token/refresh/', jwt_views.TokenRefreshView.as_view(), name='token_refresh'),
+    path('api/events/', views_events.events),
+    path('api/events/<int:event_id>/', views_events.event),
+]
+#+ static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
+

irie/apps/events/views.py

@@ -0,0 +1,55 @@
+
+import os
+from django.template import loader
+from django.core.paginator import Paginator
+from django.http import HttpResponse
+from django.contrib.auth.decorators import login_required
+
+from apps.events.models import Event
+from apps.site.view_utils import raise404
+
+
+@login_required(login_url="/login/")
+def event_table(request):
+    """
+    This view generates the event table page. It uses the event-table.html
+    """
+    context = {}
+    page_template = "event-table.html"
+    context["segment"] = "event-table.html"
+
+    page = request.GET.get("page", 1)
+    try:
+        page = int(page)
+    except:
+        page = 1
+    
+    asset = request.GET.get("asset", None)
+
+    if asset is not None:
+        events = [i for i in reversed(sorted(Event.objects.filter(asset=asset),
+                             key=lambda x: x.motion_data["event_date"]))]
+    else:
+        events = [i for i in reversed(sorted(Event.objects.all(),
+                             key=lambda x: x.motion_data["event_date"]))]
+    
+    # Paginator for 10 items per page
+    paginator = Paginator(events, 15)
+
+
+# reversed(sorted(Event.objects.all(),
+#                                         key=lambda x: x.motion_data["event_date"]))
+    context["events"] = paginator.get_page(page)
+
+
+    html_template = loader.get_template("events/" + page_template)
+
+    try:
+        return HttpResponse(html_template.render(context, request))
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("site/page-500.html")
+        return HttpResponse(html_template.render(context, request))
+

irie/apps/events/views_events.py

@@ -0,0 +1,215 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+import json
+import datetime
+from threading import Thread
+from django.shortcuts import render
+from django.core.exceptions import ObjectDoesNotExist
+from django.shortcuts import HttpResponse
+from django.forms.models import model_to_dict
+
+from rest_framework.parsers import JSONParser, MultiPartParser
+from rest_framework.decorators import api_view, permission_classes, parser_classes
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+
+from .models import Event
+from apps.inventory.models import Asset
+# from apps.evaluation.evaluation import (run_evaluation,
+#                                         add_evaluation)
+from apps.evaluation.models import Evaluation
+import quakeio
+
+
+def serialize_event(event):
+    serialized = model_to_dict(event)
+    serialized["upload_date"] = str(event.upload_date)
+
+    if event.event_file:
+        serialized["event_file"] = event.event_file.path
+    else:
+        serialized["event_file"] = None
+
+    #serialized["data_str"] = json.loads(event.data_str) if event.data_str else {}
+    return serialized
+
+
+def save_event(request, event, success_status):
+    errors = []
+
+    # DATE
+    upload_date = datetime.datetime.now()
+
+    # UPLOAD DATA
+    upload_data = request.data.get("upload_data", "{}")
+    if upload_data == "":
+        errors.append({"upload_data": "This field is required"})
+
+    # EVENT FILE
+    try:
+        event_file = request.FILES["event_file"]
+    except KeyError:
+        event_file = None
+#       errors.append({"event_file": "This field is required"})
+    except Exception as e:
+        errors.append({"event_file": str(e)})
+
+
+    if len(errors) > 0:
+        return HttpResponse(json.dumps(
+            {
+                "errors": errors
+            }), status=status.HTTP_400_BAD_REQUEST)
+
+    # MOTION DATA
+    if event_file is not None:
+        try:
+            motion_data = (
+                quakeio.read(
+                    event_file.temporary_file_path(), input_format="csmip.zip"
+                ).serialize(serialize_data=False, summarize=True)
+            )
+        except:
+            return HttpResponse(json.dumps(
+                {
+                    "errors": ["Failed to parse ground motion file."]
+                }), status=status.HTTP_400_BAD_REQUEST)
+    elif "motion_data" in request.data:
+        motion_data = json.loads(request.data.get("motion_data"))
+
+    else:
+        return HttpResponse(json.dumps(
+            {
+                "errors": ["No motion_data provided."]
+            }), status=status.HTTP_400_BAD_REQUEST)
+
+    # RECORD ID
+    rec_id = motion_data.get("record_identifier", "")
+
+
+    # CREATE EVENT
+    if event is None:
+        # Doing a PUT
+        event = Event.objects.filter(record_identifier=rec_id).first()
+        if event is None:
+            print("PUT: creating", rec_id, "\n\n")
+            event = Event()
+        else:
+            print("PUT: updating", rec_id, "\n\n")
+            upload_date = event.upload_date
+
+
+    event.upload_date = upload_date
+    event.upload_data = json.loads(upload_data)
+    event.record_identifier = rec_id
+    event.motion_data = motion_data
+    event.cesmd = "CE" + event.motion_data["station_number"]
+    try:
+        event.asset = Asset.objects.get(cesmd="CE" + event.motion_data["station_number"])
+    except:
+        return HttpResponse('{"errors": ["No asset with station CE' 
+                            +str(event.motion_data["station_number"])
+                            + 'from file '
+                            + str(event_file.temporary_file_path())
+                            + '"]}', 
+                            status=status.HTTP_400_BAD_REQUEST)
+    event.event_file = event_file
+#   if event_file is not None:
+
+    event.save()
+
+
+    # CREATE EVALUATION
+    if "evaluation" in request.data:
+        # TODO: check for parse error
+        eval_data = json.loads(request.data["evaluation"])
+    else:
+        eval_data = None
+
+
+    Evaluation.create(event, event.asset, eval_data)
+
+
+    # EMAIL
+    # Get users
+    from django.contrib.auth import get_user_model
+    User  = get_user_model()
+    users = User.objects.all()
+
+    station_name = event.motion_data["station_name"]
+
+    event.email_notify(
+        subject   = f"BRACE2: New event at '{station_name}'",
+
+        message      = ("A new event has been sent to the BRACE2 platform. "
+                       'visit  https://brace2-peer.ist.berkeley.edu/static/dmp/index.html for details.'),
+        html_message = ("A new event has been sent to the BRACE2 platform. "
+                       'visit <a href="https://brace2-peer.ist.berkeley.edu/static/dmp/index.html">here</a> for details.'),
+        fail_silently=True,
+        recipients=[user.email for user in users] + ["brace2-peer@mailinator.com"]
+    )
+
+    return HttpResponse(json.dumps({"data": serialize_event(event)}), status=success_status)
+
+
+
+def index(request):
+    context = {}
+    return render(request, "events/events.html", context=context)
+
+
+@api_view(["GET", "POST", "PUT"])
+@permission_classes([IsAuthenticated])
+def events(request):
+    # if request.user.is_anonymous:
+    #     return HttpResponse(json.dumps({"detail": "Not authorized"}), status=status.HTTP_401_UNAUTHORIZED)
+
+    if request.method == "GET":
+        events_data = Event.objects.all()
+
+        events_count = events_data.count()
+
+        page_size = int(request.GET.get("page_size", events_count))
+        page_no = int(request.GET.get("page_no", 0))
+        events_data = list(events_data[page_no * page_size:page_no * page_size + page_size])
+
+        events_data = [serialize_event(event) for event in events_data]
+        return HttpResponse(json.dumps({"count": events_count, "data": events_data}), status=status.HTTP_200_OK)
+
+    elif request.method == "POST":
+        event = Event()
+        return save_event(request, event, status.HTTP_201_CREATED)
+
+    elif request.method == "PUT":
+        return save_event(request, None, status.HTTP_201_CREATED)
+
+    return HttpResponse(json.dumps({"detail": "Wrong method"}), status=status.HTTP_501_NOT_IMPLEMENTED)
+
+
+@api_view(['GET', 'PUT', 'DELETE'])
+@parser_classes([JSONParser,MultiPartParser])
+@permission_classes([IsAuthenticated])
+def event(request, event_id):
+    #if request.user.is_anonymous:
+    #    return HttpResponse(json.dumps({"detail": "Not authorized"}), status=status.HTTP_401_UNAUTHORIZED)
+
+    try:
+        event = Event.objects.get(pk=event_id)
+    except ObjectDoesNotExist:
+        return HttpResponse(json.dumps({"detail": "Not found"}), status=status.HTTP_404_NOT_FOUND)
+
+    if request.method == "GET":
+        return HttpResponse(json.dumps({"data": serialize_event(event)}), status=status.HTTP_200_OK)
+
+    if request.method == "PUT":
+        return save_event(request, event, status.HTTP_200_OK)
+
+    if request.method == "DELETE":
+        event.delete()
+        return HttpResponse(json.dumps({"detail": "deleted"}), status=status.HTTP_410_GONE)
+
+    return HttpResponse(json.dumps({"detail": "Wrong method"}), status=status.HTTP_501_NOT_IMPLEMENTED)
+

irie/apps/inventory/CESMD.py

@@ -0,0 +1,81 @@
+CESMD = {
+ '89973': [40.5093, -124.1196],
+ '89324': [40.5031, -124.1009],
+ '89686': [40.8216, -124.1697],
+ '89736': [40.809, -124.1547],
+ '89735': [40.8136, -124.1594],
+ '47315': [36.8619, -121.5796],
+ '23631': [34.065, -117.2962],
+ '58700': [37.8198, -122.4788],
+ '25749': [34.4497, -119.735],
+ '14406': [33.7494, -118.2715],
+ '58632': [37.7982, -122.3774],
+ '58657': [37.8286, -122.2666],
+ '24775': [34.8663, -118.8836],
+ '58601': [37.8198, -122.3429],
+ '24706': [34.5463, -118.1301],
+ '33742': [35.6696, -117.8187],
+ '24704': [34.0368, -118.3762],
+ '24689': [34.1486, -118.1561],
+ '54730': [37.5733, -118.739],
+ '13705': [33.882, -117.5497],
+ '13795': [33.4659, -117.6674],
+ '68065': [38.1205, -122.2801],
+ '57595': [37.4639, -121.9302],
+ '68185': [38.061, -122.2265],
+ '68717': [38.3484, -122.713],
+ '58754': [37.3574, -122.397],
+ '58658': [37.6907, -122.0993],
+ '76741': [39.368, -120.1151],
+ '89708': [40.9563, -124.1161],
+ '24714': [34.2878, -118.4084],
+ '79421': [39.9213, -123.7634],
+ '68778': [38.1157, -122.5054],
+ '58602': [37.8126, -122.3627],
+ '68184': [38.061, -122.2252],
+ '12666': [33.9153, -116.6085],
+ '68682': [38.0414, -122.1238],
+ '12649': [33.9332, -116.9907],
+ '67771': [38.0278, -121.7514],
+ '57748': [37.4176, -121.9738],
+ '58600': [37.8152, -122.3589],
+ '69760': [38.955, -123.1051],
+ '47707': [36.9067, -121.7818],
+ '3679': [32.6891, -117.1538],
+ '24738': [34.2878, -118.865],
+ '36668': [35.7331, -120.2901],
+ '37728': [35.5955, -121.1256],
+ '3731': [32.838, -117.234],
+ '99190': [41.8797, -124.1373],
+ '25324': [34.2428, -119.1905],
+ '58258': [37.9344, -122.4346],
+ '79757': [39.8485, -123.7019],
+ '68322': [38.0441, -122.1229],
+ '58596': [37.505, -122.12],
+ '24694': [34.3349, -118.5084],
+ '79683': [39.2157, -123.7678],
+ '24670': [34.0314, -118.4354],
+ '69671': [38.4347, -123.1017],
+ '79761': [39.8471, -123.6967],
+ '58656': [37.7837, -122.1769],
+ '67972': [38.5728, -121.587],
+ '99710': [41.5174, -124.0307],
+ '23650': [34.2251, -117.4096],
+ '58677': [37.5836, -122.2515],
+ '25758': [34.9331, -119.5941],
+ '79296': [39.4274, -123.8068],
+ '58536': [37.6746, -122.3895],
+ '58501': [37.6708, -122.0885],
+ '58414': [37.584, -122.509],
+ '1571':  [37.34105, -121.8514],
+ '5235':  [33.96843, -117.44815],
+ '25725': [34.2622, -119.231],
+ '58799': [37.6083, -122.1842],
+ '47646': [36.2391, -121.7747],
+ '88638': [40.881, -122.3809],
+ '22503': [34.2419, -116.9775],
+ '88194': [40.7597, -122.3188],
+ '26917': [34.5215, -120.3369],
+ '34715': [35.0387, -118.1696],
+ '14690': [33.7865, -118.0939],
+ '58678': [37.5048, -122.3346]}

irie/apps/inventory/__init__.py

@@ -0,0 +1,5 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#

irie/apps/inventory/admin.py

@@ -0,0 +1,10 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+from django.contrib import admin
+from .models import Asset, Corridor
+
+admin.site.register(Corridor)
+admin.site.register(Asset)

irie/apps/inventory/apps.py

@@ -0,0 +1,12 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+from django.apps import AppConfig
+
+
+class InventoryConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.inventory'
+    label = 'apps_inventory'