def post(self): args = self.parser.post().parse_args() name = args.get("name", None) exists = Category.query.filter_by(name=name).scalar() is not None if exists: raise abort(400, "Tag already exists") new_category = Category(name=name) create_instances(new_category, "category") return jsonify("Succeed")
def insert_data(self, request_obj): self.request_obj = request_obj data = dict( self.query, **{ "_id": str(uuid.uuid4()), "updated_at": datetime.datetime.utcnow().isoformat() }) inserted_docs = m.insert(schema=self.schema, collection=self.collection, data=data) log.debug( f"Inserting data with query {self.query} got {inserted_docs}") if len(inserted_docs) == 0: abort(404, reason='Could not insert data') if isinstance(inserted_docs, str): abort(500, reason=inserted_docs) return "SUCCESS"
def post(self, name): global model_swapping_map data = request.json from_data = get_datasource_path(data.get('data_source_name')) try: format_flag = data.get('format_flag') except: format_flag = 'explain' try: kwargs = data.get('kwargs') except: kwargs = {} if type(kwargs) != type({}): kwargs = {} if from_data is None: from_data = data.get('from_data') if from_data is None: from_data = data.get('when_data') if from_data is None: abort(400, 'No valid datasource given') # Not the fanciest semaphor, but should work since restplus is multi-threaded and this condition should rarely be reached while name in model_swapping_map and model_swapping_map[name] is True: time.sleep(1) mdb = mindsdb.Predictor(name=name) try: results = mdb.predict(when_data=from_data, **kwargs) except: results = mdb.predict(when=from_data, **kwargs) return preparse_results(results, format_flag)
def patch(self, uid): parameter = orm_utils.get_or_404_parameter_with_uid(uid) edit_parameter_info = UPDATE_PARAMETER_SCHEMA.dump(parameter) patch_data = request.get_json() # @UndefinedVariable if not patch_data: abort(400, "No updates provided with request") edit_parameter_info.update(patch_data) validation_errors = UPDATE_PARAMETER_SCHEMA.validate( edit_parameter_info) if validation_errors: abort(400, f"Validation error(s): {validation_errors}") for key in patch_data: new_value = PARAMETER_SCHEMA.fields[key].deserialize( edit_parameter_info[key]) setattr(parameter, key, new_value) resource_utils.perform_orm_commit_or_500(parameter, operation="update") parameter_info = PARAMETER_SCHEMA.dump(parameter) response_content = { 'message': 'parameter updated', "parameter": parameter_info, "parameter_url": url_for('.parameter', uid=uid), "parameter_set_url": url_for('.parameter_set'), } return response_content
def post(self, server_type, server_id): """Create a new Counter""" form = ns.payload server_group_id = get_group_id(server_type, server_id) if (Counter.query.filter_by(server_group_id=server_group_id).filter( func.lower(Counter.name) == form["name"].lower()).first() is not None): abort(400, f"Counter {form['name']} already exists") response = None if "response" in form: response = form["response"] if response is None: # response could still be None from the post data response = f"Counter {form['name']}" + " is now at {}" counter = Counter( server_group_id=server_group_id, name=form["name"], count=form.get("count", 0), response=response, ) db.session.add(counter) db.session.commit() return counter
def post(self): ''' Add new feature, update it with users if name is identical''' feature = FeatureDB.get_by_name(api.payload.get('name')) try: if feature: feature.add_users(api.payload.get('users', [])) else: feature = FeatureDB(**api.payload) db.session.commit() except Exception as exc: return abort(message=exc) return feature, HTTPStatus.CREATED
def post(self): body = api.payload try: player = Player.objects.get(username=body["username"]) except DoesNotExist: try: player = Player.objects.get(email=body["username"]) except DoesNotExist: abort(404, "User Not Found", error="The username or email does not exist") authorized = player.check_password_hash(body["password"]) if not authorized: abort(401, "Unauthorized", error="Invalid username/email password combination") # return {"error": "Invalid username/email password combination"}, 401 expires = datetime.timedelta(days=7) fresh = datetime.timedelta(minutes=30) access_token = create_access_token(str(player.id), expires_delta=expires, fresh=fresh) return {"token": access_token}, 200
def post(self): form = ns.payload serverId = form["id"] serverName = form["name"] server = DiscordServer.query.get(serverId) if server is None: serverGroup = None if "server_group_id" in form: serverGroup = ServerGroup.query.get(form["server_group_id"]) if serverGroup is None: abort(400, "Passed server group does not exist") else: serverGroup = ServerGroup(name=f"{serverName}_group") db.session.add(serverGroup) server = DiscordServer(id=serverId, name=serverName, server_group=serverGroup) db.session.add(server) db.session.commit() app.logger.info(f"added server: {server}") return server else: abort(404)
def delete_db_item(self, sql_alchemy_model, item_id_dict): """ Deletes db item Args: sql_alchemy_model ([type]): [description] item_id_dict ([type]): [description] Returns: [type]: [description] """ db_item = sql_alchemy_model.query.filter_by(**item_id_dict).first_or_404( description="There is no data with item id %s" % str(item_id_dict) ) try: self.session.delete(db_item) self.session.commit() return True except Exception as ex: print(ex) # log.exception(str(ex)) self.session.rollback() abort(HTTPStatus.INTERNAL_SERVER_ERROR, str(ex))
def get(self, name): '''return data rows''' ds = ca.default_store.get_datasource(name) if ds is None: abort(400, 'No valid datasource given') params = {'page[size]': None, 'page[offset]': None} where = [] for key, value in request.args.items(): if key == 'page[size]': params['page[size]'] = int(value) if key == 'page[offset]': params['page[offset]'] = int(value) elif key.startswith('filter'): param = parse_filter(key, value) if param is None: abort(400, f'Not valid filter "{key}"') where.append(param) data_dict = ca.default_store.get_data(name, where, params['page[size]'], params['page[offset]']) return data_dict, 200
def get_student_last_lesson( subject, student): if subject == "letters": subject_name = "Français" dataset = "gp" else: subject_name = "Maths" dataset = "numbers" lessons = db.student_lessons.find_one({"student": student, "dataset": dataset}, {"_id":0, "lessons":0}) last_lesson_id = lessons["lesson_ids"][-1] if len(chapters) == 0: raise abort(404, "Pas de données pour l'étudiant {} sur le sujet {}".format(student, subject)) last_lesson = db.student_lesson.find_one({"student": student, "dataset": dataset, "lesson":last_lesson_id}, {"_id":0, "records":0}) last_lesson["start"] = convert_datetime_to_str(last_chapter["start"]) last_lesson["end"] = convert_datetime_to_str(last_chapter["end"]) return convert_raw_data({"data": last_lesson})
def post(self, name): global model_swapping_map data = request.json from_data = ca.default_store.get_datasource_obj( data.get('data_source_name'), raw=True) if from_data is None: abort(400, 'No valid datasource given') try: format_flag = data.get('format_flag') except: format_flag = 'explain' try: kwargs = data.get('kwargs') except: kwargs = {} if type(kwargs) != type({}): kwargs = {} # Not the fanciest semaphore, but should work since restplus is multi-threaded and this condition should rarely be reached while name in model_swapping_map and model_swapping_map[name] is True: time.sleep(1) if is_custom(name): return ca.custom_models.predict(name, from_data=from_data, **kwargs) else: results = ca.mindsdb_native.predict(name, when_data=from_data, **kwargs) return preparse_results(results, format_flag)
def get(self, name): '''List of predictors colums''' try: model = ca.mindsdb_native.get_model_data(name) except Exception: abort(404, 'Invalid predictor name') columns = [] for array, is_target_array in [ (model['data_analysis']['target_columns_metadata'], True), (model['data_analysis']['input_columns_metadata'], False) ]: for col_data in array: column = { 'name': col_data['column_name'], 'data_type': col_data['data_type'].lower(), 'is_target_column': is_target_array } if column['data_type'] == 'categorical': column['distribution'] = col_data["data_distribution"][ "data_histogram"]["x"] columns.append(column) return columns, 200
def post(self, name): data = request.json format_flag = data.get('format_flag', 'explain') kwargs = data.get('kwargs', {}) use_raw = False if is_custom(name): use_raw = True from_data = ca.default_store.get_datasource_obj( data.get('data_source_name'), raw=use_raw) if from_data is None: abort(400, 'No valid datasource given') if is_custom(name): return ca.custom_models.predict(name, from_data=from_data, **kwargs) results = ca.naitve_interface.predict(name, format_flag, when_data=from_data, **kwargs) return results
def get(self, challenge_id: str): args = attest_parser.parse_args(strict=True) user_id: str = args["user_id"] oracle_address: str = args["oracle"] specifier: str = args["specifier"] decoded_user_id = decode_with_abort(user_id, ns) db = get_db_read_replica() with db.scoped_session() as session: try: owner_wallet, signature = get_attestation( session, user_id=decoded_user_id, oracle_address=oracle_address, specifier=specifier, challenge_id=challenge_id, ) return success_response({ "owner_wallet": owner_wallet, "attestation": signature }) except AttestationError as e: abort(400, e) return None
def patch(self, uid): value = orm_utils.get_or_404_value_with_uid(uid) edit_value_info = UPDATE_VALUE_SCHEMA.dump(value) patch_data = request.get_json() # @UndefinedVariable if not patch_data: abort(400, "No updates provided with request") edit_value_info.update(patch_data) validation_errors = UPDATE_VALUE_SCHEMA.validate(edit_value_info) if validation_errors: abort(400, f"Validation error(s): {validation_errors}") for key in patch_data: new_value = VALUE_SCHEMA.fields[key].deserialize( edit_value_info[key]) setattr(value, key, new_value) resource_utils.perform_orm_commit_or_500(value, operation="update") value_info = VALUE_SCHEMA.dump(value) puid = value_info['parameter'] response_content = { 'message': 'value updated', "value": value_info, "value_url": url_for('.value', uid=uid), "parameter_url": url_for('.parameter', uid=puid), } return response_content
def put(self): args = forgotuser_parser.parse_args() email_id = args["email"].lower() password = args["password"] one_time_pass = args["OTP"] user = User.query.filter_by(email_id=email_id).first() if not user: return abort(404, "User not found") if len(password) < 8: return abort(411, "Password should be atleast 8 characters") if " " in password: return abort(422, "Password cannot contain spaces") if one_time_pass != str(user.otp): return abort(422, "The OTP you entered is incorrect!") update_password(password=password, user=user, db=db) message_content = "ALERT! Your password for Simvestr has been changed. Please contact us if this wasn't you." # sends a confirmation email to the user send_email(email_id, "Password updated successfully", message_content) return 200
def get(self): """Show all output settings and statuses.""" if not utils_general.user_has_permission('view_settings'): abort(403) try: list_data = get_from_db(OutputSchema, Output) list_channels = get_from_db(OutputChannelSchema, OutputChannel) states = get_all_output_states() # Change integer channel keys to strings (flask-restx limitation?) new_state_dict = {} for each_id in states: new_state_dict[each_id] = {} for each_channel in states[each_id]: new_state_dict[each_id][str(each_channel)] = states[each_id][each_channel] if list_data: return {'output devices': list_data, 'output channels': list_channels, 'output states': new_state_dict}, 200 except Exception: abort(500, message='An exception occurred', error=traceback.format_exc())
def put(self, dancing_class_id, dancing_class_person_id): """Update dancing class attendee""" dancing_class: DancingClass = DancingClass.query.filter( DancingClass.id == dancing_class_id).first() attendee: DancingClassPerson = DancingClassPerson.query\ .filter(DancingClassPerson.id == dancing_class_person_id, DancingClassPerson.dancing_class_id == dancing_class_id).first() person: Person = Person.query.filter( Person.id == api.payload["person_id"]).first() if dancing_class and attendee and person: attendee.person = person if "notes" in api.payload: attendee.notes = api.payload["notes"] db.session.commit() return dancing_class.json(include_attendees=True) return abort(404)
def post(self, dancing_class_id): """Add attendee""" dancing_class: DancingClass = DancingClass.query.filter( DancingClass.id == dancing_class_id).first() person: Person = Person.query.filter( Person.id == api.payload["person_id"]).first() if dancing_class and person: dcp = DancingClassPerson() dcp.dancing_class = dancing_class dcp.person = person if "notes" in api.payload: dcp.notes = api.payload["notes"] db.session.add(dcp) db.session.commit() return dancing_class.json(include_attendees=True) return abort(404)
def get_student_subject_info(student, subject): db = connect() try: student = int(student) except ValueError: return abort( 406, "L'identifiant de l'élève {} est incorrect.".format(student)) if int(student) not in range(111, 60821): return abort( 406, "L'identifiant de l'élève {} est incorrect.".format(student)) if int(student) not in db.students.distinct("student"): return abort(404, "L'élève {} n'a pas été trouvé.".format(student)) if subject not in db.datasets.distinct("subject"): return abort(406, "Le nom du sujet {} est incorrect.".format(subject)) if db.student_dataset.count_documents({}) == 0: return abort(500, "Table student_subject is empty.") else: student_dataset = db.student_subject.find_one( { "student": student, "subject": subject }, { "_id": 0, "records": 0 }) if student_dataset is None: return abort( 404, "Aucune donnée disponible pour l'élève {} et le sujet {}.". format(student, subject)) timespent = time.strftime('%H:%M:%S', time.gmtime(student_dataset["timespent"])) student_dataset["timespent_sec"] = student_dataset["timespent"] student_dataset["timespent"] = timespent if student_dataset["subject"] == "letters": subject = "letters" subject_name = "Français" else: subject = "numbers" subject_name = "Maths" del student_dataset["start"] del student_dataset["end"] print(student_dataset["datasets"]) student_dataset["datasets"] = "|".join( [str(n) for n in student_dataset["datasets"]]) student_dataset["timespent_by_dataset"] = "|".join( [str(n) for n in student_dataset["timespent_by_dataset"]]) # del student_dataset["sequences"] del student_dataset["days"] status = True code = 200 msg = convert_raw_data({"data": student_dataset}) return msg
def post(self): args = forgotuser_email_parser.parse_args() email_id = args["email"].lower() user = User.query.filter_by(email_id=email_id).first() if not user: return abort(404, "User not found") # set an otp in the user's dB so multiple users can reset pwd at the same time otp = str(random.randint(1000, 9999)) update_otp(otp=otp, user=user, db=db) message_content = f"ALERT! You have requested password change for your Simvestr account. " \ f"Please copy the 4 digit OTP {user.otp}." # sends a confirmation email to the user send_email(user.email_id, f"Forgot Password - OTP: {user.otp}", message_content) return {"email": email_id}, 200
def put(self): '''Update a classroom''' db = connect() classroom = request.json["classroom"] # students = request.json["students"]) group = request.json["group"] for n in students: if not str(n).startswith(classroom): return abort( 406, "Student doesn't belong to classroom: student ID must start with classroom ID" ) # for n in db.students.find({"classroom":classroom}): # db.students.update({"_id":n["_id"]} {"$set":{"group": group, "classroom": classroom}}) return { "message": "Sucessfully udpated classroom {}".format(classroom) }, 204
def post(self, dancing_class_id): """Create couple""" dancing_class: DancingClass = DancingClass.query.filter( DancingClass.id == dancing_class_id).first() person: DancingClassPerson = DancingClassPerson.query\ .filter(DancingClassPerson.id == api.payload["person_id"]).first() partner: DancingClassPerson = DancingClassPerson.query\ .filter(DancingClassPerson.id == api.payload["partner_id"]).first() if dancing_class and person and partner: dcc = DancingClassCouple() dcc.dancing_class = dancing_class dcc.person = person dcc.partner = partner db.session.add(dcc) db.session.commit() return dancing_class.json(include_attendees=True) return abort(404)
def delete(self, category_id): # Delete a category from the menu role = get_jwt_claims().get('role') # Make sure user is a manager if db.get_staff_title(role) != 'Manage': abort(400, 'User is not a manager') items = menu_db.get_items_by_category(category_id) if items is None: abort(500, 'Something went wrong') elif (len(items) > 0): abort(400, 'Can only delete empty category') # Delete a category if (not menu_db.delete_category(category_id)): abort(500, 'Something went wrong') return jsonify({'status': 'success'})
def delete(self): player_id = get_jwt_identity() char_id = request.args.get("character_id") if not char_id: abort(400, "Bad Query") char_obj = Character.objects.with_id(char_id) if not char_obj: abort(404, "Character Does Not Exist") if not str(char_obj.owner.id) == player_id: abort(401, "Bad Owner") char_obj.delete() return Response("Character Deleted", 204)
def get(self): """ VIEW downloaded files ## Method SELECT * from files ## Documentation Consult [admin documentation](http://doc.ludoeducation.fr/researcher-guide/admin/) """ db = connect() files = list(db.files.find({}, {"_id":0})) if len(files) == 0: return abort(404, "no files found") return {"files": sorted(files, key =lambda x: x["filename"]), "count": len(files), "csv": "{}/csv".format(request.base_url)}
def post(self, owner_name, username): file = request.files.get("face", None) if file is None or file.filename == "": abort(400, message="Missing file") session = Session() owner = session.query(Owner).filter(Owner.name == owner_name).first() if owner is None: abort(404, message="Owner not found") public_key = ( int(owner.public_key1), int(owner.public_key2), ) with tempfile.TemporaryDirectory() as tempdir: if not file or not allowed_file(file.filename): abort(400, message="File not permitted") filename = pathlib.Path(secure_filename(file.filename)) filepath = (tempdir / filename).as_posix() file.save(filepath) embeddings, emb_sum = global_rec.get_crypt_encodings( filepath, public_key) user_obj = session.query(User).filter( User.name == username).first() if user_obj is None: abort(404, message="User not found") emb_list = [int(emb.value) for emb in user_obj.embeddings] distance = global_rec.compare(filepath, int(user_obj.embedding_sum), emb_list, public_key) session.close() return {"distance": distance.val}, 200
def get(self, classroom): """ VIEW classroom item ## Method SELECT student FROM table students WHERE student.classroom == _<classroom>_ ## Documentation Consult [admin documentation](http://doc.ludoeducation.fr/researcher-guide/admin/) """ db = connect() students = [n for n in db.students.find({"classroom": int(classroom)})] if len(students) == 0: return abort(404, "no classroom `{}` found".format(classroom)) return {"classroom": students, "count": len(students), "csv": "{}/csv".format(request.base_url)}
def decorator(*args, **kwargs): token = request.headers.get(AUTH_HEADER_KEY) token_chunks = token.split(' ') if token else [] if len(token_chunks) > 1: token = token_chunks[1] auth_token = AuthTokens.get(token=token) if not auth_token: return abort(code=HTTPStatus.UNAUTHORIZED, message='Authentication is required') try: setattr(args[0], 'auth_token', auth_token) except Exception: pass return function(*args, **kwargs)