PACJPythonbackend/app.py at master · gosso22/PACJPythonbackend · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#!/usr/bin/env python
from flask import Flask, request
from flask_restful import reqparse, abort, Api, Resource
import pickle
from ACJ import ACJ
import json
import os

app = Flask(__name__)
api = Api(app)

#parser = reqparse.RequestParser()
#parser.add_argument('jsonResultData', type=dict)

class Pair(Resource):
    def get(self, course_name):
        with open(course_name+".pkl", "rb") as input_file:
            acj = pickle.load(input_file)

        pair = acj.nextPair()
        with open(course_name+".pkl", 'wb') as output_file:
            pickle.dump(acj, output_file)
        del(acj)
        print(type(pair))

        return pair

class Result(Resource):

    def post(self):
        received_data = request.get_json()
        result_data = json.loads(received_data)
        print("This was received data",result_data)
        for key, value in result_data.items():
            if(key == "pair"):
                pair = result_data[key]
            if(key == "result"):
                resultSent = result_data[key]
            if(key == "reviewer"):
                reviewerName = result_data[key]
            if(key == "time"):
                timeTaken = result_data[key]
            if(key == "courseName"):
                courseName = result_data[key]

        with open(courseName+".pkl", 'rb') as input_file:
            acj = pickle.load(input_file)

        acj.comp(pair, result=resultSent, reviewer=reviewerName , time=timeTaken)
        with open(courseName+".pkl", 'wb') as output_file:
            pickle.dump(acj, output_file)
        acj.JSONLog()
        del(acj)
        results = ("Response received", json.dumps(result_data))

        return True, 201

class ACJObject(Resource):
    def post(self):
        received_info = request.get_json()
        data_for_creating_acj = json.loads(received_info)
        print(data_for_creating_acj)

        for key in data_for_creating_acj:
            if(key == "data"):
                submissions = data_for_creating_acj[key]
            if(key == "maxRounds"):
                maxRounds = data_for_creating_acj[key]
            if(key == "noOfChoices"):
                noOfChoices = data_for_creating_acj[key]
           # if(key == "logPath"):
            #    logPath = data_for_creating_acj[key]
            if(key == "optionNames"):
                optionNames = data_for_creating_acj[key]
            if(key == "courseName"):
                courseName = data_for_creating_acj[key]
                logPath = courseName

        acj = ACJ(submissions, maxRounds, noOfChoices, logPath, optionNames)

        if(os.path.isfile(courseName+".pkl")):
            result = False

        else:
            with open(courseName+".pkl", 'wb') as output_file:
                pickle.dump(acj, output_file)
                os.makedirs(courseName)
                result = True

        del(acj)

        return result, 201

class CurrentACJResult(Resource):
    def get(self, course_name):
        try:
            with open(course_name+".pkl", 'rb') as input_file:
                acj = pickle.load(input_file)
                results = acj.results()[0]
            del(acj)
            resultsDict = {}
            for item in results:
                resultsDict[item[0]] = item[1]
            jsonResults = json.dumps(resultsDict)

            return jsonResults
        except FileNotFoundError:
            return "NotCreated"

class Reviewers(Resource):
    def get(self, course_name):
        try:
            with open(course_name+".pkl", 'rb') as input_file:
                acj = pickle.load(input_file)
            choice = acj.optionNames[0]
            del(acj)
            with open(os.path.join(course_name, "ACJ_"+choice+".json")) as input_file:
                json_result = json.load(input_file)
            reviewers = json.dumps(json_result["Reviewers"])
            return reviewers
        except FileNotFoundError:
            return "NotCreated"

class Decisions(Resource):
    def get(self):
        received_data = request.args.get('data')
        data = json.loads(received_data)
        course_name = data["courseName"]
        reviewer = data["reviewer"]

        with open(course_name+".pkl", 'rb') as input_file:
            acj = pickle.load(input_file)

        choice = acj.optionNames[0]
        del(acj)

        with open(os.path.join(course_name, "ACJ_"+choice+".json")) as input_file:
            json_result = json.load(input_file)

        reviewer_decisions = [decision for decision in json_result["Decisions"]
                if(decision["reviewer"]==reviewer)]

        for decision in reviewer_decisions:
            if(decision["Result"] == "True"):
                decision["Result"] = decision["Pair"][0]
            else:
                decision["Result"] = decision["Pair"][1]

        decisions_json = json.dumps(reviewer_decisions)

        return decisions_json

class Kassim(Resource):
    def get(self):

        return "you have reached us!"


api.add_resource(Pair, '/pair/<course_name>')
api.add_resource(Result, '/result')
api.add_resource(ACJObject, '/newacj')
api.add_resource(CurrentACJResult, '/acjresult/<course_name>')
api.add_resource(Reviewers, '/reviewers/<course_name>')
api.add_resource(Decisions, '/decisions')
api.add_resource(Kassim, '/kassim')

if __name__ == '__main__':
    app.run(debug=True)