25/06/2020

Training_Data/OverfittingUnderfitting.py

-import numpy as np
-import matplotlib.pyplot as plt
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import PolynomialFeatures
-from sklearn.linear_model import LinearRegression
-from sklearn.model_selection import cross_val_score
-
-
-def true_fun(X):
-    return np.cos(1.5 * np.pi * X)
-
-np.random.seed(0)
-
-n_samples = 30
-
-
-degrees = [2, 5, 16]
-
-X = np.sort(np.random.rand(n_samples))
-y = true_fun(X) + np.random.randn(n_samples) * 0.1
-
-plt.figure(figsize=(14, 5))
-for i in range(len(degrees)):
-    ax = plt.subplot(1, len(degrees), i + 1)
-    plt.setp(ax, xticks=(), yticks=())
-
-    polynomial_features = PolynomialFeatures(degree=degrees[i],
-                                             include_bias=False)
-    linear_regression = LinearRegression()
-    pipeline = Pipeline([("polynomial_features", polynomial_features),
-                         ("linear_regression", linear_regression)])
-    pipeline.fit(X[:, np.newaxis], y)
-
-    # Evaluate the models using crossvalidation
-    scores = cross_val_score(pipeline, X[:, np.newaxis], y,
-                             scoring="neg_mean_squared_error", cv=10)
-
-    X_test = np.linspace(0, 1, 100)
-    plt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label="Model")
-    plt.plot(X_test, true_fun(X_test), label="True function")
-    plt.scatter(X, y, edgecolor='b', s=20, label="Samples")
-    plt.xlabel("x")
-    plt.ylabel("y")
-    plt.xlim((0, 1))
-    plt.ylim((-2, 2))
-    plt.legend(loc="best")
-    plt.title("Degree {}\nMSE = {:.2e}(+/- {:.2e})".format(
-        degrees[i], -scores.mean(), scores.std()))
-plt.show()
-
-
-

Training_Data/RunRestWalkClassification.py

-import matplotlib.pyplot as plt
-import seaborn as sns 
-import numpy as np
-import pandas as pd
-from accuracies import results
-from accuracies import print_results
-from OverfittingUnderfitting import true_fun
-
-
-data = pd.read_csv('ModelData.csv', encoding='utf-8')
-data.isnull().sum()
-
-true_fun(data);
-
-#Activity Counts
-data.MeanActivity.value_counts()
-
-rest = data[data.MeanActivity == 0]
-walk = data[data.MeanActivity == 1]
-run = data[data.MeanActivity == 2]
-
-plt.bar(0, height=[rest.MeanActivity.count()])
-plt.bar(1, height=[walk.MeanActivity.count()])
-plt.bar(2, height=[run.MeanActivity.count()])
-
-plt.xticks(np.arange(3), ['rest', 'walk','run'])
-plt.show()
-
-
-#Feature Vectors
-features = ['Xmin', 'Ymin', 'Zmin','Xmax','Ymax','Zmax','Xmean','Ymean','Zmean','Xmedian' ,'Ymedian','Zmedian', 'Xvariance', 'Yvariance', 'Zvariance', 'Xstd', 'Ystd', 'Zstd', 'Xrms', 'Yrms', 'Zrms', 'Xenergy', 'Yenergy', 'Zenergy', 'MaxMagnitude']
-    
-plot_data_size = 20
-rest_plot = rest.head(plot_data_size)
-walk_plot = walk.head(plot_data_size)
-run_plot = run.head(plot_data_size)
-
-
-#fig, axes = plt.subplots(9, 3, figsize=(16, 16))
-#for i, ax in enumerate(axes.flatten()[:25]):
-#    c = features[i]
-#    ax.plot(range(0, plot_data_size), rest_plot[c], label="Rest")
-#    ax.plot(range(0, plot_data_size), run_plot[c], label="Run")
-#    ax.plot(range(0, plot_data_size), walk_plot[c], label="Walk")
-#    ax.set_ylabel(c)
-#    ax.legend()
-
-
-#Rest,Run And Walk Patterns
-    
-#fig, axes = plt.subplots(9, 3, figsize=(16, 16))
-#for i, ax in enumerate(axes.flatten()[:25]):
-#    c = features[i]
-#    sns.distplot(rest[c], ax=ax, label='Rest')
-#    sns.distplot(run[c], ax=ax, label='Run')
-#    sns.distplot(walk[c], ax=ax, label='Walk')
-#    ax.legend()
-
-
-#Train a Model
-    
-X = data[:]
-y = X.pop("MeanActivity")
-
-#X = data.iloc[:,0:25].values
-#y = data.iloc[:,25].values
-
-print_results(X, y)
-#results(X,y)
-
-
-
-
-

WalkingPatternRecognition/.idea/misc.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
+    <option name="languageLevel" value="JSX" />
   </component>
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7" project-jdk-type="Python SDK" />
 </project>
