1import http 

2from flask import Flask, request, abort 

3from flask_restful import Resource, Api 

4import database 

5import os 

6import sys 

7from bson import json_util 

8import json 

9 

10ASSETS_DIR = os.path.dirname(os.path.abspath(__file__)) 

11app = Flask("__name__") 

12api = Api(app) 

13 

14 

15def connect_db(test): 

16 if test: 

17 api.db = database.Database(True) 

18 api.token_timeout = 60 

19 else: 

20 api.db = database.Database() 

21 api.token_timeout = int(os.environ.get("TOKEN_TIMEOUT")) 

22 print(api.token_timeout) 

23 

24 

25def parse_json(data): 

26 return json.loads(json_util.dumps(data)) 

27 

28 

29@app.after_request 

30def after_request(response): 

31 response.headers.add('Access-Control-Allow-Origin', '*') 

32 response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization') 

33 response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE') 

34 return response 

35 

36 

37class Login(Resource): 

38 def put(self): 

39 request_json = request.get_json() 

40 name = request_json["name"] 

41 password = request_json["password"] 

42 if api.db.check_user_exists(name): 

43 result, user = api.db.check_password(name, password) 

44 if result: 

45 return { 

46 "result": result, 

47 "user": { 

48 "role": user["role"], 

49 "name": user["name"], 

50 "token": api.db.create_token(api.token_timeout, user["id"]) 

51 } 

52 } 

53 else: 

54 return {"result": False} 

55 else: 

56 return {"result": False} 

57 

58 

59class Register(Resource): 

60 def post(self): 

61 request_json = request.get_json() 

62 name = request_json["name"] 

63 password = request_json["password"] 

64 role = request_json["role"] 

65 check = api.db.check_user_exists(name) 

66 if check: 

67 return {"result": False} 

68 else: 

69 result = api.db.create_user(name, password, role) 

70 return {"result": result} 

71 

72 

73class TemplateCreate(Resource): 

74 def post(self): 

75 request_json = request.get_json() 

76 token = request_json.get("token") 

77 user = api.db.check_token(token) 

78 if user is None: 

79 return abort(403, "bad token") 

80 else: 

81 try: 

82 return parse_json(api.db.create_template(request_json["name"], request_json["columns"])) 

83 except: 

84 abort(400, "bad params") 

85 

86 

87class TemplateList(Resource): 

88 def get(self): 

89 token = request.args["token"] 

90 user = api.db.check_token(token) 

91 if user is None: 

92 return abort(403, "bad token") 

93 else: 

94 return {"result": parse_json(api.db.get_templates())} 

95 

96 

97class TestCreate(Resource): 

98 def post(self): 

99 request_json = request.get_json() 

100 token = request_json.get("token") 

101 user = api.db.check_token(token) 

102 if user is None: 

103 return abort(403, "bad token") 

104 else: 

105 try: 

106 test = api.db.create_test(request_json["name"], request_json["template"], request_json["fields"]) 

107 if test: 

108 return http.HTTPStatus.OK 

109 else: 

110 return http.HTTPStatus.INTERNAL_SERVER_ERROR 

111 except Exception as e: 

112 abort(400, "bad params") 

113 

114 

115class TestList(Resource): 

116 def get(self): 

117 token = request.args["token"] 

118 user = api.db.check_token(token) 

119 if user is None: 

120 return abort(403, "bad token") 

121 else: 

122 return {"result": parse_json(api.db.get_tests())} 

123 

124 

125class LogCreate(Resource): 

126 def post(self): 

127 request_json = request.get_json() 

128 token = request_json.get("token") 

129 user = api.db.check_token(token) 

130 if user is None: 

131 return abort(403, "bad token") 

132 else: 

133 try: 

134 log = api.db.create_log(request_json["template"], 

135 request_json["test"], 

136 request_json.get("name")) 

137 return {"result": parse_json(log) 

138 } if log is not None else None 

139 

140 except KeyError as e: 

141 return abort(400, "bad params") 

142 

143 

144class LogGet(Resource): 

145 def get(self, log_id): 

146 token = request.args["token"] 

147 user = api.db.check_token(token) 

148 if user is None: 

149 abort(403, "bad token") 

150 else: 

151 return parse_json({"result": api.db.get_log(log_id)}) 

152 

153 

154class LogList(Resource): 

155 def get(self): 

156 token = request.args["token"] 

157 user = api.db.check_token(token) 

158 if user is None: 

159 abort(403, "bad token") 

160 else: 

161 return parse_json(api.db.get_logs()) 

162 

163 

164class LogSlideGet(Resource): 

165 def get(self, log_id): 

166 token = request.args["token"] 

167 user = api.db.check_token(token) 

168 if user is None: 

169 abort(403, "bad token") 

170 else: 

171 try: 

172 slides = api.db.get_slides(log_id) 

173 if slides: 

174 return parse_json(slides) 

175 else: 

176 return http.HTTPStatus.BAD_REQUEST 

177 except: 

178 return http.HTTPStatus.BAD_REQUEST 

179 

180 

181class PostSlide(Resource): 

182 def post(self, log_id): 

183 request_json = request.get_json() 

184 token = request_json["token"] 

185 user = api.db.check_token(token) 

186 if user is None: 

187 abort(403, "bad token") 

188 else: 

189 try: 

190 slide = api.db.post_slide(log_id, request_json["fields"], request_json["submit"], user) 

191 return{"result": parse_json(slide)} if slide is not None else http.HTTPStatus.INTERNAL_SERVER_ERROR 

192 except KeyError as e: 

193 return abort(400, "bad params") 

194 

195 

196class EditSlide(Resource): 

197 def put(self, log_id): 

198 request_json = request.get_json() 

199 token = request_json["token"] 

200 user = api.db.check_token(token) 

201 if user is None: 

202 abort(403, "bad token") 

203 else: 

204 try: 

205 result = api.db.edit_slide(request_json["slide"], request_json["fields"], request_json["submit"], user) 

206 if result: 

207 return http.HTTPStatus.OK 

208 else: 

209 return http.HTTPStatus.BAD_REQUEST 

210 except KeyError as e: 

211 return abort(400, "bad params") 

212 

213 

214 

215api.add_resource(Login, "/login") 

216api.add_resource(Register, "/register") 

217 

218api.add_resource(TemplateList, "/templates/") 

219api.add_resource(TemplateCreate, "/templates/create") 

220api.add_resource(TestList, "/tests/") 

221api.add_resource(TestCreate, "/tests/create") 

222api.add_resource(LogList, "/logs/") 

223api.add_resource(LogCreate, "/logs/create") 

224api.add_resource(LogGet, "/logs/<string:log_id>/") 

225api.add_resource(LogSlideGet, "/logs/<string:log_id>/slides/") 

226api.add_resource(PostSlide, "/logs/<string:log_id>/slides/create") 

227api.add_resource(EditSlide, "/logs/<string:log_id>/slides/edit") 

228 

229 

230if __name__ == '__main__': 

231 if len(sys.argv) > 1 and sys.argv[1] == "test": 

232 connect_db(True) 

233 else: 

234 connect_db(False) 

235 # context = ('server.crt', 'server.key') 

236 app.run(host="0.0.0.0", port=int(os.environ.get("PORT")))#, ssl_context=context)