def put(self, movie): """Method for editing (PUT) a single movie item in the database""" db_movie = Movie.query.filter_by(name=movie).first() if db_movie is None: return create_error_response(404, "Not found", "No movie was found with the name {}".format(movie) ) if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON" ) try: validate(request.json, Movie.get_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_movie.name = request.json["name"] db_movie.genre = request.json["genre"] try: db.session.commit() except IntegrityError: return create_error_response(409, "Already exists", "Movie with name '{}' already exists.".format(request.json["name"]) ) return Response(status=204)
def post(self): """ POST method adds a new user to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, BoardBuilder.user_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_user = User(id=request.json["id"], name=request.json["name"], password=request.json["password"]) try: db.session.add(new_user) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "User with name '{}' already exists".format( request.json["name"])) return Response(status=201, headers={ "Location": api.url_for(UserItem, name=request.json["name"]) })
def post(self): """ POST method adds new match to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Request must be JSON") try: validate(request.json, GameBuilder.match_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_match = Match( #id=request.json["id"], team1=request.json["team1"], team2=request.json["team2"], date=request.json["date"], team1_points=request.json["team1_points"], team2_points=request.json["team2_points"]) try: db.session.add(new_match) db.session.commit() except IntegrityError: return create_error_response(409, "Already exists", "Match already inserted") return Response( status=201, headers={"Location": api.url_for(MatchItem, id=new_match.id)})
def check_for_json_errors(json_body): response = {} if json_body: leagues = json_body.get(CONSTANTS.LEAGUES_KEY) if leagues: date = json_body.get(CONSTANTS.DATE_KEY) if date and utils.validate_date(date): date_object = datetime.strptime(date, CONSTANTS.DATE_FORMAT) response = { CONSTANTS.LEAGUES_KEY: leagues, CONSTANTS.DATE_KEY: date_object, CONSTANTS.INCLUDE_ODDS_KEY: json_body.get(CONSTANTS.INCLUDE_ODDS_KEY) } else: message = "Need to provide valid date in format MM-DD-YYYY (ex: 02-18-2021)" response = utils.create_error_response(500, message) else: message = "Please provide valid leagues array (ex: \"leagues\": [\"nhl\", \"nba\"]" response = utils.create_error_response(500, message) else: message = "The request body is not valid json!" response = utils.create_error_response(500, message) return response
def put(self, id): """ PUT method edits a single throw """ db_throwid = Throw.query.filter_by(id=id).first() if db_throwid is None: return create_error_response( 404, "Not found", "No throw was found with id {}".format(id)) if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, GameBuilder.throw_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_throwid.id = request.json["id"] db_throwid.points = request.json["points"] db_throwid.player_id = request.json["player_id"] db_throwid.match_id = request.json["match_id"] try: db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Throw with id '{}' already exists".format(request.json["id"])) return Response(status=204)
def put(self, name): """ PUT method edits a player """ db_player = Player.query.filter_by(name=name).first() if db_player is None: return create_error_response( 404, "Not found", "No player was found with name {}".format(name)) if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, GameBuilder.player_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_player.name = request.json["name"] db_player.team = request.json["team"] try: db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Player with name '{}' already exists".format( request.json["name"])) return Response(status=204)
def post(self): """ POST method adds a new message to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, BoardBuilder.message_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_message = Message(id=request.json["id"], parent_topic_id=request.json["parent_topic_id"], message=request.json["message"], time=request.json["time"], user_id=request.json["user_id"]) try: db.session.add(new_message) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "message with id '{}' already exists".format( request.json["id"])) return Response(status=201, headers={ "Location": api.url_for(MessageItem, id=request.json["id"]) })
def post(self): """ POST method adds a new throw to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, GameBuilder.throw_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_throw = Throw(id=request.json["id"], points=request.json["points"], player_id=request.json["player_id"], match_id=request.json["match_id"]) try: db.session.add(new_throw) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Throw with id '{}' already exists".format(request.json["id"])) return Response(status=201, headers={ "Location": api.url_for(ThrowItem, id=request.json["id"]) })
def post(self): """Method for POST a new single movie item to the database""" if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON" ) try: validate(request.json, Movie.get_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) #Find uploader for the movie: uploader=request.json["uploader"] #email=request.json["email"] uploader_object = Uploader.query.filter_by(uploader_name=uploader).first() movie = Movie( name=request.json["name"], genre=request.json["genre"], uploader=uploader_object ) try: db.session.add(movie) db.session.commit() except IntegrityError: return create_error_response(409, "Already exists", "Movie with name '{}' already exists.".format(request.json["name"]) ) return Response(status=201, headers={ "Location": api.url_for(MovieItem, movie=request.json["name"]) })
def delete(self, project, member): """ delete member from project """ db_project = Project.query.filter_by(name=project).first() if db_project is None: return create_error_response( 404, "Project not found", f"Project with name {project} not found") db_tasks = Tasks.query.filter_by(project_id=db_project.id) if db_tasks is []: return create_error_response(404, "not found", f"no tasks for this project") db_member = Members.query.filter_by(name=member).first() if db_member is None: return create_error_response(404, "not found", f"member {member} not in database") for task in db_tasks: db_team = Teams.query.filter_by(task_id=task.id, member_id=db_member.id).first() if db_team is not None: db.session.delete(db_team) db.session.commit() return Response(status=204) return create_error_response( 404, "not found", f"member {member} not in project {project}")
def put(self, id): """ PUT method edits a single message """ db_messageid = Message.query.filter_by(id=id).first() if db_messageid is None: return create_error_response( 404, "Not found", "No message was found with id {}".format(id)) if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, BoardBuilder.message_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_messageid.id = request.json["id"], db_messageid.parent_topic_id = request.json["parent_topic_id"], db_messageid.message = request.json["message"], db_messageid.time = request.json["time"], db_messageid.user_id = request.json["user_id"] try: db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Message with id '{}' already exists".format( request.json["id"])) return Response(status=204)
def put(self, member): """ edit member """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, MemberBuilder.member_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_member = Members.query.filter_by(name=member).first() if db_member is None: return create_error_response( 404, "Not found", "No member was found with the name {}".format(member)) db_member.name = request.json["name"] try: db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Member with name '{}' already exists.".format( request.json["name"])) return Response(status=204, headers={ "location": api.url_for(MemberItem, member=db_member.name) })
def post(self): """ add new meber to database """ # add new member if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, MemberBuilder.member_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_member = Members(name=request.json["name"]) try: db.session.add(new_member) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Member with name '{}' already exists.".format( request.json["name"])) return Response(status=201, headers={ "Location": api.url_for(MemberItem, member=new_member.name) })
def put(self, uploader_name): """Method for editing a single uploader in the database""" db_uploader = Uploader.query.filter_by(uploader_name=uploader_name).first() if db_uploader is None: return create_error_response(404, "Not found", "No uploader was found with the name {}".format(uploader_name) ) if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON" ) try: validate(request.json, Uploader.get_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_uploader.uploader_name = request.json["uploader_name"] db_uploader.email = request.json["email"] try: db.session.commit() except IntegrityError: return create_error_response(409, "Already exists", "Uploader with name '{}' already exists.".format(request.json["uploader_name"]) ) return Response(status=204)
def post(self): """ POST method adds new topic to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Request must be JSON") try: validate(request.json, BoardBuilder.topic_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_topic = Topic(id=request.json["id"], header=request.json["header"], message=request.json["message"], time=request.json["time"], user_id=request.json["user_id"]) try: db.session.add(new_topic) db.session.commit() except IntegrityError: return create_error_response(409, "Already exists", "Topic already inserted") return Response( status=201, headers={"Location": api.url_for(TopicItem, id=new_topic.id)})
def put(self, project, phase, task): """ Modify existing task. """ db.session.rollback() if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, TaskBuilder.task_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) db_task = Tasks.query.filter_by(name=task).first() if db_task is None: return create_error_response( 404, "Not found", "No phase was found with the name {}".format(task)) db_task.name = request.json["task_name"] try: db_task.start = datetime.datetime.strptime( request.json["task_start"], "%Y-%m-%d") except KeyError: pass try: db_task.end = datetime.datetime.strptime(request.json["task_end"], "%Y-%m-%d") except KeyError: pass try: db_task.status = request.json["task_status"] except KeyError: pass try: db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Phase with name '{}' already exists.".format( request.json["name"])) return Response(status=204, headers={ "location": api.url_for(TaskItem, project=project, phase=phase, task=db_task.name) })
def post(self, project): #db.session.rollback() if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, PhaseBuilder.phase_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) try: project = Project.query.filter_by(name=project).first() except KeyError: pass new_phase = Phase( name=request.json["name"], project=project, ) try: new_phase.deadline = datetime.datetime.strptime( request.json["deadline"], "%Y-%m-%d") except KeyError: pass try: new_phase.status = status_type[request.json["status"]] except KeyError: pass if new_phase.deadline != None: new_phase.deadline = new_phase.deadline try: db.session.add(new_phase) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Phase with name '{}' already exists.".format( request.json["name"])) return Response(status=201, headers={ "Location": api.url_for(PhaseItem, project=project.name, phase=new_phase.name) })
def post(self, project): """ add new member to project """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, MemberBuilder.member_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) # add new member to task db_member = Members.query.filter_by(name=request.json["name"]).first() db_task = Tasks.query.filter_by(name=f"{project}-default").first() db_project = Project.query.filter_by(name=project).first() if db_member is None: return create_error_response( 404, "not found", f"member {request.json['name']} not in database") if db_task is None: new_task = Tasks(project=db_project, name=f"{project}-default", status=status_type["NOT_STARTED"]) db.session.add(new_task) db.session.commit() db_task = Tasks.query.filter_by(name=f"{project}-default").first() db_team = Teams.query.filter_by(task_id=db_task.id, member_id=db_member.id).first() if db_team is not None: return create_error_response( 409, "Already exists", "Member already in task '{}'.".format(db_task.name)) new_team = Teams(team_tasks=db_task, team_members=db_member) try: db.session.add(new_team) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Member already in task '{}'.".format(task)) return Response(status=201, headers={ "Location": api.url_for(ProjectMemberItem, project=project, member=db_member.name) })
def post(self): """ this function adds new project to the database """ # add new project db.session.rollback() if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, ProjectBuilder.project_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) manager, start, end = None, None, None new_project = Project(name=request.json["name"], status=status_type[request.json["status"]]) try: manager = Members.query.filter_by( name=request.json["project_manager"]).first() except KeyError: pass try: start = request.json["start"] new_project.start = datetime.datetime.strptime(start, "%Y-%m-%d") except (KeyError, TypeError): pass try: end = request.json["end"] new_project.end = datetime.datetime.strptime(end, "%Y-%m-%d") except (KeyError, TypeError): pass if manager is not None: new_project.project_manager = manager try: db.session.add(new_project) db.session.commit() except IntegrityError: return create_error_response( 409, "Already exists", "Project with name '{}' already exists.".format( request.json["name"])) return Response(status=201, headers={ "location": api.url_for(ProjectItem, project=new_project.name) })
def process_games(json_body, is_revenge_games): response = {} parsed_json = check_for_json_errors(json_body) if not parsed_json.get(CONSTANTS.ERROR_KEY): leagues = parsed_json[CONSTANTS.LEAGUES_KEY] date_object = parsed_json[CONSTANTS.DATE_KEY] include_odds = parsed_json.get(CONSTANTS.INCLUDE_ODDS_KEY) response[CONSTANTS.DATA_KEY] = {} for league in leagues: if (utils.validate_league(league)): json_logic = get_json_logic(league, leagues) if is_revenge_games: number_of_years_back = json_body.get( CONSTANTS.YEARS_BACK_KEY) if not number_of_years_back: number_of_years_back = CONSTANTS.DEFAULT_NUMBER_OF_YEARS_BACK generator = RevengeGameGenerator(league, number_of_years_back, date_object, json_logic) else: generator = GameGenerator(league, date_object, json_logic) games = generator.get_games(include_odds) response_array = [] for game in games: response_array.append(game.to_dictionary()) response[CONSTANTS.DATA_KEY][league] = response_array else: message = str(league) + " is not a valid league (ex: nhl)" response = utils.create_error_response(500, message) else: response = parsed_json return response
def get(self, uploader_name): """Method for getting a single uploader from the database""" db_uploader = Uploader.query.filter_by(uploader_name=uploader_name).first() if db_uploader is None: return create_error_response(404, "Not found", "No uploader was found with the name {}".format(uploader_name) ) body = MovieBuilder( uploader_name=db_uploader.uploader_name, email=db_uploader.email, ) body.add_namespace("mwl", LINK_RELATIONS_URL) body.add_control("self", api.url_for(UploaderItem, uploader_name=uploader_name)) body.add_control("uploaders-all", api.url_for(UploaderCollection)) body.add_control_delete_uploader(uploader_name) body.add_control_modify_uploader(uploader_name) body["items"] = [] for db_movie in Movie.query.all(): uploader_object = db_movie.uploader if uploader_object is not None: uploader_object_name = uploader_object.uploader_name else: uploader_object_name = "No name" if uploader_object_name == uploader_name: item = MovieBuilder( name=db_movie.name, genre=db_movie.genre ) item.add_control("self", api.url_for(MovieItem, movie=db_movie.name)) item.add_control("profile", MOVIE_PROFILE) body["items"].append(item) return Response(json.dumps(body), 200, mimetype=MASON)
def get(self, project, phase, task): db_task = Tasks.query.filter_by(name=task).first() if db_task == None: return create_error_response(404, "Not found", f"Task with name {task} not found.") if db_task.start != None: db_task.start = datetime.datetime.strftime(db_task.start, "%Y-%m-%d") if db_task.end != None: db_task.end = datetime.datetime.strftime(db_task.end, "%Y-%m-%d") body = TaskBuilder(name=db_task.name, task_start=str(db_task.start), task_end=str(db_task.end), status=str(db_task.status.value)) body.add_namespace("promana", LINK_RELATIONS_URL) body.add_control( "self", api.url_for(TaskItem, project=project, phase=phase, task=task)) body.add_control( "collection", api.url_for(TaskCollection, project=project, phase=phase)) body.add_control_task_phase(project, phase) body.add_control_task_members(project, phase, task) body.add_control_edit_task(project, phase, task) body.add_control_delete_task(project, phase, task) return Response(json.dumps(body), 200, mimetype=MASON)
def get(self, project, phase): db_phase = Phase.query.filter_by(name=phase).first() if db_phase == None: return create_error_response( 404, "Not found", f"Phase with name {phase} not found.") #if db_phase.deadline is None: # db_phase.deadline = datetime.datetime.strftime(db_phase.deadline, "%Y-%m-%d") try: deadline = db_phase.deadline.strftime("%Y-%m-%d") except AttributeError: deadline = None body = PhaseBuilder(name=db_phase.name, deadline=deadline, status=str(db_phase.status.value)) body.add_namespace("promana", LINK_RELATIONS_URL) body.add_control("self", api.url_for(PhaseItem, project=project, phase=phase)) body.add_control("collection", api.url_for(PhaseCollection, project=project)) body.add_control_up_project(project) body.add_control_edit_phase(project, phase) body.add_control_delete_phase(project, phase) return Response(json.dumps(body), 200, mimetype=MASON)
def post(self): """ POST method adds a new message to collection """ if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON") try: validate(request.json, BoardBuilder.message_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) new_message = Message(id=request.json["id"], message=request.json["message"], date=request.json["date"], user_id=request.json["user_id"], parent_topic_id=request.json["parent_topic_id"]) """
def get(self, project, phase, task): """ get all task members """ db_task = Tasks.query.filter_by(name=task).first() if db_task is None: return create_error_response(404, "Task not found", f"Task with name {task} not found") body = MemberBuilder() body.add_namespace("promana", LINK_RELATIONS_URL) body.add_control( "self", api.url_for(TaskMembers, project=project, phase=phase, task=task)) body.add_control( "up", f"/api/projects/{project}/phases/{phase}/tasks/{task}/") body.add_control_delete_member("member", project=project, phase=phase, task=task) body.add_control_add_member(project=project, phase=phase, task=task) body["items"] = [] db_teams = Teams.query.filter_by(task_id=db_task.id) for team in db_teams: member = team.team_members try: if member.name not in body["items"]: item = MemberBuilder(name=member.name) item.add_control( "self", api.url_for(TaskMemberItem, project=project, phase=phase, task=task, member=member.name)) body["items"].append(item) except AttributeError: return create_error_response(404, "not found", "user not found") return Response(json.dumps(body), 200, mimetype=MASON)
def post(self): """Method for POST a new single uploader to the database""" if not request.json: return create_error_response(415, "Unsupported media type", "Requests must be JSON" ) try: validate(request.json, Uploader.get_schema()) except ValidationError as e: return create_error_response(400, "Invalid JSON document", str(e)) uploader = Uploader( uploader_name=request.json["uploader_name"], email=request.json["email"], ) exists = Uploader.query.filter_by(uploader_name=uploader.uploader_name).first() print("\nposting: " + str(exists)) print("\nposting: " + str(uploader.uploader_name)) try: db.session.add(uploader) if exists == None: db.session.commit() else: print("\nNothing to add, uploader already exists.") db.session.rollback() except IntegrityError: return create_error_response(409, "Already exists", "Uploader with name '{}' already exists.".format(request.json["uploader_name"]) ) return Response(status=201, headers={ "Location": api.url_for(UploaderItem, uploader_name=request.json["uploader_name"]) })
def delete(self, movie): """Method for deleting a movie from the database with movie name""" db_movie = Movie.query.filter_by(name=movie).first() if db_movie is None: return create_error_response(404, "Not found", "No movie was found with the name {}".format(movie) ) db.session.delete(db_movie) db.session.commit() return Response(status=204)
def delete(self, uploader_name): """Method for deleting a uploader from the database""" db_uploader = Uploader.query.filter_by(uploader_name=uploader_name).first() if db_uploader is None: return create_error_response(404, "Not found", "No Uploader was found with the name {}".format(uploader_name) ) db.session.delete(db_uploader) db.session.commit() return Response(status=204)
def delete(self, id): """ DELETE method deletes a single message """ db_messageid = Throw.query.filter_by(id=id).first() if db_messageid is None: return create_error_response( 404, "Not found", "No message was found with id {}".format(id)) db.session.delete(db_messageid) db.session.commit() return Response(status=204)
def get(self, project): """ get all project members """ db_project = Project.query.filter_by(name=project).first() if db_project is None: return create_error_response( 404, "Project not found", f"Project with name {project} not found") body = MemberBuilder() body.add_namespace("promana", LINK_RELATIONS_URL) body.add_control("self", api.url_for(ProjectMembers, project=project)) body.add_control("up", f"/api/projects/{project}/") body.add_control_delete_member("member", project=project) body.add_control_add_member(project=project) body["items"] = [] db_tasks = Tasks.query.filter_by(project_id=db_project.id) for task in db_tasks: db_teams = Teams.query.filter_by(team_tasks=task) for team in db_teams: member = team.team_members if member is not None: try: if member.name not in body["items"]: item = MemberBuilder(name=member.name) item.add_control( "self", api.url_for(ProjectMemberItem, project=project, member=member.name)) body["items"].append(item) except AttributeError: return create_error_response(404, "not found", "user not found") return Response(json.dumps(body), 200, mimetype=MASON)