def post(self, name):
project_parse = reqparse.RequestParser()
project_parse.add_argument('name',
type=non_empty_string,
required=True,
help='Name is required')
project_parse.add_argument('description',
type=non_empty_string,
required=True,
help="description is required")
project_parse.add_argument('project_color_identity',
type=non_empty_string,
required=True,
help="project_color_identity is required")
project = ProjectModel.find_by_name(name)
if project:
return {
"ProjectAlreadyExistsError": {
"message": "Project with given name already exists",
"status": 400
}
}
data = project_parse.parse_args()
project = ProjectModel(data['name'], data['description'],
get_jwt_identity(),
data['project_color_identity'])
project.save_to_db()
return {"message": "Project Created", "status": 200}
def create():
# Process data
dataJSON = json.loads(request.form['data'])
audio = request.files['audio']
data, error = project_schema.load(dataJSON)
# If an error, return status code (400).
if error:
return custom_response(error, 400)
# Add audio to bucket
if minioClient.bucket_exists(data['username']):
minioClient.put_object(data['username'], data['name'], audio,
dataJSON['audioSize'])
else:
return custom_response(
'User does not exist for the project you are creating!', 400)
# Save the model
project = ProjectModel(data)
user = UserModel.query.filter_by(username=project.username).first()
user.projects.append(project)
project.save()
UserModel.commit()
# Send a successful response to the client.
return custom_response(data, 201)
def post(self):
"""This method handle the creation of new Projects"""
data = PARSER.parse_args()
owner = get_jwt_identity()
project = ProjectModel(data.title, data.description, owner)
res = project.insert()
return {'message': res['message']}
def setUp(self) -> None:
"""Create all db tables before each test"""
self.client = app.test_client()
self.app_context = app.app_context()
with self.app_context:
db.create_all()
self.keynote_1 = KeynoteModel(**TEST_KEYNOTE_1)
self.keynote_2 = KeynoteModel(**TEST_KEYNOTE_2)
self.member_1 = MemberModel(**TEST_MEMBER_1)
self.member_2 = MemberModel(**TEST_MEMBER_2)
self.meeting_1 = MeetingModel(**TEST_MEETING_1)
self.meeting_2 = MeetingModel(**TEST_MEETING_2)
self.permission_1 = PermissionModel(**TEST_PERMISSION_1)
self.permission_2 = PermissionModel(**TEST_PERMISSION_2)
self.permission_3 = PermissionModel(**TEST_PERMISSION_3)
self.permission_4 = PermissionModel(**TEST_PERMISSION_4)
self.permission_5 = PermissionModel(**TEST_PERMISSION_5)
self.permission_6 = PermissionModel(**TEST_PERMISSION_6)
self.permission_7 = PermissionModel(**TEST_PERMISSION_7)
self.permission_8 = PermissionModel(**TEST_PERMISSION_8)
self.project_1 = ProjectModel(**TEST_PROJECT_1)
self.project_2 = ProjectModel(**TEST_PROJECT_2)
self.role_1 = RoleModel(**TEST_ROLE_1)
self.role_2 = RoleModel(**TEST_ROLE_2)
self.role_3 = RoleModel(**TEST_ROLE_3)
self.role_4 = RoleModel(**TEST_ROLE_4)
self.role_5 = RoleModel(**TEST_ROLE_5)
self.speaker_1 = SpeakerModel(**TEST_SPEAKER_1)
self.speaker_2 = SpeakerModel(**TEST_SPEAKER_2)
def post(self):
data = ProjectList.parser.parse_args()
y, m, d = data['to_date'].split('-')
project = ProjectModel(data['name'], datetime.datetime(int(y), int(m), int(d)))
try:
project.save_to_db()
except:
return {'message': 'An error occured inserting the project'}, 500
return project.json(), 201
def post(self):
data = NewProject.parser.parse_args()
user_id = get_jwt_identity()
check_projects = ProjectModel.get_projects_by_user_id(user_id)
check_projects = [
pr for pr in check_projects if pr.name == data['name']
]
if check_projects:
return {
'message':
"A project with name '{}' already exists.".format(data['name'])
}, 400
# Create a new project
project = ProjectModel(id=None, **data)
try:
project.save_to_db()
except Exception as e:
print(e)
return {"message": "An error occurred inserting the item."}, 500
# Map the project to the user
mapping_user = UserProjectMap(user_id=user_id, project_id=project.id)
try:
mapping_user.save_to_db()
except:
project.delete_from_db()
return {
"message": "An error occurred mapping the user to the project."
}, 500
return project.json(), 201
def post(self, pname):
data = Project.parser.parse_args()
# TODO: fix this <class 'werkzeug.local.LocalProxy'> to int problem
project = ProjectModel(pname, data['description'],
int(current_identity), data['roles'])
# print((data['roles']))
# for rolestr in data['roles']:
# print(eval(rolestr))
# save roles
try:
project.save_to_db()
except:
return {"message": "An error occured inserting the project"}, 500
return project.json(), 201
def post(self):
data = Projects.parser.parse_args()
project = ProjectModel(name=data['name'], user_id=data['user_id'])
if (UserModel.find_by_id(project.user_id)):
try:
project.save_to_db()
return project.json(), 201
except:
return {
"message": "An error occurred inserting the project."
}, 500
else:
return {"message": "The associated user does not exist."}, 500
def delete(self, name):
# user id,project id,task_name
parse = reqparse.RequestParser()
parse.add_argument('uuid',
type=non_empty_string,
required=True,
help='uuid Required..')
data = parse.parse_args()
project = ProjectModel.find_by_id(data['uuid'])
if project:
task = TaskModel.query.filter(
and_(TaskModel.uuid == data['uuid'],
TaskModel.task_name == name)).first()
if task:
if project.created_by_id == get_jwt_identity():
# owner
task.delete_from_db()
return {"Message": "Task Deleted", "status": 200}
else:
collaborator = ShareProjectModel.query.filter(
and_(
ShareProjectModel.share_with_id ==
get_jwt_identity(),
ShareProjectModel.uuid == project.uuid)).first()
if collaborator:
if collaborator.permission == 'Delete':
# share with permission to delete
task.delete_from_db()
return {"Message": "Task Deleted", "status": 200}
return {
"UnauthorizedError": {
"message":
"You don't have permission to Delete Task.",
"status": 401
}
}
return {
"CollaboratorNotExistsError": {
"message":
"User with given id is not a part of this project or not owner",
"status": 400
}
}
return {
"TaskNotExistsError": {
"message": "Task with given name doesn't exists",
"status": 400
}
}
return {
"ProjectNotExistsError": {
"message": "Project with given id doesn't exists",
"status": 400
}
}
def get(self):
return {
'projects':
list(
map(lambda x: x.json(),
ProjectModel.get_projects_by_user_id(get_jwt_identity())))
}
def get(self, project_id, id):
if len(ProjectModel.find_by_id(project_id)) == 0:
return {'message': 'Project not found'}, 404
executions = ExecutionModel.find_by_id_and_project_id(id, project_id)
if executions:
return {'execution': executions[0].json()}
return {'message': 'Execution not found'}, 404
def post(cls, project: str, title: str):
project = ProjectModel.find_by_name(project)
if not project:
return {'message': gettext("project_not_found").format(project)}, 400
current_user = get_jwt_identity()
user = UserModel.find_by_username(current_user)
if user not in project.authorized:
return {'message': gettext("project_not_authorized")}, 401
for taskItem in project.task:
if taskItem.title == title:
return {'message': gettext("task_name_exists").format(title)}, 400
task_json = request.get_json()
task_json['title'] = title
if "assigned" in task_json:
user_assg = UserModel.find_by_username(task_json['assigned'])
task_json.pop("assigned")
else:
user_assg = None
task = task_schema.load(task_json)
task['createdate'] = datetime.now()
task['owner'] = user
task['status'] = "Boşta"
if user_assg:
task['assigned'] = user_assg
print(task.to_json())
try:
project.task.append(task)
project.save()
except:
return {"message": gettext("task_error_creating")}, 500
return task_schema.dump(task), 201
def post(self, name):
data = Task.parse.parse_args()
project = ProjectModel.query.filter_by(uuid=data['uuid']).first()
if project:
if project.created_by_id == get_jwt_identity():
# owner
if TaskModel.find_by_name(name):
return {
"TaskAlreadyExistsError": {
"message": "Task with given name alredy exists.",
"status": 401
}
}
task = TaskModel(name, data['task_desc'], data["uuid"])
task.save_to_db()
project = ProjectModel.find_by_id(data['uuid'])
project.task_id = task
project.save_to_db()
return {"Message": "Task Added...", "status": 200}
else:
return {
"UnauthorizedError": {
"message": "Project Owner can only create task.",
"status": 401
}
}
return {
"ProjectNotExistsError": {
"message": "Project with given id doesn't exists",
"status": 400
}
}
def get(self, pname):
project = ProjectModel.find_by_name(pname)
if project:
return project.json(), 200
return {
'message': "Project named '{}' is not found".format(pname)
}, 404
def get(self, id):
current_user_id = get_jwt_identity()
project = ProjectModel.find_by_id(id)
if not project:
return {"message": "project not found"}, 404
if project.is_archived == True:
return {"message": "project already archived"}
if project.user_id != current_user_id:
return {"message": "Unauthorized"}, 401
# tasks = Comment.query.filter_by(thread_id=thread.id)\
# .order_by(Comment.created_at.desc())\
# .all()
tasks = TaskModel.query.filter(TaskModel.project_id==id)\
.all()
print(tasks)
# current_user_id = get_jwt_identity()
# if current_user_id:
# tasks = [x.json() for x in TaskModel.query.filter(TaskModel.user_id==current_user_id).all()]
#
# task_termined = [r._asdict() for r in tasks]
for row in tasks:
print(row)
return {"message": "project_task_termined"}, 200
def put(self, id):
current_user_id = get_jwt_identity()
project = ProjectModel.find_by_id(id)
if not project:
return {"message": "project not found"}, 404
if current_user_id != project.user_id:
return {"message": "Unauthorized"}, 401
data = Project.parser.parse_args()
project_name = data["project_name"]
if not project_name:
project_name = project.project_name
description = data['description']
if not description:
description = project.description
try:
project.project_name = project_name
project.description = description
project.save_to_db()
except:
return {"message": "An error occured updating the Project"}, 500
project_id = project.id
project_name = project.project_name
description = project.description
is_archived = project.is_archived
return {
"project_id": project_id,
"project_name": project_name,
"description": description,
"is_archived": is_archived
}, 201
def get(self, id):
current_user_id = get_jwt_identity()
project = ProjectModel.find_by_id(id)
if not project:
return {"message": "project not found"}, 404
if project.user_id != current_user_id:
return {"message": "Unauthorized"}, 401
number_tasks = (db.session.query(
func.count(TaskModel.id).label('total_task')).join(
ProjectModel, TaskModel.project_id == ProjectModel.id).filter(
TaskModel.project_id == project.id).filter(
TaskModel.user_id == current_user_id).scalar())
number_tasks_termined = (db.session.query(
func.count(TaskModel.id).label('total_task_temined')).filter(
TaskModel.project_id == project.id).filter(
TaskModel.status == False).filter(
TaskModel.user_id == current_user_id).scalar())
if number_tasks == 0:
return {"message": "Not task"}
percentage = number_tasks_termined * 100 / number_tasks
return {
"number_tasks": number_tasks,
"number_tasks_termined": number_tasks_termined,
"percentage": percentage
}, 200
def get(cls, project: str):
project = ProjectModel.find_by_name(project)
if not project:
return {'message': gettext("project_not_found").format(project)}, 400
current_user = get_jwt_identity()
user = UserModel.find_by_username(current_user)
if user not in project.authorized:
return {'message': gettext("project_not_authorized")}, 401
return {'task': task_list_schema.dump(project.task)}, 200
def get(cls, name: str):
project = ProjectModel.find_by_name(name)
if not project:
return {'message': gettext("project_not_found")}, 404
current_user = get_jwt_identity()
user = UserModel.find_by_username(current_user)
if user not in project.authorized:
return {'message': gettext("project_not_authorized")}, 401
return project_schema.dump(project), 200
def test_find_by_id(self):
with self.app_context:
self.role_1.save_to_db()
self.member_1.save_to_db()
poject_id = self.project_1.save_to_db().id
project = ProjectModel.find_by_id(poject_id)
self.assertEqual(project.title, "REST API para sitio web")
def test_find_by_status(self):
with self.app_context:
self.role_1.save_to_db()
self.member_1.save_to_db()
poject_id = self.project_1.save_to_db().id
projects = ProjectModel.find_by_status("in progress")
self.assertEqual(projects[0].id, poject_id)
def test_find_by_admin_id(self):
with self.app_context:
self.role_1.save_to_db()
admin_id = self.member_1.save_to_db().id
poject_id = self.project_1.save_to_db().id
projects = ProjectModel.find_by_admin_id(admin_id)
self.assertEqual(projects[0].id, poject_id)
def get(self, project_id):
if len(ProjectModel.find_by_id(project_id)) == 0:
return {'message': 'Project not found'}, 404
return {
'executions':
list(
map(lambda x: x.json(),
ExecutionModel.find_executions_by_project_id(project_id)))
}
def get(self, project_id):
user_id = get_jwt_identity()
result = ProjectModel.find_one_by_id(project_id, user_id)
columns_filter_id = result.columns_filter_id
columns_filter = ProjectUnstructureModel.find_by_object_id(
ObjectId(columns_filter_id))
return {
'message': SUCCESS_MESSAGE.format('columns_filter'),
'columns_filter': columns_filter['columns']
}
def get(self, project_id, id):
data = ExecutionOutput.parser.parse_args()
if len(ProjectModel.find_by_id(project_id)) == 0:
return {'message': 'Project not found'}, 404
exec_output = ExecutionModel.get_output(id, project_id,
data['first_requested_byte'],
data['last_requested_byte'])
if exec_output:
return {'output': exec_output.json()}
return {'message': 'Execution not found'}, 404
def get_projects() -> ApiResponse:
project_list = ProjectModel.find_all()
if not project_list:
abort(404, description=ERROR_404_LIST.format("projects"))
return (
jsonify({"projects": project_list_schema.dump(project_list)}),
200,
)
def post(self, experiment_name):
user_id = get_jwt_identity()
data = Prediction.parser.parse_args()
raw_data = data['data']
dataset = File.read_json(raw_data)
result = ExperimentModel.find_by_name(user_id, experiment_name)
y_col = result.y_col
datasource_id = result.datasource_id
project_id = result.project_id
result = DatasourceModel.find_one_by_id(user_id, datasource_id)
user_schema_name = result.user_schema_name
user_table_name = result.user_table_name
columns = [
col['column_name'] for col in DatasourceModel.get_columns(
user_schema_name, user_table_name)
]
try:
columns_filter_id = ProjectModel.find_one_by_id(
project_id, user_id).columns_filter_id
except Exception as e:
return {
'message':
ERROR_CANNOT_GET_COLUMNS_FILTER_ID.format(project_id)
}, 500
try:
columns_filter = ProjectUnstructureModel.find_by_object_id(
ObjectId(columns_filter_id))['columns']
except Exception as e:
return {
'message': ERROR_CANNOT_GET_COLUMNS_FILTER.format(project_id)
}, 500
try:
predict = Predicting(experiment_name, dataset, columns,
columns_filter, y_col, user_id)
predict.decorate_dataframe()
predict.load_model()
predict.predict()
dataset = predict.merge_predict_to_dataframe()
json_data = Dataset(dataset).get_json()
except Exception as e:
print(e)
return {
'message':
ERROR_CANNOT_GET_PREDICT_WITH_DATA.format(experiment_name)
}, 500
# try:
# DatasourceModel.append_datasource(dataset, user_schema_name, user_table_name)
# except Exception as e:
# return {'message': ERROR_CANNOT_INSERT_DB}, 500
return {'data': json_data}, 200
def delete(self, project_id):
user_id = get_jwt_identity()
try:
project = ProjectModel.find_one_by_id(project_id, user_id)
project.delete_from_db()
return {'message': SUCCESS_MESSAGE.format(project_id)}, 200
except Exception as e:
return {
'message':
'This project has many experiments, please remove experiment first.'
}, 500
def get(self, name):
project = ProjectModel.find_by_name(name)
if project:
return {"project": project.json(), "status": 200}
return {
"ProjectNotExistsError": {
"message": "Project with given name doesn't exists",
"status": 400,
}
}
def delete(self, id):
project = ProjectModel.find_by_id(id)
if project:
if current_identity.id == project.user_id:
project.delete_from_db()
return {'message': 'Project deleted'}
else:
return {
'message': 'Sorry, this project was not created by you.'
}
else:
return {'message': 'Sorry, this project was not found.'}
