def edit(user_id): """ Param: { 'name': not_required, 'email': not_required, 'password': not_required } """ if g.user.id != user_id: return make_response(jsonify(message='NOT_ALLOWED')) edited_user = g.user if 'name' in request.json: edited_user.name = check_none_and_blank(request, 'name') if 'email' in request.json: email = check_none_and_blank(request, 'email') if not User.query.filter_by(email=email).first(): edited_user.email = email if 'password' in request.json: pwd_raw = check_none_and_blank(request, 'password') password = edited_user.generate_hash_password(pwd_raw) edited_user.password = password db.session.add(edited_user) db.session.commit() return make_response(jsonify(message='USER_EDITED'))
def edit(project_id): """POST endpoint for editing existing users. Param: { project_name: not required, privacy_policy: not required (public or false), project_owner: not required (id), type_of_project: not required } """ edited_project = get_project(project_id) if 'project_name' in request.json: project_name = check_none_and_blank(request, 'project_name') edited_project.name = project_name if 'privacy_policy' in request.json: privacy_policy = check_none_and_blank(request, 'privacy_policy') edited_project.privacy_policy = privacy_policy if 'project_owner' in request.json: project_owner = check_none_and_blank(request, 'project_owner') user = get_user({'id': project_owner}) edited_project.owner_id = user.id if 'type_of_project' in request.json: type_of_project = check_none_and_blank(request, 'type_of_project') edited_project.type_of_project = type_of_project db.session.add(edited_project) db.session.commit() return make_response(jsonify(message='PROJECT_EDITED'))
def remove_scenario(): """POST endpoint for removing the scenario. Params: { scenario_id: required, action: required -> DISABLE, ACTIVE, REMOVE } """ scenario_id = check_none_and_blank(request, 'scenario_id') scenario = get_scenario(scenario_id) action = check_none_and_blank(request, 'action') last_cycle = get_last_cycle(scenario.project_id) if action in ['DISABLE', 'ENABLE', 'REMOVE']: if action == 'DISABLE': state = StateType.disable cycle_state = StateType.blocked elif action == 'ENABLE': state = StateType.active cycle_state = StateType.not_executed else: state = StateType.removed cycle_state = None scenario_case_process(last_cycle, scenario, state, action, cycle_state) else: return make_response(jsonify(message='ACTION_UNKNOW')) return make_response(jsonify(message='DONE'))
def change_cycle_case_state_code_(project_id): """ Endpoint for changing the cycle cases state_code . Param: { 'cycle_id': required, 'case_id': required, 'action': required } """ action = check_none_and_blank(request, 'action') case_id = check_none_and_blank(request, 'case_id') cycle_id = check_none_and_blank(request, 'cycle_id') cycle = get_cycle(cycle_id, project_id) last_cycle = get_last_cycle(project_id) if cycle.id != last_cycle.id: return make_response(jsonify(message='NOT_LAST_CYCLE')) if action not in StateType.__members__: return make_response(jsonify(message='ACTION_UNKNOW')) edited_cycle_case = CycleCases.query.filter_by( cycle_id=cycle.id).filter_by(case_id=case_id).first() if edited_cycle_case is None: abort(make_response(jsonify(message='UNKNOW_CASE'), 404)) edited_cycle_case.state_code = StateType[action] db.session.add(edited_cycle_case) db.session.commit() return make_response(jsonify(message='CYCLE_EDITED'))
def new(): """ Param: { 'name': required, 'email': required, 'password': required } """ open_user_setting = SherlockSettings.query.filter_by( setting='OPEN_USER_REGISTER').first() try: if g.user.profile == 'admin': is_admin = True else: is_admin = False except: is_admin = False if open_user_setting == "False" and not is_admin: return make_response(jsonify(message='UNAUTHORIZED')) name = check_none_and_blank(request, 'name') email = check_none_and_blank(request, 'email') password = check_none_and_blank(request, 'password') if User.query.filter_by(email=email).first() is not None: return make_response(jsonify(message='EMAIL_IN_USE')) new_user = User(name=name, email=email, password=password) db.session.add(new_user) db.session.commit() return make_response(jsonify(message='USER_CREATED'))
def remove_tag(): scenario_id = check_none_and_blank(request, 'scenario_id') scenario = get_scenario(scenario_id) tag_id = check_none_and_blank(request, 'tag_id') tag = get_tagscenario(tag_id) db.session.delete(tag) db.session.commit() return make_response(jsonify(message='TAG_REMOVED'))
def tstcase_changestatus(scenario_id): """POST endpoint for new scenarios. Param: { 'case_id': required, 'action': required, } TODO: State is not defined """ case_id = check_none_and_blank(request, 'case_id') action = check_none_and_blank(request, 'action') scenario = get_scenario(scenario_id) tst_case = get_tstcase(case_id) if scenario.state_code == StateType.disable: return make_response(jsonify(message='SCENARIO_DISABLED')) last_cycle = get_last_cycle(scenario.project_id) if last_cycle: cycle_case = CycleCases.query.filter_by( cycle_id=last_cycle.id).filter_by(case_id=case_id).first() if action == 'DISABLE': state = StateType.disable cycle_state = StateType.blocked elif action == 'ENABLE': state = StateType.active cycle_state = StateType.not_executed elif action == 'REMOVE': if last_cycle and last_cycle.state_code == StateType.active: cycle_state = None if cycle_case: db.session.delete(cycle_case) db.session.commit() state = StateType.removed else: return make_response(jsonify(message='ACTION_UNKNOW')) tst_case.state_code = state db.session.add(tst_case) db.session.commit() if last_cycle: if last_cycle.state_code == StateType.active: if cycle_case and cycle_state: cycle_case.state_code = cycle_state db.session.add(cycle_case) db.session.commit() return make_response(jsonify(message='DONE'))
def close(project_id, cycle_id): # TODO: Check untested cases. """POST endpoint for closing cycles. Param: { reason: required, } """ project = get_project(project_id) cycle = get_cycle(cycle_id, project_id) if cycle.state_code == StateType.closed: return make_response(jsonify(message='CYCLE_CLOSED')) else: reason = check_none_and_blank(request, 'reason') user = g.user cycle.closed_reason = reason cycle.closed_by = user.id cycle.state_code = StateType.closed cycle.closed_at = datetime.now() cycle.last_change = datetime.now() db.session.add(cycle) db.session.commit() return make_response(jsonify(message='CYCLE_CLOSED'))
def edit(): """POST endpoint for editing existing scenarios. Param: { "scenario_id": required, "scenario_name": required } """ scenario_id = check_none_and_blank(request, 'scenario_id') scenario = get_scenario(scenario_id) scenario_name = check_none_and_blank(request, 'scenario_name') scenario.name = scenario_name db.session.add(scenario) db.session.commit() return make_response(jsonify(message='SCENARIO_EDITED'))
def register_tag(): """POST endpoint for adding a tag to a scenario. Param: { 'scenario_id': required, 'tag': required } """ scenario_id = check_none_and_blank(request, 'scenario_id') scenario = get_scenario(scenario_id) tag = check_none_and_blank(request, 'tag') new_tag = TagScenario(scenario_id=scenario_id, tag=tag) db.session.add(new_tag) db.session.commit() return make_response(jsonify(message='TAG_CREATED'))
def edit(scenario_id): """POST endpoint for edit scenarios. Param: { 'case_name': required, 'case_id': required } """ case_id = check_none_and_blank(request, 'case_id') new_case_name = check_none_and_blank(request, 'case_name') edited_tc = get_tstcase(case_id) edited_tc.name = new_case_name db.session.add(edited_tc) db.session.commit() return make_response(jsonify(message='CASE_EDITED'))
def _create_scenario(request): scenario_name = request.json.get('scenario_name') project_id = request.json.get('projectId') check_none_and_blank(request, 'scenario_name') check_none_and_blank(request, 'project_id') if not Project.query.filter_by(id=project_id).first(): abort(make_response(jsonify(message='PROJECT_NOTFOUND'), 400)) new_scenario = Scenario(name=scenario_name, project_id=project_id) db.session.add(new_scenario) db.session.commit() project_lasty_cycle = get_last_cycle(project_id) if project_lasty_cycle: scenario_cycle = CycleScenarios(cycle_id=project_lasty_cycle.id, scenario_id=new_scenario.id) db.session.add(scenario_cycle) db.session.commit() return new_scenario
def new(): """POST endpoint for new projects. Param: { project_name: required, privacy_policy: required (public or private), project_owner: required (current_user_id), type_of_project: required } """ project_name = check_none_and_blank(request, 'project_name') privacy_policy = check_none_and_blank(request, 'privacy_policy') project_owner = check_none_and_blank(request, 'project_owner') type_of_project = check_none_and_blank(request, 'type_of_project') new_project = Project(name=project_name, privacy_policy=privacy_policy, owner_id=int(project_owner), type_of_project=type_of_project) db.session.add(new_project) db.session.commit() return make_response(jsonify(message='PROJECT_CREATED'))
def new(scenario_id): """POST endpoint for new scenarios. Param: {'case_name': required } """ case_name = check_none_and_blank(request, 'case_name') scenario = get_scenario(scenario_id) case = Case(name=case_name, scenario_id=scenario.id) db.session.add(case) db.session.commit() project_lasty_cycle = get_last_cycle(scenario.project_id) if project_lasty_cycle: cyclecase = CycleCases(cycle_id=project_lasty_cycle.id, case_id=case.id, scenario_id=case.scenario_id) db.session.add(cyclecase) db.session.commit() return make_response(jsonify(message='CASE_CREATED'))