\ No newline at end of file

WalkingPatternRecognition/.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/python-getting-started" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

WalkingPatternRecognition/.idea/workspace.xml

@@ -7,6 +7,9 @@
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
     <option name="LAST_RESOLUTION" value="IGNORE" />
   </component>
+  <component name="DjangoConsoleOptions" custom-start-script="import sys; print('Python %s on %s' % (sys.version, sys.platform))&#10;import django; print('Django %s' % django.get_version())&#10;sys.path.extend([WORKING_DIR_AND_PYTHON_PATHS])&#10;if 'setup' in dir(django): django.setup()&#10;import django_manage_shell; django_manage_shell.run(PROJECT_ROOT)">
+    <option name="myCustomStartScript" value="import sys; print('Python %s on %s' % (sys.version, sys.platform))&#10;import django; print('Django %s' % django.get_version())&#10;sys.path.extend([WORKING_DIR_AND_PYTHON_PATHS])&#10;if 'setup' in dir(django): django.setup()&#10;import django_manage_shell; django_manage_shell.run(PROJECT_ROOT)" />
+  </component>
   <component name="FileTemplateManagerImpl">
     <option name="RECENT_TEMPLATES">
       <list>
@@ -14,7 +17,12 @@
       </list>
     </option>
   </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/python-getting-started" />
+  </component>
+  <component name="JupyterTrust" id="2d1e7fc0-f051-488f-b26c-f3b7be8c0836" />
   <component name="ProjectId" id="1bgCm5DFdWgxgd5CZJV4fw4UhEH" />
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
   <component name="ProjectViewState">
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showExcludedFiles" value="true" />
@@ -30,6 +38,7 @@
     <property name="node.js.path.for.package.tslint" value="project" />
     <property name="node.js.selected.package.eslint" value="(autodetect)" />
     <property name="node.js.selected.package.tslint" value="(autodetect)" />
+    <property name="settings.editor.selected.configurable" value="preferences.lookFeel" />
   </component>
   <component name="RunManager">
     <configuration name="WalkingPatternRecognition" type="Python.DjangoServer" factoryName="Django server">
@@ -83,6 +92,10 @@
       <workItem from="1589375663029" duration="4084000" />
       <workItem from="1589385233042" duration="3295000" />
       <workItem from="1589396394075" duration="1696000" />
+      <workItem from="1590081950078" duration="20751000" />
+      <workItem from="1592913871108" duration="42000" />
+      <workItem from="1592914317572" duration="2313000" />
+      <workItem from="1592973208713" duration="14819000" />
     </task>
     <servers />
   </component>
@@ -90,9 +103,18 @@
     <option name="version" value="1" />
   </component>
   <component name="WindowStateProjectService">
-    <state x="477" y="241" key="com.intellij.ide.util.TipDialog" timestamp="1589396394538">
+    <state x="549" y="171" key="FileChooserDialogImpl" timestamp="1590316992326">
       <screen x="0" y="0" width="1536" height="824" />
     </state>
-    <state x="477" y="241" key="com.intellij.ide.util.TipDialog/0.0.1536.824@0.0.1536.824" timestamp="1589396394538" />
+    <state x="549" y="171" key="FileChooserDialogImpl/0.0.1536.824@0.0.1536.824" timestamp="1590316992326" />
+    <state x="2383" y="166" key="SettingsEditor" timestamp="1592973231446">
+      <screen x="1920" y="0" width="1920" height="1040" />
+    </state>
+    <state x="2383" y="166" key="SettingsEditor/0.0.1536.824/1920.0.1920.1040@1920.0.1920.1040" timestamp="1592973231446" />
+    <state x="2516" y="304" key="com.intellij.ide.util.TipDialog" timestamp="1593057263416">
+      <screen x="1920" y="0" width="1920" height="1040" />
+    </state>
+    <state x="2516" y="304" key="com.intellij.ide.util.TipDialog/0.0.1536.824/1920.0.1920.1040@1920.0.1920.1040" timestamp="1593057263416" />
+    <state x="477" y="241" key="com.intellij.ide.util.TipDialog/0.0.1536.824@0.0.1536.824" timestamp="1590081950861" />
   </component>
 </project>
\ No newline at end of file

Training_Data/Data.py → WalkingPatternRecognition/TrainingAndTestingData/Data.py

 from csv import writer
 import pandas as pd
-from datetime import datetime
 
 class Data:
     data = '';

WalkingPatternRecognition/TrainingAndTestingData/DogData.csv

+StartTime,EndTime,Date,Activity
+2016-02-22 14:59:44.561776,2016-02-22 14:59:44.561805,2016-02-22 14:59:44.561805,run

WalkingPatternRecognition/TrainingAndTestingData/Example.csv

