def get(self): logger.debug("Getting instances") auth_response = authenticate(self, [Permissions.READ_SURVEY]) survey_id = self.get_argument("survey_id", None) status = self.get_argument("status", None) if auth_response["valid"]: owner_id = auth_response["owner_id"] if status is not None: instances = InstanceService.get_by_owner(owner_id, survey_id, Status.CREATED_START) else: instances = InstanceService.get_by_owner(owner_id, survey_id) instance_ids = [instance.id for instance in instances] self.set_status(200) response = { "status": "success", "ids": instance_ids } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, enrollment_id): logger.debug("Getting metadata about an enrollment") auth_response = authenticate(self, [Permissions.READ_ENROLLMENT]) if auth_response["valid"]: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if enrollment.owner_id == owner.id: enrollment_dict = { "id": enrollment.id, "open_date": enrollment.open_date.strftime('%Y-%m-%d'), "close_date": enrollment.close_date.strftime('%Y-%m-%d'), "expiry_date": enrollment.expiry_date.strftime('%Y-%m-%d') } response = {"status": "success", "enrollment": enrollment_dict} self.set_status(200) else: response = { "status": "error", "message": "Owner does not have authorization to administer this enrollment" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def delete(self, enrollment_id): logger.debug("Removing an enrollment") auth_response = authenticate(self, [Permissions.WRITE_ENROLLMENT]) if auth_response['valid']: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if enrollment is None or owner.id == enrollment.owner_id: if enrollment is not None: # DELETE is idempotent EnrollmentService.delete_enrollment(enrollment_id) self.set_status(200) response = {"status": "success"} else: self.set_status(401) response = { "status": "error", "message": "Owner does not have authorization to administer this enrollment" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, plugin_url): logger.debug("Requesting permissions of an unregistered plugin") r = requests.get(plugin_url + "/info") if r.status_code != 200: self.set_status(400) response = { "status": "error", "message": "Something went wrong in the request to the plugin" } else: try: r = r.json() permissions = r["permissions"] self.set_status(200) response = {"status": "success", "permissions": permissions} except ValueError: self.set_status(400) response = { "status": "error", "message": "Plugin did not respond to request as expected" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self): logger.debug("Querying for tasks") auth = authenticate(self, [Permissions.READ_TASK]) if auth["valid"]: surveys = SurveyService.get_surveys_by_owner(auth["owner_id"]) surveys_tasks = {} for survey in surveys: surveys_tasks[survey] = TaskService.get_tasks_by_survey_id( survey.id) tasks = [] for survey, task_list in surveys_tasks.items(): for task in task_list: tasks.append({ "id": task.id, "name": task.name, "protocol_name": ProtocolService.get_protocol(survey.protocol_id).name, "enrollment_name": EnrollmentService.get(survey.enrollment_id).name }) response = {"status": "success", "tasks": tasks} self.set_status(200) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def save_update(self): instr = '' for key in self.model.columns: instr += key + " = " + self.parse_value( self.__dict__[key]) + ', ' instr = instr[:-2] sql = "UPDATE " + self.model.table_name + " SET " + instr + " WHERE id = %s" logger.debug(sql) connection = Model.dao.get_connection() try: with connection.cursor() as cursor: cursor.execute(sql, self.__dict__['id']) logger.debug("Executing sql: %s", sql) connection.commit() updated_row_id = cursor.lastrowid finally: connection.close() return self.model.select( Where(self.model.id, Where.EQUAL, updated_row_id))
def delete(self, task_id): logger.debug("Trying to delete a task") auth = authenticate(self, [Permissions.READ_TASK]) if auth['valid']: task = TaskService.get_task(int(task_id)) survey = SurveyService.get_survey(task.survey_id) if survey.owner_id == int(auth['owner_id']): TaskService.delete_task(task.id) self.set_status(200) response = {"status": "success"} else: response = { "status": "error", "message": "Plugin is not registered by survey administrator" } self.set_status(403) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self): logger.debug("Querying for plugins") auth = authenticate(self, [Permissions.READ_PLUGIN]) permissions = self.get_argument("permissions") if auth["valid"]: plugins = PluginService.get_plugins_with_at_least_permissions( permissions) plugin_list = [] for plugin in plugins: plugin_dict = { "id": plugin.id, "name": plugin.name, "url": plugin.url, "icon": plugin.icon, "permissions": plugin.permissions } plugin_list.append(plugin_dict) response = {"status": "success", "plugins": plugin_list} self.set_status(200) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, enrollment_id): logger.debug("Getting list of enrolled participants") auth_response = authenticate( self, [Permissions.READ_ENROLLMENT, Permissions.READ_PARTICIPANT]) if auth_response["valid"]: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if owner.id == enrollment.owner_id: participants = ParticipantService.get_participants_in_enrollment( enrollment.id) response = { "status": "success", "participant_ids": [participant.id for participant in participants] } self.set_status(200) else: response = { "status": "error", "message": "Owner does not have authorization to administer this enrollment" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, enrollment_id, participant_id): logger.debug("Retrieving participant info") auth_response = authenticate( self, [[Permissions.READ_ENROLLMENT, Permissions.READ_PARTICIPANT]]) if auth_response["valid"]: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if owner.id == enrollment.owner_id: try: participant = ParticipantService.get_participant( participant_id) except SecurityException as e: response = {"status": "error", "message": e.message} self.set_status(410) else: if participant is None: response = { "status": "error", "message": "Participant does not exist" } self.set_status(410) elif participant.enrollment_id == enrollment_id: participant_dict = { "participant_id": participant.id, "plugin_id": participant.plugin_id, "plugin_scratch": participant.plugin_scratch, "enrollment_id": participant.enrollment_id } response = { "status": "success", "participant": participant_dict } self.set_status(200) else: response = { "status": "error", "message": "Participant does not belong to enrollment" } self.set_status(400) else: response = { "status": "error", "message": "Owner does not have authorization to administer enrollment" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self, enrollment_id): logger.debug("Adding participant to enrollment") plugin_id = self.get_argument("plugin_id") plugin_name = self.get_argument("plugin_name") plugin_scratch = self.get_argument("plugin_scratch") ParticipantDetails.participantEnrollment.append(enrollment_id) auth_response = authenticate( self, [Permissions.READ_ENROLLMENT, Permissions.WRITE_PARTICIPANT]) if auth_response["valid"]: owner = OwnerService.get_by_id(auth_response["owner_id"]) if PluginService.is_owned_by(plugin_id, owner.id): enrollment = EnrollmentService.get(int(enrollment_id)) if owner.id == enrollment.owner_id: try: ParticipantService.register_participant( enrollment.id, plugin_id, plugin_scratch, owner.name, owner.domain) participants = ParticipantService.get_participants_in_enrollment( enrollment_id) for participant in participants: lastparticipantid = participant.id ParticipantDetails.participantEnrollment.append( lastparticipantid) ParticipantDetails.participantEnrollment.append( plugin_name) ParticipantDetails.participantEnrollment.append( plugin_scratch) ParticipantDetails.get_enrollment() except SecurityException as e: response = {"status": "error", "message": e.message} else: response = {"status": "success"} else: response = { "status": "error", "message": "Owner does not have authorization to administer this enrollment" } else: response = { "status": "error", "message": "Participant's plugin is not registered with owner" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self): logger.debug("User attempting to retrieve all enrollments") auth_response = authenticate(self, [Permissions.READ_ENROLLMENT]) if auth_response["valid"]: enrollments = EnrollmentService.get_by_owner( auth_response["owner_id"]) enrollments_list = [] for enrollment in enrollments: enrollment_dict = { "id": enrollment.id, "name": enrollment.name, "participants": EnrollmentService.participant_count(enrollment.id) } if enrollment.open_date is not None: enrollment_dict[ "open_date"] = enrollment.open_date.strftime( '%Y-%m-%d') else: enrollment_dict["open_date"] = None if enrollment.close_date is not None: enrollment_dict[ "close_date"] = enrollment.close_date.strftime( '%Y-%m-%d') else: enrollment_dict["close_date"] = None if enrollment.expiry_date is not None: enrollment_dict[ "expiry_date"] = enrollment.expiry_date.strftime( '%Y-%m-%d') else: enrollment_dict["expiry_date"] = None enrollments_list.append(enrollment_dict) response = {"status": "success", "enrollments": enrollments_list} self.set_status(200) else: response = { "status": "error", "message": "Do not have authorization to make this request" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, plugin_id): logger.debug("Requesting permissions from a registered plugin") plugin = PluginService.get_plugin(plugin_id) if plugin is None: self.set_status(410) response = {"status": "error", "message": "invalid plugin id"} else: self.set_status(200) response = {"status": "success", "permissions": plugin.permissions} response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def select(self, param1=None, param2=None, force_list=False): inner_join = None where = None if isinstance(param1, Where): where = param1 elif isinstance(param1, InnerJoin): inner_join = param1 if isinstance(param2, Where): where = param2 elif isinstance(param2, InnerJoin): inner_join = param2 sql = "SELECT * FROM " + self.table_name connection = Model.dao.get_connection() try: with connection.cursor(pymysql.cursors.DictCursor) as cursor: if inner_join is not None: sql += " INNER JOIN " + inner_join.build() if where is not None: sql += " WHERE " + where.build() cursor.execute(sql) logger.debug("Executing sql: %s", sql) results = cursor.fetchall() if len(results) == 1 and not force_list: return self.__ModelInstance.from_dict(self, results[0]) elif len(results) > 1 or force_list: instances = [] for result in results: instances.append( self.__ModelInstance.from_dict(self, result)) return instances return [] if force_list else None finally: connection.close()
def post(self): logger.debug("Attempt to login") data = json_decode(self.request.body) username = data["username"] password = data["password"] print(username) splitter = username.find('@') print(splitter) if splitter == -1: self.set_status(401) response = {"status": "error", "reason": "Invalid username"} else: owner_name = username[:splitter] owner_domain = username[splitter + 1:] if OwnerService.validate_password(owner_name, owner_domain, password): # Generate a session session = secure.create_session( OwnerService.get(owner_name, owner_domain).id) self.set_status(200) response = { "status": "success", "session_id": session.id, "username": username } else: self.set_status(401) response = { "status": "error", "reason": "Username and password do not match" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self): data = json_decode(self.request.body) session_id = data["session_id"] logger.debug("Logging out session %s", session_id) secure.delete_session(session_id) response = {"status": "success"} self.set_status(200) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self, enrollment_id): logger.debug("Updating metadata about an enrollment") name = self.get_argument("name", None) open_date = self.get_argument("open_date", None) close_date = self.get_argument("close_date", None) expiry_date = self.get_argument("expiry_date", None) auth_response = authenticate(self, [Permissions.WRITE_ENROLLMENT]) if auth_response['valid']: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if enrollment.owner_id == owner.id: if name is not None: enrollment.name = name if open_date is not None: enrollment.open_date = parser.parse(open_date) if close_date is not None: enrollment.close_date = parser.parse(close_date) if expiry_date is not None: enrollment.expiry_date = parser.parse(expiry_date) enrollment.save() response = {"status": "success"} self.set_status(200) else: response = { "status": "error", "message": "Owner does not have authorization to administer this enrollment" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, instance_id): auth_response = authenticate(self, [Permissions.READ_QUESTION]) if auth_response["valid"]: instance = InstanceService.get_instance(instance_id) state = StateService.get_next_state_in_instance(instance, Status.AWAITING_USER_RESPONSE) if state is None: self.set_status(410) response = { "status": "error", "message": "No response was expected for this survey" } else: survey = SurveyService.get_survey(instance.survey_id) if str(survey.owner_id) == auth_response['owner_id']: question_service = QuestionService() question = question_service.get(survey.protocol_id, state.question_number) if question is not None: self.set_status(200) response = { "status": "success", "question_number": state.question_number, "question_text": question.question_text, "survey_end": question.final } else: self.set_status(410) response = { "status": "error", "message": "No more questions in this survey" } else: self.set_status(403) response = { "status": "error", "message": "Owner has not registered plugin" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self, task_id): auth = authenticate(self, [Permissions.READ_TASK]) if auth['valid']: task = TaskService.get_task(int(task_id)) survey = SurveyService.get_survey(task.survey_id) if survey.owner_id == int(auth['owner_id']): time_rule = TimeRuleService().get(survey.id, task.time_rule_id) date_times = time_rule.get_date_times() dts = [] for dt in date_times: hour_str = str( dt.hour) if dt.hour > 9 else '0' + str(dt.hour) minute_str = str( dt.minute) if dt.minute > 9 else '0' + str(dt.minute) dts.append({ "year": dt.year, "month": dt.month, "day": dt.day, "time": hour_str + ":" + minute_str }) response = {"status": "success", "run_times": dts} self.set_status(200) else: response = { "status": "error", "message": "Plugin is not registered by survey administrator" } self.set_status(403) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self): logger.debug("GET /protocol - retrieving owner's protocols") auth = authenticate(self, [Permissions.READ_PROTOCOL]) if auth['valid']: protocol_objects = ProtocolService.get_protocols_owned_by(auth['owner_id']) protocols = [] for protocol_object in protocol_objects: protocol = { "id": protocol_object.id, "name": protocol_object.name } protocols.append(protocol) response = { "status": "success", "protocols": protocols } response_json = json.dumps(response) logger.debug(response_json) self.set_status(200) self.write(response_json) self.flush() else: logger.debug('Request failed - could not authenticate')
def delete(self): session_id = self.get_argument("session_id") plugin_id = self.get_argument("plugin_id") logger.debug( "Attempting to delete plugin registered to owner of session %s", session_id) owner_id = secure.get_session_owner_id(session_id) logger.debug("Owner of session is %s", owner_id) if owner_id is not None: if PluginService.is_owned_by(plugin_id, owner_id): PluginService.delete_plugin(plugin_id) self.set_status(200) response = {"status": "success"} else: self.set_status(401) response = { "status": "error", "message": "Plugin is not associated with owner" } else: self.set_status(401) response = {"status": "error", "message": "Invalid session"} response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def get(self): session_id = self.get_argument("session_id") logger.debug( "Attempting to get plugins registered to owner of session %s", session_id) owner_id = secure.get_session_owner_id(session_id) logger.debug("Owner of session is %s", owner_id) if owner_id is not None: p = PluginService.get_by_owner_id(owner_id) plugins = [] for plugin in p: plugins.append({ 'id': plugin.id, 'name': plugin.name, 'url': plugin.url, 'icon': plugin.icon }) self.set_status(200) response = {"status": "success", "plugins": plugins} else: self.set_status(401) response = {"status": "error", "message": "No valid session"} response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def delete(self, enrollment_id, participant_id): logger.debug("Removing participant from enrollment") auth_response = authenticate( self, [Permissions.READ_ENROLLMENT, Permissions.WRITE_PARTICIPANT]) if auth_response["valid"]: owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.get(enrollment_id) if owner.id == enrollment.owner_id: participant = ParticipantService.get_participant( participant_id) if participant is None or participant.enrollment_id == enrollment.id: if participant is not None: ParticipantService.delete_participant(participant_id) response = { "status": "success", } self.set_status(200) else: response = { "status": "error", "message": "Participant does not belong to enrollment" } else: response = { "status": "error", "message": "Owner does not have authorization to administer enrollment" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def save_new(self, id_override=None): columns, values = self.get_column_tuples() sql = "INSERT INTO " + self.model.table_name + " " + columns + " VALUES %s" connection = Model.dao.get_connection() try: with connection.cursor() as cursor: cursor.execute(sql, [values]) logger.debug("Executing sql: %s", sql) connection.commit() new_row_id = cursor.lastrowid finally: connection.close() if id_override is None: return self.model.select( Where(self.model.id, Where.EQUAL, new_row_id)) else: return self.model.select( Where(self.model.id, Where.E, id_override))
def post(self): logger.debug("Attempting to verify a session") data = json_decode(self.request.body) username = data["username"] session_id = data["session_id"] splitter = username.find('@') if splitter == -1: self.set_status(401) response = {"status": "error", "reason": "Invalid username"} else: owner_name = username[:splitter] owner_domain = username[splitter + 1:] if secure.session_valid( OwnerService.get(owner_name, owner_domain).id, session_id): self.set_status(200) response = {"status": "success"} else: self.set_status(401) response = { "status": "error", "reason": "Invalid or out of date session" } response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self): logger.debug("Adding new enrollment") name = self.get_argument("name") open_date = self.get_argument("open_date", None) close_date = self.get_argument("close_date", None) expiry_date = self.get_argument("expiry_date", None) auth_response = authenticate(self, [Permissions.WRITE_ENROLLMENT]) if auth_response["valid"]: if open_date is not None: open_date = parser.parse(open_date) if close_date is not None: close_date = parser.parse(close_date) if expiry_date is not None: expiry_date = parser.parse(expiry_date) owner = OwnerService.get_by_id(auth_response["owner_id"]) enrollment = EnrollmentService.add_enrollment( name, owner.id, open_date, close_date, expiry_date) response = {"status": "success", "enrollment_id": enrollment.id} self.set_status(200) else: response = { "status": "error", "message": "Do not have authorization to make this request" } self.set_status(401) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self): logger.debug("Posting new task") task_name = self.get_argument("name") protocol_id = int(self.get_argument("protocol_id")) enrollment_id = int(self.get_argument("enrollment_id")) time_rule = json.loads(self.get_argument("time_rule")) enable_notes = self.get_argument("enable_notes", False) timeout = int(self.get_argument("timeout"), 20) enable_warnings = self.get_argument("enable_warnings", True) enable_notes = 1 if enable_notes else 0 enable_warnings = 1 if enable_warnings else 0 all_run_times = [] all_run_dates = [] local_tz = pytz.timezone(time_rule['timezone']) date_conversion = time_rule["run_date"] time_conversion = time_rule["run_times"] for several_run_time in time_conversion: datetime_without_tz = datetime.strptime( str(date_conversion) + " " + str(several_run_time), "%Y-%m-%d %H:%M") datetime_with_tz = local_tz.localize( datetime_without_tz, is_dst=True) # No daylight saving time datetime_in_utc = datetime_with_tz.astimezone(pytz.utc) str_utc_time = datetime_in_utc.strftime('%Y-%m-%d %H:%M %Z') all_run_dates.append(str_utc_time[:10]) all_run_times.append(str_utc_time[11:16]) time_rule["run_date"] = str_utc_time[:10] time_rule["run_times"] = all_run_times auth = authenticate(self, [Permissions.WRITE_TASK, Permissions.WRITE_SURVEY]) if auth["valid"]: owner_id = int(auth['owner_id']) response = None if ProtocolService.is_owned_by(protocol_id, int(auth['owner_id'])): if EnrollmentService.is_owned_by(enrollment_id, owner_id): params = time_rule["params"] run_time_values = time_rule["run_times"] run_times = [] for run_time_value in run_time_values: rtv = run_time_value.split(":") hour = int(rtv[0]) minute = int(rtv[1]) run_times.append( datetime.now(tz=pytz.utc).replace(hour=hour, minute=minute, second=0)) until = datetime.strptime( time_rule["run_date"], "%Y-%m-%d").replace(tzinfo=pytz.utc) run_date = datetime.strptime( time_rule["run_date"], "%Y-%m-%d").replace(tzinfo=pytz.utc) last_date = datetime.strptime(time_rule["run_date"], "%Y-%m-%d") start_date = datetime.strptime(time_rule["run_date"], "%Y-%m-%d") intervalcount = 'no_repeat' every = 0 if time_rule["type"] == 'no_repeat': intervalcount = 'no_repeat' time_rule = NoRepeat(run_date, run_times) elif time_rule["type"] == 'daily': intervalcount = 'daily' every = int(params["every"]) until = datetime.strptime( time_rule['until'], "%Y-%m-%d").replace(tzinfo=pytz.utc) last_date = datetime.strptime(time_rule['until'], "%Y-%m-%d") time_rule = RepeatsDaily(run_date, every, until, run_times) elif time_rule["type"] == 'weekly': intervalcount = 'weekly' every = int(params["every"]) until = datetime.strptime( time_rule['until'], "%Y-%m-%d").replace(tzinfo=pytz.utc) time_rule = RepeatsWeekly(every, params['days'], run_times, run_date, until) elif time_rule["type"] == 'monthly_date': intervalcount = 'monthly_date' every = int(params["every"]) until = datetime.strptime( time_rule['until'], "%Y-%m-%d").replace(tzinfo=pytz.utc) time_rule = RepeatsMonthlyDate(every, params['dates'], until, run_times) elif time_rule["type"] == 'monthly_day': intervalcount = 'monthly_day' every = int(params["every"]) until = datetime.strptime( time_rule['until'], "%Y-%m-%d").replace(tzinfo=pytz.utc) time_rule = RepeatsMonthlyDay(every, params['param1'], params['days'], until, run_times) else: response = { "status": "error", "message": time_rule['type'] + " is not a valid time rule" } self.set_status(400) for daysNo in range((last_date - start_date).days + 1): DataManagement.dataStorage.append(enrollment_id) listParticipants = [] participants = ParticipantService.get_participants_in_enrollment( enrollment_id) for participant in participants: listParticipants.append(participant.id) DataManagement.dataStorage.append(listParticipants) DataManagement.dataStorage.append(start_date) DataManagement.dataStorage.append(run_time_values) DataManagement.dataStorage.append("cig_ecig") DataManagement.dataStorage.append(until) DataManagement.dataStorage.append(intervalcount) DataManagement.dataStorage.append(protocol_id) DataManagement.dataStorage.append("scheduled") DataManagement.get_schedule() start_date = start_date + timedelta(days=every) else: response = { "status": "error", "message": "Enrollment not owned by account" } self.set_status(401) else: response = { "status": "error", "message": "Protocol not owned by account" } self.set_status(401) if response is None: survey = SurveyService.create_survey(owner_id, protocol_id, enrollment_id, enable_notes, timeout, enable_warnings) time_rule_id = TimeRuleService().insert(survey.id, time_rule) TaskService.create_task(task_name, survey.id, time_rule_id) DataManagement.getSurveyid(survey.id) response = {"status": "success"} self.set_status(200) response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()
def post(self): data = json_decode(self.request.body) session_id = data["session_id"] plugin_url = data["plugin_url"] logger.debug("Attempting to register plugin to owner of session %s", session_id) owner_id = secure.get_session_owner_id(session_id) logger.debug("Owner of session is %s", owner_id) if owner_id is not None: r = requests.get(plugin_url + "/info") if r.status_code != 200: self.set_status(400) response = { "status": "error", "message": "Something went wrong in the request to the plugin" } else: try: r = r.json() plugin_name = r["name"] plugin_permissions = r["permissions"] plugin_icon = r["icon"] plugin, token = PluginService.register_plugin( plugin_name, owner_id, plugin_url, plugin_icon, plugin_permissions) data = { "owner_id": owner_id, "plugin_id": plugin.id, "token": token, "url": os.environ.get("SYSTEM_URL") } post = requests.post(plugin_url + "/register/", json=data) p = post.json() if post.status_code == 200 and "status" in p and p[ "status"] == "success": self.set_status(200) response = {"status": "success"} elif post.status_code != 200: self.set_status(400) response = { "status": "error", "message": "Plugin raised error on registration" } else: self.set_status(400) response = { "status": "error", "message": "Plugin did not respond to request as expected" } except ValueError: self.set_status(400) response = { "status": "error", "message": "Plugin did not respond to request as expected" } else: self.set_status(401) response = {"status": "error", "message": "Invalid session"} response_json = json.dumps(response) logger.debug(response_json) self.write(response_json) self.flush()