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)