+timestamp,accelerometer_X,accelerometer_Y,accelerometer_Z
+2016-02-22 14:59:44.561776,0.612916,-10.400413,0.095768
+2016-02-22 14:59:44.561777,6.421249,29.022512,8.8777
+2016-02-22 14:59:44.561778,5.214572,20.910957,8.30788
+2016-02-22 14:59:44.561779,0.565032,-9.792285,-0.325611
+2016-02-22 14:59:44.561780,-2.738967,4.458004,8.255207
+2016-02-22 14:59:44.561781,-2.585738,7.244855,0.521936
+2016-02-22 14:59:44.561782,-2.140416,-19.938911,-2.284068
+2016-02-22 14:59:44.561783,30.119057,23.142353,-16.376339
+2016-02-22 14:59:44.561784,-4.165911,7.268797,2.226608
+2016-02-22 14:59:44.561785,-1.522712,-15.916653,1.92015
+2016-02-22 14:59:44.561786,12.909535,28.543673,0.354342
+2016-02-22 14:59:44.561787,-0.11971,16.591818,-0.071826
+2016-02-22 14:59:44.561788,4.644751,-16.098612,-2.715025
+2016-02-22 14:59:44.561789,5.736508,13.55597,7.354988
+2016-02-22 14:59:44.561790,-8.00621,5.315128,2.284068
+2016-02-22 14:59:44.561791,7.886501,-12.397177,1.120486
+2016-02-22 14:59:44.561792,30.674513,24.890121,-4.079719
+2016-02-22 14:59:44.561793,1.187524,13.072341,-1.953669
+2016-02-22 14:59:44.561794,1.44131,-14.585477,3.610456
+2016-02-22 14:59:44.561795,6.0286,17.889475,-0.732626
+2016-02-22 14:59:44.561796,15.35641,25.665842,-2.499546
+2016-02-22 14:59:44.561797,0.550666,-3.926491,0.895431
+2016-02-22 14:59:44.561798,-3.246537,8.75799,-3.605668
+2016-02-22 14:59:44.561799,-1.345541,5.391742,-1.359906
+2016-02-22 14:59:44.561800,17.860744,-3.758896,-3.394978
+2016-02-22 14:59:44.561801,18.689138,22.256498,-1.335964
+2016-02-22 14:59:44.561802,-0.143652,8.240842,-0.703895
+2016-02-22 14:59:44.561803,0.80924,-20.618866,-1.489193
+2016-02-22 14:59:44.561804,15.629349,29.8126,2.30801
+2016-02-22 14:59:44.561805,15.528792,30.004135,10.548853

Training_Data/FeatureExtraction.py → WalkingPatternRecognition/TrainingAndTestingData/FeatureExtraction.py

@@ -65,13 +65,14 @@ class FeatureExtraction:
                 num = i       
         return num 
     
+    
     def getFeatureSingle(self,list):  
         d= gd.GetData(list)          
         
         X= d.getX(list)
         Y= d.getY(list)
         Z=d.getZ(list)
-        Magnitudes=d.getMagnitude(list)
+        Magnitudes=d.getMagnitude(list)        
         Activities= d.getActivities(list)
    
         fe = FeatureExtraction(list);
@@ -106,6 +107,50 @@ class FeatureExtraction:
 
         print("Feature Vector \n" ,feature , "\n\n");
         return feature;
+    
+    
+    
+    def getTestFeatureSingle(self,list):  
+        d= gd.GetData(list)          
+        
+        X= d.getX(list)
+        Y= d.getY(list)
+        Z=d.getZ(list)
+        Magnitudes=d.getMagnitude(list)        
+        Times= d.getStartAndEndTime(list)
+        fe = FeatureExtraction(list);
+
+        feature=[];   
+        feature.append(fe.MinimumPeak(X))
+        feature.append(fe.MinimumPeak(Y));
+        feature.append(fe.MinimumPeak(Z));
+        feature.append(fe.MaximumPeak(X));
+        feature.append(fe.MaximumPeak(Y));
+        feature.append(fe.MaximumPeak(Z));
+        feature.append(fe.Mean(X));
+        feature.append(fe.Mean(Y));
+        feature.append(fe.Mean(Z));
+        feature.append(fe.median(X));
+        feature.append(fe.median(Y));
+        feature.append(fe.median(Z));
+        feature.append(fe.Variance(X));
+        feature.append(fe.Variance(Y));
+        feature.append(fe.Variance(Z));
+        feature.append(fe.StandardDeviation(X));
+        feature.append(fe.StandardDeviation(Y));
+        feature.append(fe.StandardDeviation(Z));
+        feature.append(fe.RMS(X));
+        feature.append(fe.RMS(Y));
+        feature.append(fe.RMS(Z));
+        feature.append(fe.Energy(X));
+        feature.append(fe.Energy(Y));
+        feature.append(fe.Energy(Z));
+        feature.append(fe.Mean(Magnitudes));
+        feature.append(Times[0])
+        feature.append(Times[-1])
+
+        print("Feature Vector \n" ,feature , "\n\n");
+        return feature;
         
 
 

