def delete_user(email: str, token: str) -> Dict[Any, Any]: """ Deletes a User Parameters ---------- email: str Email of User to delete token: str JWT to authenticate User Returns ------- No User with email: {email} Invalid token Successfully deleted {email} Failed to validate Token """ user = Session.query(User).filter(User.email == email).first() if not user: return response(Status.Failure, f"No User with email: {email}") try: json = jwt.decode(token, secret, algorithms=["HS256"]) if json["email"] != email and json["password"] == user.password: return response(Status.Error, "Invalid token") Session.delete(user) Session.commit() return response(Status.Success, f"Successfully deleted {email}") except jwt.DecodeError: return response(Status.Error, "Failed to validate token")
def login_post(): content = flask.request.json t = userauth.login(content) if t: return response('OK', 'Login Success.', None) else: return response('Failed', 'Login Failed.', None)
def register_post(): content = flask.request.json t = userauth.register(content, 0) if t: return response('OK', 'Registration Success.', None) else: return response('Failed', 'Registration Failed.', None)
def login(email: str, payload: Dict[Any, Any]) -> Dict[Any, Any]: """ Logins in a User Parameters ---------- email: str Email for User payload: Dict[Any, Any] Payload sent as {"password": "******"} Returns ------- No User Exists or Password is incorrect or JSON Web Token to authenticate user """ user = Session.query(User).filter(User.email == email).first() if not user: return response(Status.Error, f"No user with email: {email}") if not bcrypt.checkpw(payload["password"].encode(), user.password): return response(Status.Failure, f"Password is incorrect") return response(Status.Success, create_jwt(user.email, user.password, secret).decode())
def verify_email(email, token, payload) -> Dict[Any, Any]: try: jwt.decode(token, secret, algorithms=["HS256"]) except jwt.DecodeError: return response(Status.Error, "Failed to validate token") user = Session.query(User).filter(User.email == email).first() user.verified = True Session.commit() return response(Status.Success, "Successfully verified email")
def del_remote(user, project, remote): if not all([user, project, remote]): return response(user, status=http.HTTP_UNPROCESSABLE_ENTITY) # retrieve gitlab project res = gitlab.Gitlab().get_project(project) if not res.ok: return response(user, res) result = run_command(user, _cmd_del(project, remote)) return response(user, status=result['status'], body=result)
def get_remote(user, project, remote): if not all([user, project, remote]): return response(user, status=http.HTTP_UNPROCESSABLE_ENTITY) remotes = _get_remotes(user, project) rem = filter(lambda r: r['name'] == remote, remotes['remotes']) if not rem: return response(user, status=http.HTTP_NOT_FOUND) res = { 'project': project } res.update(rem[0]) return response(user, status=http.HTTP_OK, body=res)
def plotRaw(): global pt global eta global raw raw = True pt = response('pt') plotPtResponse(pt) eta = response('eta') plotEtaResponse(eta)
def plotCor(): global ptcor global etacor global raw raw = False ptcor = response('ptcor') plotPtResponse(ptcor) etacor = response('etacor') plotEtaResponse(etacor)
def plotDREffect(): global dRon global dRoff global dRCut dRCut = False dRoff = response('dRoff') plotPtResponse(dRoff) dRCut = True dRon = response('dRon') plotPtResponse(dRon)
def request_pose(): # Request if not request.json: # or not "button" in request.json: abort(400) post = { "position": request.json["position"], "mode": request.json["mode"], "vid_length": request.json["vid_length"] } ip = socket.gethostbyname(socket.gethostname()) url_settings = "http://" + ip + ":61405/pixelsettings" settings = requests.get(url_settings) settings = settings.json()[-1] response(post) # action posts.append(post) # see post on website return jsonify(posts), 201
def test_valid_participant_stat_response(self): validPlayerStat = [None] * 33 validPlayerStat[7] = 39 validPlayerStat[31] = 29 validPlayerStat[32] = "2018" resp = response() self.assertEqual(resp.participantResponse(validPlayerStat), 'Player No.29 has 39 Games played in 2018')
def parse_message(self, data): print 'origin data:' + data data = data.rstrip('##') new_data = json.loads(data) print new_data uid = new_data.get("uid") print self.uid service = new_data.get("service") method = new_data.get("method") params = new_data.get("params") """ service= 'TestService' method= 'testMethod' params= {} """ cls = getattr(TestService, service) obj = cls() func = getattr(obj, method) data = func(params) req = response(data) #print req.dump() return req.dump() return data
def _create_application(user, app): res = provider.OpenShift(user).add_app(**app._asdict()) if res.ok: print 'Application created: {app.name}-{app.domain}'.format(app=app) return res raise response(user, res=res)
def request_pose(): # Request if not request.json: # or not "button" in request.json: abort(400) post = { "position": request.json["position"], "mode": request.json["mode"], "vid_length": request.json["vid_length"] } stream = os.popen('ipconfig getifaddr en0') # gets ip address ip = stream.read().rstrip() # gets rid of newline url_settings = "http://" + ip + ":61405/pixelsettings" settings = requests.get(url_settings) settings = settings.json()[-1] response(post) # action posts.append(post) # see post on website return jsonify(posts), 201
def adminresponce(text): text = str(text) if '/' in text: if '/genadmin ' in str(text): n = text.replace('/genadmin ', '') if n.isdigit(): n = int(n) generateAdmins(n) return u'Токены сгенерированы' else: return u'Пример команды: /genadmin 3' if '/gen' in str(text): n = text.replace('/gen ', '') if n.isdigit(): n = int(n) generateUsers(n) return u'Токены сгенерированы' else: return u'Пример команды: /gen 3' if '/tokens' in str(text): return ('\n'.join(getTokens())) return u'команды: /gen - сгенерировать токены юзеров \n/genadmin сгенерировать токены админов \n/tokens - вывести токены \n' return response(text) #print(adminresponce('/gen 3')) #print(adminresponce('/genadmin 3')) #print(adminresponce('/tokens')) #print(adminresponce('/t')) #print(adminresponce('привет'))
def _create_gitlab_project(user, proj): res = gitlab.Gitlab().add_project(name=proj.name) if res.ok: print 'Project created:', proj.name return res raise response(user, res=res)
def _get_remotes(user, project): # garantee ownership res = gitlab.Gitlab().get_project(project) if not res.ok: raise response(user, res) return run_command(user, _cmd_list(project))
def clone_remote(user, project_name, application): _install_getup_key(user) mesg = 'setup application project repository: app={app.name}-{app.domain} project={project}'.format(app=application, project=project_name) print mesg res = _create_remote(user, project_name, application.domain, application.name, 'clone') print '{mesg} (end with {status})'.format(mesg=mesg, status=res.get('status')) return response(user, status=res['status'], body=res)
def do_single_reponse(self, idx): databuff = "" data_len = 0 while True: rbuff = self.client.recv(FSIZE) magic_code, resp_code, id, reverse, length = unpack(FMT, rbuff) self.client.logger.debug("return resp_code[%d] length[%d],id[%d]" % (resp_code, length, id)) if id != self.ids[idx]: raise response_exception("id is error!") rbuff = self.client.recv(length) if 400 <= resp_code < 600: rpos = 0 error_code, = unpack('!L', rbuff[rpos:rpos + 4]) if resp_code == CLIENT_STATUS_DB_ERROR: raise response_exception("mysql return code [%d]" % error_code) if error_code < len(ERROR_MSG): raise response_exception(ERROR_MSG[error_code]) else: raise response_exception("unkown error code [%d]" % error_code) elif resp_code == CLIENT_STATUS_ACCEPT: databuff += rbuff data_len += length elif resp_code == CLIENT_STATUS_OK: databuff += rbuff data_len += length self.client.logger.debug("return data_length[%d]" % data_len) return response(databuff, data_len).parse() else: raise response_exception("unknown response code [%d]" % resp_code)
def add_remote(user, project_name, application): _install_getup_key(user) mesg = 'attaching repository into application: app={app.name}-{app.domain} project={project}'.format(app=application, project=project_name) print mesg res = _create_remote(user, project_name, application.domain, application.name, 'add') print '{mesg} (end with {status})'.format(mesg=mesg, status=res.get('status')) return response(user, status=res.get('status'), body=res)
def SearchRestaurant(conn, rName): sql = """select Restaurant.rID, rName, rAddr, rPic, tableType, time17, time18, time19, time20 from Restaurant natural join Available where rName = '%s'""" % (rName) search = conn.cursor() search.execute(sql) result = search.fetchall() res = response() if not len(result): res.StatusCode = '404' res.ReasonPhrase = 'Restaurant ID Not Found' else: res.StatusCode = '200' res.ReasonPhrase = 'Search OK' dict = {'rID':'', 'rName':'', 'rAddr':'', 'rPic':'', 'tableInfo': []} dict['rID'] = result[0][0] dict['rName'] = result[0][1] dict['rAddr'] = result[0][2] dict['rPic'] = result[0][3] for rInfo in result: tmp = [] tmp.append(rInfo[5]) tmp.append(rInfo[6]) tmp.append(rInfo[7]) tmp.append(rInfo[8]) dict['tableInfo'].append(tmp) res.Data = dict return res
def do_single_reponse(self,idx): databuff = "" data_len = 0 while True: rbuff = self.client.recv(FSIZE) magic_code, resp_code, id, reverse, length = unpack(FMT, rbuff) self.client.logger.debug("return resp_code[%d] length[%d],id[%d]" % (resp_code, length, id)) if id != self.ids[idx]: raise response_exception("id is error!") rbuff = self.client.recv(length) if 400 <= resp_code < 600: rpos = 0 error_code, = unpack('!L', rbuff[rpos:rpos + 4]) if resp_code == CLIENT_STATUS_DB_ERROR: raise response_exception("mysql return code [%d]" % error_code) if error_code < len(ERROR_MSG): raise response_exception(ERROR_MSG[error_code]) else: raise response_exception("unkown error code [%d]" % error_code) elif resp_code == CLIENT_STATUS_ACCEPT: databuff += rbuff data_len += length elif resp_code == CLIENT_STATUS_OK: databuff += rbuff data_len += length self.client.logger.debug("return data_length[%d]" % data_len) return response(databuff, data_len).parse() else: raise response_exception("unknown response code [%d]" % resp_code)
def get(self, user=None): return response.response( response.STATUS, {'status': self.toastStatus(), 'count': int(self.toastCount()), 'last': self.modified(), 'started': self.started() }).json()
def _create_remote(user, project, domain, application, command='add'): if not all([user, project, domain, application]): raise response(user, status=http.HTTP_UNPROCESSABLE_ENTITY) # retrieve openshift app res = provider.OpenShift(user).get_app(domain=domain, name=application) if not res.ok: raise response(user, res) app_data = res.json['data'] # retrieve gitlab project res = gitlab.Gitlab().get_project(project) if not res.ok: raise response(user, res) remote = '{app[name]}-{app[domain_id]}'.format(app=app_data) git_url = '{app[ssh_url]}/~/git/{app[name]}.git/'.format(app=app_data) return run_command(user, _cmd_create(project, remote, git_url, command))
def register_TBD_user_post(): content = {} content["email"] = "TBD" + "@contestify.com" content["password"] = "******" content["firstName"] = "" content["lastName"] = "TBD" t = userauth.register(content, 2) return response('OK', 'TBD Registration Success.', None)
def get(): # result in form of array representing probablistic classes #resultClassify = res.classify(request.json["sentence"]) resultResponse = res.response(request.json["sentence"]) responseDict = {} #for r in resultClassify: #responseDict[r[0]] = str(r[1]) responseDict["sentence"] = resultResponse print(responseDict) return jsonify ( responseDict )
def sentiment_analysis(): """method that outputs a response""" if request.method == 'GET': text = request.args.get('text') return response(text) return make_response( jsonify({ 'error': 'sorry! unable to parse', 'status_code': 500 }), 500)
def get_user(email: str) -> Dict[Any, Any]: """ Gets a User by Email Parameters ---------- email: str Email to query for Returns ------- User information including public_key, bio, and handle """ user = Session.query(User).filter(User.email == email).first() if not user: return response(Status.Failure, f"No Users with email: {email}") return response(Status.Success, user.to_json())
def register_empty_users_post(): for i in range(int(128)): content = {} content["email"] = "Player" + str(i) + "@contestify.com" content["password"] = "******" content["firstName"] = "Player" content["lastName"] = str(i) t = userauth.register(content, 1) return response('OK', 'Batch Registration Success.', None)
def run_command(user, cmd): try: cmd_result = gitlab.SSHClient().run(cmd) output = json.loads(cmd_result.stdout) if 'status' not in output: raise response(user, status=http.HTTP_INTERNAL_SERVER_ERROR, body="Invalid result from command: missing 'status' field") if 200 > output['status'] >= 400: raise response(user, status=output['status'], body=output.get('data')) return output except ValueError, ex: print 'Failure parsing command output: {ex}'.format(ex=ex) print '--- stdout' print cmd_result.stdout print '--- stderr' print cmd_result.stderr print '---' raise response(user, status=http.HTTP_INTERNAL_SERVER_ERROR, body=str(ex))
def _create_domain(user, app): res = provider.OpenShift(user).get_dom(app.domain) if res.ok: return res res = provider.OpenShift(user).add_dom(app.domain) if res.ok: print 'Domain created:', app.domain return res raise response(user, res=res)
def main(): #set up the request user_input = input("Request: ") a = re.split(' +', user_input) r = request(a[0], a[1]) #send the request, assign it to response req = send_socket(r.toString()) resp = response(req.decode('UTF-8')) print(resp.toString())
def resend_email_verificaiton(email: str, token: str, payload: Dict[Any, Any]) -> Dict[Any, Any]: """ Resends the Verification email Parameters ---------- email: str User's email token: str JWT Token to verify the user payload: Dict[Any, Any] Empty payload Returns ------- Dict[Any, Any] No User with email: {email} Invalid token Verification email sent Invalid Token """ user = Session.query(User).filter(User.email == email).first() if not user: return response(Status.Error, f"No User with email: {email}") try: json = jwt.decode(token, secret, algorithms=["HS256"]) if json["email"] != email and json["password"] == user.password: return response(Status.Error, "Invalid token") send_verification_email( email, rest.get_url(), create_jwt(user.email, user.password, secret, 24 * 7).decode(), ) return response(Status.Success, "Verification email sent") except jwt.DecodeError: return response(Status.Error, "Invalid Token")
def create_project(user, project): start_time = datetime.utcnow().ctime() report = [] def add_report(action, description, **kva): report.append(dict(action=action, description=description, **kva)) def set_report_status(res): r = report[-1] print '{action}: {res.status_code}\n---\n{res.json}\n---'.format( action=r['action'], res=res) report[-1].update(status=res.status_code, content=res.json) try: # create openshift domain add_report('domain', 'Create openshift domain') res = _create_domain(user, project.application) set_report_status(res) # create gitlab project add_report('project', 'Create project repository') res = _create_gitlab_project(user, project) set_report_status(res) # create openshift app add_report('application', 'Create openshift application') res = _create_application(user, project.application) set_report_status(res) # clone and setup default remote add_report('clone', 'Clone and setup application code into project repository') res = _clone_app_into_repo(user, project.name, project.application) set_report_status(res) # create dev openshift app is applicable if project.dev_application: add_report('dev_application', 'Create openshift dev_application') res = _create_application(user, project.dev_application) set_report_status(res) dns_register_wildcard_cname('{app.name}-{app.domain}'.format(app=project.dev_application)) #set_report_status(res) # add remote to dev repoitory add_report('dev_remote', 'Add dev_application as remote') res = add_remote(user, project.name, project.dev_application) set_report_status(res) except HTTPResponse, ex: set_report_status(ex.res) add_report('finish', 'Failure creating component ({action})'.format(action=report[-1]['action']), status=str(), start_time=start_time, end_time=datetime.utcnow().ctime()) return response(user, status=ex.status_code, body=report)
def index(req): if not checkSig(req): return HttpResponseForbidden() if req.method == 'GET': return HttpResponse(req.GET.get('echostr', '')) req_msg = parseXml(req) ret = NULL_RESPONSE if req_msg.get('MsgType', '') == 'text': ret = response(req_msg.get('Content', '')) return HttpResponse(makeTextMsg(req_msg, ret))
def list_users() -> Dict[Any, Any]: """ Lists all Users by Email Returns ------- List[str] of User emails """ users: List[User] = Session.query(User).all() users_json: List[Dict[str, str]] = [user.email for user in users] return response(Status.Success, users_json)
def onProcessRequest(self, request): ret = None if self.mapOperation.has_key(request.method): for pathReg, handle in self.mapOperation[request.method].items(): params = self.__matchPath(pathReg, request.path) if params: ret = handle(**params) if not isinstance(ret, response): ret = response(200, str(ret)) return ret
def index(req): if not checkSig(req): return HttpResponseForbidden() if req.method == 'GET': return HttpResponse(req.GET.get('echostr', '')) req_msg = parseXml(req) ret = 'Null Response.' if req_msg.get('MsgType', '') == 'text': ret = response(req_msg.get('Content', '')) return HttpResponse(makeTextMsg(req_msg, ret))
def update_user(email: str, token: str, payload: Dict[Any, Any]) -> Dict[Any, Any]: """ Updates a User Parameters ---------- email: str Email to query for jwt: str JSON Web Token to validate User to permit updating payload: Dict[Any, Any] Payload of the form { "password": "******", "handle": "handle_here", "public_key": "public_key_here" "bio": "bio_here" } Returns ------- No User with email: {email} Updated User information """ user = Session.query(User).filter(User.email == email) if not user: return response(Status.Failure, f"No User with email: {email}") try: jwt.decode(token, secret, algorithms=["HS256"]) except jwt.DecodeError: return response(Status.Error, "Failed to validate token") user.update(payload) Session.commit() return response(Status.Success, user.to_json())
def get_response(self): intent = self.intent slot_dictionary = self.slot_dictionary response_dictionary = None if intent == 'TeamIntent': response_dictionary = self.interpret_team_intent(intent, slot_dictionary) elif intent == 'TeamParticipantIntent': response_dictionary = self.interpret_team_participant_intent(intent, slot_dictionary) elif intent == 'ScheduleIntent': response_dictionary = self.interpret_schedule_intent(intent, slot_dictionary) else: response_dictionary = None return response(response_dictionary).generate_response()
def getAllResponsePatternId(self): """ Get all response for patternid :return: """ c = con() #uma lista de tuplas [(id,response,patternId),...] aux = c.getAllResponsePattern(self.patternId) # temporaria para retornar tmp = [] for rs in aux: tmp.append(response(rs)) return tmp
def test_valid_schedule_response(self): data = [] gameObj = game(data) gameObj.month = "April" gameObj.day = 25 gameObj.opponent_name = "#2 Wooster" gameObj.result = "L, 11-6" validSchedule = [None] * 3 validSchedule[1] = gameObj validSchedule[2] = "2018" resp = response() #print(validSchedule) self.assertEqual(resp.scheduleResponse(validSchedule), 'CWRU baseball team played #2 Wooster on the 25 of April, and the result was L, 11-6.')
def set(self, key=None, toasting=None): errors = [] toasting = toasting.lower() js = '' if key == None: errors.append('Empty key.') keyRow = self.db.execute("select * from users where secret = '" + key.upper() + "' limit 1").fetchone(); if keyRow == None: errors.append('Invalid key.') else: name = keyRow['name'] if toasting == None: errors.append('Empty toasting command.') elif toasting != 'on' and toasting != 'off' and toasting != 'reset': errors.append('Invalid toasting command.') if len(errors) > 0: js = response.response(response.ERROR, errors).json() else: if toasting == 'reset': self.db.execute("delete from records") else: timing = str(time.localtime()) if toasting == 'on': self.records.insert().execute(user='******', start=timing) else: row = self.db.execute( "select rowid from records order by start desc, finish desc limit 1" ).fetchone() id = row['rowid'] self.db.execute("update records set finish = '" + str(timing) + "' where rowid = " + str(id)) js = response.response(response.SUCCESS, {"toasting": toasting, "effective": str(timing)}).json() return js
def pairing(self): url = '%s/login?pairing-guid=%s' % (self.service, self.guid) data = urllib2.urlopen( url ).read() resp = response.response(data) self.sessionid = resp.resp['mlog']['mlid'] confMan.connect( self.dbId, self.sessionid ) print "Got session id", self.sessionid self.databases() pl = self.playlists() self.musicid = pl.library.id self.getspeakers() return resp
def _operation( self, command, values, verbose=True, sessionid = True): if sessionid: if self.sessionid is None: self.pairing() values['session-id'] = self.sessionid url = command if len(values): url += "?" + _encode(values) #if verbose: print url print url headers = { 'Viewer-Only-Client': '1', 'Connection':'keep-alive', 'Accept-Encoding': 'gzip'} # 'Accept-Encoding': 'identity', # 'User-agent':'Python-urllib/2.6' } # 'Connection':'close' } request = urllib2.Request( url, None, headers ) try: resp = urllib2.urlopen(request) headers = resp.headers.dict if 'content-encoding' in headers and headers['content-encoding'] == 'gzip': compressedstream = StringIO.StringIO(resp.read()) gzipper = gzip.GzipFile(fileobj=compressedstream) out = gzipper.read() else: out = resp.read() if headers['content-type'] != 'image/png': if verbose: self._decode2( out ) resp = response.response( out ) return resp.resp else: return out except HTTPError, e: print "HTTPError while running query" print request.get_full_url() print request.headers print e
def _dns_init(): zone = app.config.dns.zone key = app.config.dns.key server = socket.getaddrinfo(app.config.dns.server, app.config.dns.port, socket.SOCK_DGRAM, 0, socket.SOL_UDP) if not server: raise response(user=None, status=http.HTTP_INTERNAL_SERVER_ERROR, body="Unable to resolve DNS server: {server}:{port}".format(**app.config.dns)) server = server[0] af = server[0] addr, port = server[-1][:2] return { 'af': af, 'addr': addr, 'port': port, 'zone': zone, 'keyring': dns.tsigkeyring.from_text({ zone: key }), 'keyname': zone, 'keyalgorithm': dns.tsig.HMAC_MD5, }
async def SendData(self, data): try: data += "<EOF>" self.encryptionconn.send(data.encode()) recvdata = await self.RecvData() recvdata = recvdata.decode('UTF-8') if not recvdata: self.connected = False return 1 recvdata = recvdata[:-5] jsonobj = json.loads(recvdata) if jsonobj['action'] == 'response': return response.response(jsonobj["rezultat"][0][0], jsonobj["rezultat"][1][1]) except socket.error as e: print("Error in sending data. " + str(e)) self.connected = False self.mainsocket.close() self.on_connection_lost(self) return 1
def parse_message(self, data): print data data = data.rstrip('##') obj = ConnectionObj() obj.stream = self._stream obj.time = 123456789 Connection.clients[str(self._address[0]) + str(self._address[1])] = obj return data new_data = json.loads(data) print "data:" + data print new_data self.uid = new_data.get("uid") print self.uid service = new_data.get("service") method = new_data.get("method") params = new_data.get("params") """ service= 'TestService' method= 'testMethod' params= {} """ obj = ConnectionObj() obj.stream = self._stream obj.time = 123456789 Connection.clients[str(self.uid) + self._address[1]] = obj #print Connection.clients[self.uid].time cls = getattr(TestService, service) obj = cls() func = getattr(obj, method) data = func(params) req = response(data) #print req.dump() #return req.dump() return data
def insert_appointment(conn, rid, uid, tableType, startTime, duration): res = response() cur = conn.cursor() find_restTable_sql = """ SELECT rID, tableType, time17, time18, time19, time20 FROM Available WHERE rid = '%d' AND tableType = '%d'""" % (rid, tableType) cur.execute(find_restTable_sql) find_restTable_result = cur.fetchall() #print(find_restTable_result) if (check_remaining(find_restTable_result, startTime, duration) == -1): print("no remaining") res.StatusCode = '404' res.ReasonPhrase = 'no remaining' insert_sql = """INSERT INTO Appointment VALUES('%d','%s','%d','%d','%d')""" % (rid, uid, tableType, startTime, duration) update_remaining_sql = update_remaining(find_restTable_result, rid, tableType, startTime, duration) print(update_remaining_sql) try: cur.execute(insert_sql) cur.execute(update_remaining_sql) conn.commit() res.StatusCode = '200' res.ReasonPhrase = 'successfully inserted' except MySQLdb.Error, e: conn.rollback() for index in range(len(e.args)): print "Error %s" % (e.args[index]) res.StatusCode = '404' res.ReasonPhrase = 'fail to insert'
def post_create(user, domain, application, project, cartridge, scale, dev_gear): '''Clone and bind project to application, creating any missing component. ''' scale = bool(scale) if not project: project = '%s-%s' % (application, domain) if dev_gear: dev_application = 'dev%s' % application checklist = { 'project': False, 'domain': False, 'application': False, } checklist['project'] = gitlab.Gitlab().get_project(project).status_code == 404 checklist['domain'] = provider.OpenShift(user).get_dom(name=domain).status_code == 200 checklist['application'] = provider.OpenShift(user).get_app(domain=domain, name=application).status_code == 404 if dev_gear: checklist['dev-application'] = provider.OpenShift(user).get_app(domain=domain, name=dev_application).status_code == 404 if checklist['project'] is False or checklist['application'] is False or \ (dev_gear is True and checklist['dev-application'] is False): return response(user, status=http.HTTP_CONFLICT, body=checklist) p_app = projects.Application(domain=domain, name=application, cartridge=cartridge, scale=scale, \ gear_profile=app.config.provider.openshift.default_gear_profile) if dev_gear: d_app = projects.Application(domain=domain, name=dev_application, cartridge=cartridge, scale=False, \ gear_profile=app.config.provider.openshift.devel_gear_profile) else: d_app = False return projects.create_project(user, projects.Project(name=project, application=p_app, dev_application=d_app))
def player_list_put(contest_id): content = flask.request.json contestmanage.register_player(contest_id = contest_id, user_id = content["userId"]) return response('OK', '', None)
def current_user_get(): t = {} t['currentUserId'] = current_user.get_id() return response('OK', '', t)
def upload_match_result(match_id): OperationData.increaseContests() content = flask.request.json contestmanage.upload_match_result(match_id = match_id, contest_id = content["contestId"], score1 = content["score1"], score2 = content["score2"]) return response('OK', '', None)
def contest_post(): content = flask.request.json content['adminId'] = current_user.get_id() t = contestmanage.new_contest(content) return response('OK', 'New Contest Success.', t)
def graph_get(): contest_id = flask.request.args.get('id') t = contestmanage.get_graph_by_contest_id(contest_id = contest_id) return response('OK', '', t)
def match_get(): contest_id = flask.request.args.get('id') t = contestmanage.get_match_by_id(match_id = contest_id) return response('OK', '', t)
def player_list_get(): contest_id = flask.request.args.get('id') t = contestmanage.get_player_list_by_contest_id(contest_id = contest_id) return response('OK', '', t)