Added Static Pages

server/Dockerfile

@@ -0,0 +1,28 @@
+    FROM python:3.8.2
+
+    ENV PYTHONBUFFERED 1
+    ENV PYTHONWRITEBYTECODE 1
+
+    RUN apt-get update \
+        && apt-get install -y netcat
+
+    ENV APP=/app
+
+    # Change the workdir.
+    WORKDIR $APP
+
+    # Install the requirements
+    COPY requirements.txt $APP
+
+    RUN pip3 install -r requirements.txt
+
+    # Copy the rest of the files
+    COPY . $APP
+
+    EXPOSE 8000
+
+    RUN chmod +x /app/entrypoint.sh
+
+    ENTRYPOINT ["/app/entrypoint.sh"]
+
+    CMD ["gunicorn", "--bind", ":8000", "--workers", "3", "djangobackend.wsgi"]

server/deployment.yaml

@@ -0,0 +1,29 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    run: dealership
+  name: dealership
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      run: dealership
+  strategy:
+    rollingUpdate:
+      maxSurge: 25%
+      maxUnavailable: 25%
+    type: RollingUpdate
+  template:
+    metadata:
+      labels:
+        run: dealership
+    spec:
+      containers:
+      - image: us.icr.io/gonzalesjtho/dealership:latest
+        imagePullPolicy: Always
+        name: dealership
+        ports:
+        - containerPort: 8000
+          protocol: TCP
+      restartPolicy: Always

server/djangoapp/admin.py

@@ -1,13 +1,22 @@
 from django.contrib import admin
-# from .models import related models
+from .models import CarMake, CarModel
 
 
 # Register your models here.
 
 # CarModelInline class
+class CarModelInLine(admin.StackedInline):
+    model = CarModel
 
 # CarModelAdmin class
+class CarModelAdmin(admin.ModelAdmin):
+    list_display = ['name']
 
 # CarMakeAdmin class with CarModelInline
+class CarMakeAdmin(admin.ModelAdmin):
+    inlines = [CarModelInLine]
+    list_display = ['name']
 
 # Register models here
+admin.site.register(CarMake, CarMakeAdmin)
+admin.site.register(CarModel, CarModelAdmin)

server/djangoapp/models.py

@@ -1,27 +1,78 @@
 from django.db import models
 from django.utils.timezone import now
-
+import datetime
 
 # Create your models here.
 
 # <HINT> Create a Car Make model `class CarMake(models.Model)`:
-# - Name
-# - Description
-# - Any other fields you would like to include in car make model
-# - __str__ method to print a car make object
-
+class CarMake(models.Model):
+    name = models.CharField(null=False, max_length=20, primary_key=True)
+    desc = models.TextField()
+    def __str__(self):
+        return "Name: " + self.name + "," \
+                "Description: " + self.desc
 
 # <HINT> Create a Car Model model `class CarModel(models.Model):`:
-# - Many-To-One relationship to Car Make model (One Car Make has many Car Models, using ForeignKey field)
-# - Name
-# - Dealer id, used to refer a dealer created in cloudant database
-# - Type (CharField with a choices argument to provide limited choices such as Sedan, SUV, WAGON, etc.)
-# - Year (DateField)
-# - Any other fields you would like to include in car model
-# - __str__ method to print a car make object
-
+class CarModel(models.Model):
+    make = models.ForeignKey(CarMake, on_delete=models.CASCADE)
+    dealer_id = models.IntegerField(null=False)
+    name = models.CharField(null=False, max_length=20, primary_key=True)
+    SUV = 'suv'
+    SEDAN = 'sedan'
+    WAGON = 'wagon'
+    JEEP = 'jeep'
+    TYPE_CHOICES = [
+        (SUV, 'SUV'),
+        (SEDAN, 'Sedan'),
+        (WAGON, 'Wagon'),
+        (JEEP, 'Jeep')
+    ]
+    model_type = models.CharField(max_length=5, choices=TYPE_CHOICES)
+    year = models.IntegerField(default=datetime.date.today().year) 
+
+    def __str__(self):
+        return  "Make: " + self.make.name + "," \
+                "Name: " + self.name + "," \
+                "Year: " + str(self.year) + "," \
+                "Type: " + self.model_type + "," \
+                "Dealer ID: " + str(self.dealer_id)
 
 # <HINT> Create a plain Python class `CarDealer` to hold dealer data
