python-std-lib/expression_server.py at master · czkiam/python-std-lib · 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
from http.server import HTTPServer, BaseHTTPRequestHandler
from collections import OrderedDict
import time
import json

expressions = OrderedDict()


class ExpressionHandler(BaseHTTPRequestHandler):
    def next_id(self):
        if len(expressions) == 0: return 1

        expression_ids = list(expressions.keys())
        last_key = expression_ids[-1]
        return last_key + 1

    def handle_expression(self, x):
        mathop = x['mathop']
        if mathop == 'add':
            return x['op1'] + x['op2']
        elif mathop == 'subtract':
            return x['op1'] - x['op2']
        elif mathop == 'multiply':
            return x['op1'] * x['op2']
        else:
            return None

    def do_GET(self):
        path_parts = self.path.split('/')
        if path_parts[1] == 'list':
            expression_ids = list(expressions.keys())
            expression_list = [
                {
                    'id': expression_id,
                    'mathop': expressions[expression_id]['mathop'],
                    'op1': expressions[expression_id]['op1'],
                    'op2': expressions[expression_id]['op2'],
                    'timestamp': expressions[expression_id]['timestamp']
                }
                for expression_id in expression_ids
            ]
            self.send_response(200)
            self.end_headers()
            self.wfile.write(json.dumps(expression_list).encode('utf-8'))
        elif len(path_parts) > 2 and path_parts[1] == 'expression':
            expression_id = int(path_parts[2])
            if expression_id in expressions.keys():
                expression = expressions[expression_id]
                result = self.handle_expression(expression)
                data = {}
                if result is None:
                    data['error': 'invalid expression']
                else:
                    data['result'] = result
                    data['timestamp'] = time.strftime("%B %d, %Y  %H:%M:%S")
                self.send_response(200)
                self.end_headers()
                self.wfile.write(json.dumps(data).encode('utf-8'))
            else:
                self.send_response_only(404)
                self.end_headers()
        else:
            self.send_response_only(404)
            self.end_headers()

    def do_POST(self):
        if self.headers['Content-Type'] == 'application/json':
            content_length = int(self.headers['Content-Length'])
            payload = self.rfile.read(content_length)

            timestamp = time.strftime("%B %d, %Y  %H:%M:%S")
            expression_id = self.next_id()

            expression = json.loads(payload.decode('utf-8'))
            expression['timestamp'] = timestamp

            expressions[expression_id] = expression

            self.send_response(201)
            self.end_headers()
            self.wfile.write(json.dumps({'id': expression_id, 'timestamp': timestamp}).encode('utf-8'))
        else:
            self.send_response_only(400)
            self.end_headers()

    def do_PUT(self):
        path_parts = self.path.split('/')
        if len(path_parts) > 1 and self.headers['Content-Type'] == 'application/json':
            expression_id = int(path_parts[1])
            if expression_id in expressions.keys():
                content_length = int(self.headers['Content-Length'])
                payload = self.rfile.read(content_length)
                timestamp = time.strftime("%B %d, %Y  %H:%M:%S")

                expression = json.loads(payload.decode('utf-8'))
                expression['timestamp'] = timestamp

                expressions[expression_id] = expression

                self.send_response(200)
                self.end_headers()
                self.wfile.write(json.dumps({'id': expression_id, 'timestamp': timestamp}).encode('utf-8'))
            else:
                self.send_response_only(404)
                self.end_headers()
        else:
            self.send_response_only(400)
            self.end_headers()


    def do_DELETE(self):
        path_parts = self.path.split('/')
        if len(path_parts) > 1:
            expression_id = int(path_parts[1])
            if expression_id in expressions.keys():
                del expressions[expression_id]
                self.send_response_only(204)
                self.end_headers()
            else:
                self.send_response_only(404)
                self.end_headers()
        else:
            self.send_response_only(404)
            self.end_headers()


if __name__ == '__main__':
    server = HTTPServer(('', 8888), ExpressionHandler)
    server.serve_forever()