public async updateRatingForMovie(movie: Movie, rating: number): Promise<void> {
await getManager().getRepository(Movie).createQueryBuilder("movies")
.update()
.set({ rating })
.where({ id: movie.id })
.execute();
}
public async addPlayerToTeam(player: Player, team: Team): Promise<Player> {
player.teams = [team];
await getManager().getRepository(Player).save(player);
const sharePromises: Array<Promise<Share>> = [];
for (const share of player.shares) {
share.player = player;
player.shares.push(share);
sharePromises.push(getManager().getRepository(Share).save(share));
}
await Promise.all(sharePromises);
return player;
}
public async getAllSeasonsForMenu(): Promise<SeasonMenuItem[]> {
const season = await getManager().getRepository(Season).createQueryBuilder("season")
.orderBy("season.id", "DESC")
.getMany();
return season.map((s) => new SeasonMenuItem(s.name, s.slug));
}
public static async createUser (ctx: BaseContext) {
// get a user repository to perform operations with user
const userRepository: Repository<User> = getManager().getRepository(User);
// build up entity user to be saved
const userToBeSaved: User = new User();
userToBeSaved.name = ctx.request.body.name;
userToBeSaved.email = ctx.request.body.email;
// validate user entity
const errors: ValidationError[] = await validate(userToBeSaved); // errors is an array of validation errors
if (errors.length > 0) {
// return bad request status code and errors array
ctx.status = 400;
ctx.body = errors;
} else {
// save the user contained in the POST body
const user = await userRepository.save(userToBeSaved);
// return created status code and updated user
ctx.status = 201;
ctx.body = user;
}
}
public async getMovie(id: number, team: Team): Promise<Movie | undefined> {
return await getManager().getRepository(Movie).createQueryBuilder("movie")
.leftJoinAndSelect("movie.earnings", "earnings")
.leftJoinAndSelect("movie.shares", "shares")
.where("movie.id = :id", { id })
.andWhere("shares.playerId IN (:...players)", { players: team.players.map((p) => p.id) })
.getOne();
}
public async getTeam(id: number): Promise<Team> {
const team = await getManager().getRepository(Team).createQueryBuilder("team")
.innerJoinAndSelect("team.players", "players")
.innerJoinAndSelect("team.season", "season")
.where("team.id = :id", { id })
.getOne();
return team!;
}
export async function postGetAllAction(context: Context) {
// get a post repository to perform operations with post
const postRepository = getManager().getRepository(Post);
// load all posts
const posts = await postRepository.find();
// return loaded posts
context.body = posts;
}
public static async getUsers (ctx: BaseContext) {
// get a user repository to perform operations with user
const userRepository: Repository<User> = getManager().getRepository(User);
// load all users
const users: User[] = await userRepository.find();
// return loaded users
ctx.body = users;
}
public async getSelectedSeason(seasonSlug: string | undefined): Promise<Season | undefined> {
let slug: string;
if (seasonSlug === undefined) {
const maxSeason = await getManager().getRepository(Season).createQueryBuilder("season")
.orderBy("id", "DESC")
.getOne();
slug = maxSeason!.slug;
} else {
slug = seasonSlug;
}
const season = await getManager().getRepository(Season).createQueryBuilder("season")
.leftJoinAndSelect("season.teams", "teams")
.leftJoinAndSelect("season.movies", "movies")
.leftJoinAndSelect("season.urls", "urls")
.leftJoinAndSelect("movies.earnings", "earnings")
.leftJoinAndSelect("movies.shares", "shares")
.where("season.slug LIKE :slug", { slug })
.getOne();
return season;
}
export async function postSaveAction(context: Context) {
// get a post repository to perform operations with post
const postRepository = getManager().getRepository(Post);
// create a real post object from post json object sent over http
const newPost = postRepository.create(context.request.body);
// save received post
await postRepository.save(newPost);
// return saved post back
context.body = newPost;
}