-
+class CarDealer:
+    def __init__(self, address, city, full_name, id, lat, long, short_name, st, zip):
+        self.address = address
+        self.city = city
+        self.full_name = full_name
+        self.id = id
+        self.lat = lat
+        self.long = long
+        self.short_name = short_name
+        self.st = st
+        self.zip = zip
+
+    def __str__(self):
+        return "Dealer name: " + self.full_name
 
 # <HINT> Create a plain Python class `DealerReview` to hold review data
+class DealerReview:
+
+    def __init__(self, dealership, name, purchase, review):
+        # Required attributes
+        self.dealership = dealership
+        self.name = name
+        self.purchase = purchase
+        self.review = review
+        # Optional attributes
+        self.purchase_date = ""
+        self.purchase_make = ""
+        self.purchase_model = ""
+        self.purchase_year = ""
+        self.sentiment = ""
+        self.id = ""
+
+    def __str__(self):
+        return "Review: " + self.review
+
+    def to_json(self):
+        return json.dumps(self, default=lambda o: o.__dict__,
+                            sort_keys=True, indent=4)

server/djangoapp/restapis.py

@@ -1,34 +1,140 @@
 import requests
 import json
-# import related models here
+from .models import CarDealer, DealerReview
 from requests.auth import HTTPBasicAuth
+from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
+from ibm_watson import NaturalLanguageUnderstandingV1
+from ibm_watson.natural_language_understanding_v1 import Features,SentimentOptions
+import time
+
 
+def analyze_review_sentiments(text):
+    url = "https://api.us-south.natural-language-understanding.watson.cloud.ibm.com/instances/e0644675-9fce-4a74-aee4-2fc8f745c9ab"
+    api_key = "ews5G2Jj09NPpW2jSZ6_pxcJqeJnvofrNhOzVJbJ07X1"
+    authenticator = IAMAuthenticator(api_key)
+    natural_language_understanding = NaturalLanguageUnderstandingV1(version='2021-08-01',authenticator=authenticator)
+    natural_language_understanding.set_service_url(url)
+    response = natural_language_understanding.analyze( text=text+"hello hello hello",features=Features(sentiment=SentimentOptions(targets=[text+"hello hello hello"]))).get_result()
+    label=json.dumps(response, indent=2)
+    label = response['sentiment']['document']['label']
+
+
+    return(label)
 
-# Create a `get_request` to make HTTP GET requests
-# e.g., response = requests.get(url, params=params, headers={'Content-Type': 'application/json'},
-#                                     auth=HTTPBasicAuth('apikey', api_key))
 
+def get_dealers_from_cf(url, **kwargs):
+    results = []
+    # Call get_request with a URL parameter
+    json_result = get_request(url)
+    if json_result:
+        # Get the row list in JSON as dealers
+        dealers=json_result      
+        # For each dealer object
+        for dealer in dealers:
+            # Get its content in `doc` object
+            dealer_doc = dealer["doc"]
+            # Create a CarDealer object with values in `doc` object
+            dealer_obj = CarDealer(address=dealer_doc["address"], city=dealer_doc["city"], full_name=dealer_doc["full_name"],
+                                   id=dealer_doc["id"], lat=dealer_doc["lat"], long=dealer_doc["long"],
+                                   short_name=dealer_doc["short_name"],
+                                   st=dealer_doc["st"], zip=dealer_doc["zip"])
+            results.append(dealer_obj)
 