Training_Data/GetData.py → WalkingPatternRecognition/TrainingAndTestingData/GetData.py

-from datetime import datetime
-
 class GetData:
     data =[];
     
@@ -10,31 +8,40 @@ class GetData:
         X=[]
         for i, row in data.iterrows():   
              X.append(float(data.xs(i)['accelerometer_X']))
-        return X;
+        return X
    
     def getY(self,data):
         Y=[]
         for i, row in data.iterrows():    
              Y.append(float(data.xs(i)['accelerometer_Y']))
-        return Y;
+        return Y
     
     def getZ(self,data):
         Z=[]
         for i, row in data.iterrows():    
              Z.append(float(data.xs(i)['accelerometer_Z']))
-        return Z;             
+        return Z       
     
     def getMagnitude(self,data):
         Magnitudes=[];
         for i, row in data.iterrows():    
             Magnitude= ((float(data.xs(i)['accelerometer_X']))**2 + (float(data.xs(i)['accelerometer_Y']))**2 + (float(data.xs(i)['accelerometer_Z']))**2) ** 0.5;
             Magnitudes.append(Magnitude);
-        return Magnitudes;
+        return Magnitudes
    
     def getActivities(self,data):
         Activities=[];
         for i, row in data.iterrows(): 
             Activities.append(data.xs(i)['activity']);
-        return Activities;
+        return Activities
+    
     
+    def getStartAndEndTime(self,data):
+        Times= [];
+        StartTime=data['timestamp'].iloc[0];
+        Times.append(StartTime)
+        EndTime= data['timestamp'].iloc[-1];
+        Times.append(EndTime)
+        return Times
+
    
\ No newline at end of file

Training_Data/Main.py → WalkingPatternRecognition/TrainingAndTestingData/Main.py

+# In this file , the data is obtained from a csv to create the feature vector, send that to a trained model,
+# predict the activity and then transfer the dog details to a csv to be sent to the database
+
 import Data as Data
 import GetData as getdata
 import FeatureExtraction as fe
+import Test as Test
+import ReadData as ReadData
 
-d= Data.Data('MergedRunningData.csv')
-data= d.ReadData()
+#import warnings
+#warnings.filterwarnings("ignore")
 
+d= Data.Data('Example.csv')
+data= d.ReadData()
 i,j=0,0;
-
 length = len(data);
 
 while(i<= length):
@@ -20,9 +26,28 @@ while(i<= length):
     dataset = data.iloc[fIndex: lIndex+1]
     gd1=getdata.GetData(dataset)
     f= fe.FeatureExtraction(gd1)
-    FeatureVector =  f.getFeatureSingle(dataset)
-    d.append_list_as_row('FeatureVectors.csv', FeatureVector);
+    
+    if('activity' in data.columns):
+        print("For Training ")
+        FeatureVector =  f.getFeatureSingle(dataset)
+        d.append_list_as_row('FeatureVector.csv', FeatureVector);
+    else:
+        FeatureVector =  f.getTestFeatureSingle(dataset)
+        d.append_list_as_row('Test.csv', FeatureVector);
+        r = Data.Data('Test.csv')
+        predictingActivity = r.ReadData()
+        predictedActivity = Test.Test(predictingActivity)
+        d1= Data.Data('DogData.csv') 
+        data1= d1.ReadData()
+        activityCountData= ReadData.ReadData(data1)
+    
     i=i+30;
+    
+
+    
+
+
+
 
  
 

WalkingPatternRecognition/TrainingAndTestingData/ReadData.py

+#This class reads the data for rest , run and walk respectively and calculates the number of minutes of each.
+
+class ReadData:    
+     data = '';           
+         
+     def __init__(self,data):
+        self.data= data
+       
+        restData = data.apply(lambda x: True if x['Activity'] == 'rest' else False , axis=1)
+        numOfRestRows = len(restData[restData == True].index)
+        
+        walkData = data.apply(lambda x: True if x['Activity'] == 'walk' else False , axis=1)
+        numOfWalkRows = len(walkData[walkData == True].index)
+        
+        runData = data.apply(lambda x: True if x['Activity'] == 'run' else False , axis=1)
+        numOfRunRows = len(runData[runData == True].index)
+        
+        print("Resting Minutes: ",numOfRestRows)
+        print("Walking Minutes: ",numOfWalkRows)
+        print("Running Minutes: ",numOfRunRows)
+
+        
\ No newline at end of file

WalkingPatternRecognition/TrainingAndTestingData/Test.csv

+Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,Xmean,Ymean,Zmean,Xmedian,Ymedian,Zmedian,Xvariance,Yvariance,Zvariance,Xstd,Ystd,Zstd,Xrms,Yrms,Zrms,Xenergy,Yenergy,Zenergy,MaxMagnitude,StartTime,EndTime
+-8.006210000000001,-20.618866,-16.376339,30.674513,30.004134999999998,10.548853,5.7283671,7.1533957333333325,0.5251283333333334,1.3144170000000002,7.7548195,0.011970999999999996,92.04525690845622,262.324475973493,24.892536674532625,9.594021936000367,16.196434051157464,4.9892420941995415,61.20280546040809,96.97869041565232,27.47815301707999,171.851013000000,241.763736102284,46.7146199111146,18.88841309892816,2016-02-22 14:59:44.561776,2016-02-22 14:59:44.561805

WalkingPatternRecognition/TrainingAndTestingData/Test.py

+#This file reads the feature vector predicts the Activity and writes it to a file DogData.csv
+
+import joblib
+import Data as Data
+
+class Test:    
+     data = '';           
+         
+     def __init__(self,data):
+        self.data= data
+        
+        Times= data.loc[:,['StartTime','EndTime']]
+        data = data.drop(['StartTime','EndTime'],axis=1)        
+        X_test = data[:]
+
+        StartTime=Times.xs(0)['StartTime']
+        EndTime=Times.xs(0)['EndTime']
+        Date=Times.xs(0)['EndTime']
+
+        ActivityArray=[];       
+
+        # load the Gaussian Bayes Model from disk
+        filename= 'Gaussian_model.sav'
+        Gaussian_model = joblib.load(filename)
+        
+        prediction = Gaussian_model.predict(X_test)
+        
+        if(prediction[0]== 0):
+            activity ='rest'
+        if(prediction[0]== 1):
+            activity ='walk'
+        if(prediction[0]== 2):
+            activity ='run'
+            
+        print("PREDICTION ---->",activity)
+
+        ActivityArray.append(StartTime)
+        ActivityArray.append(EndTime)
+        ActivityArray.append(Date)
+        ActivityArray.append(activity)
+
+        d= Data.Data(ActivityArray)
+        d.append_list_as_row('DogData.csv', ActivityArray)

WalkingPatternRecognition/WalkingPatternRecognition/settings.py

@@ -38,8 +38,16 @@ INSTALLED_APPS = [
     'django.contrib.messages',
     'django.contrib.staticfiles',
     'rest_framework',
-    'mobileapp'
+    'mobileapp',
+    'rest_framework.authtoken',
+    'rest_auth',
+    'django.contrib.sites',
+    'allauth',
+    'allauth.account',
+    'rest_auth.registration',
 ]
+EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
+SITE_ID = 1
 
 MIDDLEWARE = [
     'django.middleware.security.SecurityMiddleware',
@@ -56,7 +64,9 @@ ROOT_URLCONF = 'WalkingPatternRecognition.urls'
 TEMPLATES = [
     {
         'BACKEND': 'django.template.backends.django.DjangoTemplates',
-        'DIRS': [],
+        'DIRS': [
+            os.path.join(BASE_DIR, 'reactapp/build')
+        ],
         'APP_DIRS': True,
         'OPTIONS': {
             'context_processors': [
@@ -85,6 +95,20 @@ DATABASES = {
     }
 }
 
+REST_FRAMEWORK = {
+    # Authentication Scheme
+    'DEFAULT_AUTHENTICATION_CLASSES': (
+        'rest_framework.authentication.BasicAuthentication',
+        'rest_framework.authentication.SessionAuthentication',
+        'rest_framework.authentication.TokenAuthentication',
+    ),
+    # Permission Policies
+    'DEFAULT_PERMISSION_CLASSES': [
+        'rest_framework.permissions.IsAuthenticated',
+    ]
+}
+
+
 
 # Password validation
 # https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
@@ -124,5 +148,8 @@ USE_TZ = True
 
 STATIC_URL = '/static/'
 
+STATICFILES_DIRS = [
+    os.path.join(BASE_DIR, 'reactapp/build/static')
+]
 # 'ENGINE': 'django.db.backends.sqlite3',
 # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
\ No newline at end of file

WalkingPatternRecognition/WalkingPatternRecognition/urls.py

@@ -14,13 +14,12 @@ Including another URLconf
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
 from django.contrib import admin
-from django.urls import path
-from rest_framework.urlpatterns import format_suffix_patterns
-from mobileapp import  views
+from django.urls import path, include
+from rest_framework.authtoken import views
 
 urlpatterns = [
-    path('', admin.site.urls),
-    path('dogs/', views.dogList.as_view()),
-    path('activities/', views.motionActivityList.as_view()),
-    path('activitiesPerDay/', views.motionActivityPerDayList.as_view()),
+    path('admin/', admin.site.urls),
+    path('api-token-auth/', views.obtain_auth_token, name='api-token-auth'),
+    path('api/', include('mobileapp.urls', namespace='api')),
+
 ]

WalkingPatternRecognition/mobileapp/admin.py

@@ -9,4 +9,3 @@ admin.site.register(Dog)
 admin.site.register(MotionActivity)
 admin.site.register(MotionActivityPerDay)
 
-

WalkingPatternRecognition/mobileapp/migrations/0004_auto_20200522_0000.py

+# Generated by Django 2.2.12 on 2020-05-21 18:30
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0003_auto_20200513_0029'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='dog',
+            name='created_date',
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+        migrations.AlterField(
+            model_name='dog',
+            name='name',
+            field=models.CharField(max_length=50),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='dog_id',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mobileapp.Dog'),
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0005_author_book.py

+# Generated by Django 2.2.12 on 2020-05-22 14:34
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0004_auto_20200522_0000'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Author',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=200)),
+                ('created_date', models.DateTimeField(default=django.utils.timezone.now)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Book',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('description', models.CharField(max_length=300)),
+                ('created_date', models.DateTimeField(default=django.utils.timezone.now)),
+                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mobileapp.Author')),
+            ],
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0006_auto_20200522_2208.py

+# Generated by Django 2.2.12 on 2020-05-22 16:38
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0005_author_book'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='book',
+            name='author',
+        ),
+        migrations.DeleteModel(
+            name='Author',
+        ),
+        migrations.DeleteModel(
+            name='Book',
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0007_author_book.py

+# Generated by Django 2.2.12 on 2020-05-22 16:39
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('mobileapp', '0006_auto_20200522_2208'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Author',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=200)),
+                ('created_date', models.DateTimeField(default=django.utils.timezone.now)),
+                ('added_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Book',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('description', models.CharField(max_length=300)),
+                ('created_date', models.DateTimeField(default=django.utils.timezone.now)),
+                ('added_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='mobileapp.Author')),
+            ],
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0008_remove_dog_dog_id.py

+# Generated by Django 2.2.12 on 2020-05-22 17:17
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0007_author_book'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='dog',
+            name='dog_id',
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0009_auto_20200623_1749.py

+# Generated by Django 2.2.12 on 2020-06-23 12:19
+
+import datetime
+from django.db import migrations, models
+from django.utils.timezone import utc
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0008_remove_dog_dog_id'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='book',
+            name='added_by',
+        ),
+        migrations.RemoveField(
+            model_name='book',
+            name='author',
+        ),
+        migrations.RemoveField(
+            model_name='motionactivity',
+            name='endTime',
+        ),
+        migrations.RemoveField(
+            model_name='motionactivity',
+            name='startTime',
+        ),
+        migrations.AddField(
+            model_name='motionactivity',
+            name='time',
+            field=models.TimeField(default=datetime.datetime(2020, 6, 23, 12, 19, 43, 658313, tzinfo=utc)),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='activity',
+            field=models.CharField(max_length=50),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='date',
+            field=models.DateField(default=datetime.datetime(2020, 6, 23, 12, 19, 43, 658313, tzinfo=utc)),
+        ),
+        migrations.DeleteModel(
+            name='Author',
+        ),
+        migrations.DeleteModel(
+            name='Book',
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0010_auto_20200623_1802.py

+# Generated by Django 2.2.12 on 2020-06-23 12:32
+
+import datetime
+from django.db import migrations, models
+from django.utils.timezone import utc
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0009_auto_20200623_1749'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='date',
+            field=models.DateField(default=datetime.datetime(2020, 6, 23, 12, 32, 18, 933586, tzinfo=utc)),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='time',
+            field=models.TimeField(default=datetime.datetime(2020, 6, 23, 12, 32, 18, 933586, tzinfo=utc)),
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0011_auto_20200623_1802.py

+# Generated by Django 2.2.12 on 2020-06-23 12:32
+
+import datetime
+from django.db import migrations, models
+from django.utils.timezone import utc
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0010_auto_20200623_1802'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='date',
+            field=models.DateField(default=datetime.datetime(2020, 6, 23, 12, 32, 48, 534727, tzinfo=utc)),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='time',
+            field=models.TimeField(default=datetime.datetime(2020, 6, 23, 12, 32, 48, 534727, tzinfo=utc)),
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0012_auto_20200623_1803.py

+# Generated by Django 2.2.12 on 2020-06-23 12:33
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0011_auto_20200623_1802'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='motionactivity',
+            name='date',
+        ),
+        migrations.RemoveField(
+            model_name='motionactivity',
+            name='time',
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0013_auto_20200624_1515.py

+# Generated by Django 2.2.12 on 2020-06-24 09:45
+
+import datetime
+from django.db import migrations, models
+from django.utils.timezone import utc
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0012_auto_20200623_1803'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='motionactivity',
+            name='date',
+            field=models.DateField(default=datetime.datetime(2020, 6, 24, 9, 45, 24, 951328, tzinfo=utc)),
+        ),
+        migrations.AddField(
+            model_name='motionactivity',
+            name='time',
+            field=models.TimeField(default=datetime.datetime(2020, 6, 24, 9, 45, 24, 951328, tzinfo=utc)),
+        ),
+    ]

WalkingPatternRecognition/mobileapp/migrations/0014_auto_20200624_1541.py

+# Generated by Django 2.2.12 on 2020-06-24 10:11
+
+from django.db import migrations, models
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mobileapp', '0013_auto_20200624_1515'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='motionactivity',
+            old_name='dog_id',
+            new_name='dog',
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='date',
+            field=models.DateField(default=django.utils.timezone.now),
+        ),
+        migrations.AlterField(
+            model_name='motionactivity',
+            name='time',
+            field=models.TimeField(default=django.utils.timezone.now),
+        ),
+        migrations.AlterField(
+            model_name='motionactivityperday',
+            name='date',
+            field=models.DateField(default=django.utils.timezone.now),
+        ),
+    ]

WalkingPatternRecognition/mobileapp/models.py

+import django
 from django.db import models
+from django.utils import timezone
+from django.conf import settings
+
 
 class Dog(models.Model):
-    dog_id=models.IntegerField()
-    name = models.CharField(max_length=10)
-    age=models.IntegerField()
-    breed= models.CharField(max_length=10)
+    name = models.CharField(max_length=50)
+    age = models.IntegerField()
+    breed = models.CharField(max_length=10)
+    created_date = models.DateTimeField(default=timezone.now)
 
     def __str__(self):
         return self.name
 
 
 class MotionActivity(models.Model):
-    dog_id=models.IntegerField()
-    date = models.DateField()
-    startTime=models.TimeField()
-    endTime=models.TimeField()
-    activity= models.CharField(max_length=10)
+    dog = models.ForeignKey(Dog, on_delete=models.CASCADE)
+    date = models.DateField(default=django.utils.timezone.now)
+    time = models.TimeField(default=django.utils.timezone.now)
+    activity = models.CharField(max_length=50)
 
     def __str__(self):
-        return str(self.dog_id)
+        return str(self.dog)
+
 
 class MotionActivityPerDay(models.Model):
-    dog_id=models.IntegerField()
-    date = models.DateField()
-    activity= models.CharField(max_length=10)
-    timePeriod=models.IntegerField()
+    dog = models.IntegerField()
+    date = models.DateField(default=django.utils.timezone.now)
+    activity = models.CharField(max_length=10)
+    timePeriod = models.IntegerField()
 
     def __str__(self):
-        return str(self.dog_id)
\ No newline at end of file
+        return str(self.dog)
+
+
+
+
+

WalkingPatternRecognition/mobileapp/serializers.py

-from rest_framework import  serializers
-from .models import Dog
-from .models import MotionActivity
-from .models import MotionActivityPerDay
+from rest_framework import serializers
+from rest_framework.validators import UniqueTogetherValidator
+from django.contrib.auth.models import User
+from .models import Dog, MotionActivity, MotionActivityPerDay
 
 
+class UserSerializer(serializers.ModelSerializer):
 
-class dogSerializer(serializers.ModelSerializer):
+    def create(self, validated_data):
+        user = User.objects.create_user(**validated_data)
+        return user
+
+    class Meta:
+        model = User
+        fields = (
+            'username',
+            'first_name',
+            'last_name',
+            'email',
+            'password',
+        )
+        validators = [
+            UniqueTogetherValidator(
+                queryset=User.objects.all(),
+                fields=['username', 'email']
+            )
+        ]
+
+
+class DogSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Dog
-        fields=('dog_id','name','breed','age')
+        fields = ('id', 'name', 'breed', 'age')
+
 
-class motionActivitySerializer(serializers.ModelSerializer):
+class MotionActivitySerializer(serializers.ModelSerializer):
 
     class Meta:
         model = MotionActivity
-        fields=('dog_id','date','startTime','endTime','activity')
+        fields = ('dog', 'date', 'time', 'activity')
 
 
-class motionActivityPerDaySerializer(serializers.ModelSerializer):
+class MotionActivityPerDaySerializer(serializers.ModelSerializer):
 
     class Meta:
         model = MotionActivityPerDay
-        fields=('dog_id','date','activity','timePeriod')
\ No newline at end of file
+        fields = ('dog', 'date', 'activity', 'timePeriod')
+
+

WalkingPatternRecognition/mobileapp/urls.py

+from django.urls import include, path
+from . import views
+from .views import UserRecordView,add_motion
+
+app_name = 'api'
+urlpatterns = [
+  path('welcome/', views.welcome),
+
+  path('user/', UserRecordView.as_view(), name='users'),
+  path('addMotionActivity', views.add_motion),
+  path('addMotionActivityPerDay', views.add_motionActivityPerDay),
+  path('dogs/', views.DogList.as_view()),
+  path('motionActivity/', views.MotionActivityList.as_view()),
+  path('motionActivityPerDay/', views.MotionActivityPerDayList.as_view()),
+
+]
\ No newline at end of file

WalkingPatternRecognition/mobileapp/views.py

+from django.core.exceptions import ObjectDoesNotExist
 from django.shortcuts import render
-from django.http import HttpResponse
+from django.http import HttpResponse, JsonResponse
 from django.shortcuts import get_object_or_404
+from django.views.decorators.csrf import csrf_exempt
+from rest_framework.decorators import api_view
 from rest_framework.views import APIView
 from rest_framework.response import Response
 from rest_framework import status
+import json
 
-from .models import Dog
-from .models import MotionActivity
-from .models import MotionActivityPerDay
 
-from .serializers import dogSerializer
-from .serializers import motionActivitySerializer
-from .serializers import motionActivityPerDaySerializer
+from .models import Dog, MotionActivity, MotionActivityPerDay
 
-class dogList(APIView):
+from .serializers import DogSerializer, MotionActivitySerializer, MotionActivityPerDaySerializer
+
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated, IsAdminUser
+from django.contrib.auth.models import User
+from .serializers import UserSerializer
+
+
+class UserRecordView(APIView):
+    permission_classes = [IsAdminUser]
+
+    def get(self, format=None):
+        users = User.objects.all()
+        serializer = UserSerializer(users, many=True)
+        return Response(serializer.data)
+
+    def post(self, request):
+        serializer = UserSerializer(data=request.data)
+        if serializer.is_valid(raise_exception=ValueError):
+            serializer.create(validated_data=request.data)
+            return Response(
+                serializer.data,
+                status=status.HTTP_201_CREATED
+            )
+        return Response(
+            {
+                "error": True,
+                "error_msg": serializer.error_messages,
+            },
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+
+@api_view(["GET"])
+@csrf_exempt
+@permission_classes([IsAuthenticated])
+def welcome(request):
+    content = {"message": "Welcome to the Doggy App!"}
+    return JsonResponse(content)
+
+
+class DogList(APIView):
     def get(self, request):
-        dogs= Dog.objects.all()
-        serializer = dogSerializer(dogs, many=True)
+        dogs = Dog.objects.all()
+        serializer = DogSerializer(dogs, many=True)
         return Response(serializer.data)
 
     def post(self):
         pass
 
-class motionActivityList(APIView):
+
+class MotionActivityList(APIView):
     def get(self, request):
-        activities= MotionActivity.objects.all()
-        serializer = motionActivitySerializer(activities, many=True)
+        activities = MotionActivity.objects.all()
+        serializer = MotionActivitySerializer(activities, many=True)
         return Response(serializer.data)
 
     def post(self):
         pass
 
 
-class motionActivityPerDayList(APIView):
+@api_view(["POST"])
+@csrf_exempt
+# @permission_classes([IsAuthenticated])
+def add_motion(request):
+    payload = json.loads(request.body)
+    try:
+        motion = MotionActivity.objects.create(
+            date=payload["date"],
+            time=payload["time"],
+            activity=payload["activity"],
+            dog=payload["dog"]
+        )
+        serializer = MotionActivitySerializer(motion)
+        return JsonResponse({'motions': serializer.data}, safe=False, status=status.HTTP_201_CREATED)
+    except ObjectDoesNotExist as e:
+        return JsonResponse({'error': str(e)}, safe=False, status=status.HTTP_404_NOT_FOUND)
+    except Exception:
+        return JsonResponse({'error': 'Something terrible went wrong'}, safe=False, status=status.HTTP_500_INTERNAL_SERVER_ERROR)@api_view(["POST"])
+
+
+class MotionActivityPerDayList(APIView):
     def get(self, request):
-        activities= MotionActivityPerDay.objects.all()
-        serializer = motionActivityPerDaySerializer(activities, many=True)
+        activities = MotionActivityPerDay.objects.all()
+        serializer = MotionActivityPerDaySerializer(activities, many=True)
         return Response(serializer.data)
 
     def post(self):
         pass
+
+
+@api_view(["POST"])
+@csrf_exempt
+# @permission_classes([IsAuthenticated])
+def add_motionActivityPerDay(request):
+    payload = json.loads(request.body)
+    try:
+        motion = MotionActivity.objects.create(
+            date=payload["date"],
+            timePeriod=payload["timePeriod"],
+            activity=payload["activity"],
+            dog=payload["dog"]
+        )
+        serializer = MotionActivitySerializer(motion)
+        return JsonResponse({'motions': serializer.data}, safe=False, status=status.HTTP_201_CREATED)
+    except ObjectDoesNotExist as e:
+        return JsonResponse({'error': str(e)}, safe=False, status=status.HTTP_404_NOT_FOUND)
+    except Exception:
+        return JsonResponse({'error': 'Something terrible went wrong'}, safe=False, status=status.HTTP_500_INTERNAL_SERVER_ERROR)@api_view(["POST"])
+
+