-# Create a `post_request` to make HTTP POST requests
-# e.g., response = requests.post(url, params=kwargs, json=payload)
+    return results
 
 
-# Create a get_dealers_from_cf method to get dealers from a cloud function
-# def get_dealers_from_cf(url, **kwargs):
-# - Call get_request() with specified arguments
-# - Parse JSON results into a CarDealer object list
+def get_dealer_by_id_from_cf(url, id):
+    json_result = get_request(url, id=id)
+    print(json_result)
 
+    if json_result:
+        dealers = json_result
+
+
+        dealer_doc = dealers[0]
+        dealer_obj = CarDealer(
+            address=dealer_doc["address"], 
+            city=dealer_doc["city"],
+            id=dealer_doc["id"],
+            lat=dealer_doc["lat"],
+            long=dealer_doc["long"],
+            full_name=dealer_doc["full_name"],
+            st=dealer_doc["st"],
+            zip=dealer_doc["zip"],
+            short_name=dealer_doc["short_name"])
+    return dealer_obj
 
-# Create a get_dealer_reviews_from_cf method to get reviews by dealer id from a cloud function
-# def get_dealer_by_id_from_cf(url, dealerId):
-# - Call get_request() with specified arguments
-# - Parse JSON results into a DealerView object list
 
+def get_dealer_reviews_from_cf(url, **kwargs):
+    results = []
+    id = kwargs.get("id")
+    if id:
+        json_result = get_request(url, id=id)
+    else:
+        json_result = get_request(url)
+
+    if json_result:
+        reviews = json_result["data"]["docs"]
+        for dealer_review in reviews:
+            review_obj = DealerReview(dealership=dealer_review["dealership"],
+                                   name=dealer_review["name"],
+                                   purchase=dealer_review["purchase"],
+                                   review=dealer_review["review"])
+            if "id" in dealer_review:
+                review_obj.id = dealer_review["id"]
+            if "purchase_date" in dealer_review:
+                review_obj.purchase_date = dealer_review["purchase_date"]
+            if "car_make" in dealer_review:
+                review_obj.car_make = dealer_review["car_make"]
+            if "car_model" in dealer_review:
+                review_obj.car_model = dealer_review["car_model"]
+            if "car_year" in dealer_review:
+                review_obj.car_year = dealer_review["car_year"]
+
+            sentiment = analyze_review_sentiments(review_obj.review)
+            print(sentiment)
+            review_obj.sentiment = sentiment
+            results.append(review_obj)
 
-# Create an `analyze_review_sentiments` method to call Watson NLU and analyze text
-# def analyze_review_sentiments(text):
-# - Call get_request() with specified arguments
-# - Get the returned sentiment label such as Positive or Negative
+    return results
+
+def get_request(url, **kwargs):
+
+    # If argument contain API KEY
+    api_key = kwargs.get("api_key")
+    print("GET from {} ".format(url))
+    try:
+        if api_key:
+            params = dict()
+            params["text"] = kwargs["text"]
+            params["version"] = kwargs["version"]
+            params["features"] = kwargs["features"]
+            params["return_analyzed_text"] = kwargs["return_analyzed_text"]
+            response = requests.get(url, params=params, headers={'Content-Type': 'application/json'},
+                                    auth=HTTPBasicAuth('apikey', api_key))
+        else:
+            # Call get method of requests library with URL and parameters
+            response = requests.get(url, headers={'Content-Type': 'application/json'},
+                                    params=kwargs)
+    except:
+        # If any error occurs
+        print("Network exception occurred")
+
+    status_code = response.status_code
+    print("With status {} ".format(status_code))
+    json_data = json.loads(response.text)
+    return json_data
+
+
+def post_request(url, payload, **kwargs):
+    print(kwargs)
+    print("POST to {} ".format(url))
+    print(payload)
+    response = requests.post(url, params=kwargs, json=payload)
+    status_code = response.status_code
+    print("With status {} ".format(status_code))
+    json_data = json.loads(response.text)
+    return json_data