nil-server-database 0.6.2

Multiplayer strategy game
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

// Copyright (C) Call of Nil contributors
// SPDX-License-Identifier: AGPL-3.0-only

use crate::error::{Error, Result};
use crate::model::user::{NewUser, User};
use crate::sql_types::id::UserId;
use crate::sql_types::player_id::db_PlayerId;
use crate::{Database, conn};
use diesel::prelude::*;
use diesel::result::{DatabaseErrorKind, Error as DieselError};
use diesel_async::RunQueryDsl;
use either::Either;

impl Database {
  pub async fn count_games_by_user(&self, id: db_PlayerId) -> Result<i64> {
    let user_id = self.get_user_id(id).await?;
    self.count_games_by_user_id(user_id).await
  }

  pub async fn count_games_by_user_id(&self, id: UserId) -> Result<i64> {
    use crate::schema::game;

    game::table
      .filter(game::created_by.eq(id))
      .count()
      .get_result(conn!(self))
      .await
      .map_err(Into::into)
  }

  pub async fn create_user(&self, new: &NewUser) -> Result<usize> {
    use crate::schema::user;

    let result = diesel::insert_into(user::table)
      .values(new)
      .execute(conn!(self))
      .await;

    if let Err(DieselError::DatabaseError(kind, _)) = &result
      && let DatabaseErrorKind::UniqueViolation = kind
    {
      Err(Error::UserAlreadyExists(new.player_id()))
    } else {
      Ok(result?)
    }
  }

  pub async fn get_user(&self, id: impl Into<db_PlayerId>) -> Result<User> {
    use crate::schema::user;

    let id: db_PlayerId = id.into();

    let result = user::table
      .filter(user::player_id.eq(&id))
      .select(User::as_select())
      .first(conn!(self))
      .await;

    if let Err(DieselError::NotFound) = &result {
      Err(Error::UserNotFound(Either::Left(id)))
    } else {
      Ok(result?)
    }
  }

  pub async fn get_user_by_id(&self, id: UserId) -> Result<User> {
    use crate::schema::user;

    let result = user::table
      .find(id)
      .select(User::as_select())
      .first(conn!(self))
      .await;

    if let Err(DieselError::NotFound) = &result {
      Err(Error::UserNotFound(Either::Right(id)))
    } else {
      Ok(result?)
    }
  }

  pub async fn get_user_id(&self, id: db_PlayerId) -> Result<UserId> {
    use crate::schema::user;

    let result = user::table
      .filter(user::player_id.eq(&id))
      .select(user::id)
      .first(conn!(self))
      .await;

    if let Err(DieselError::NotFound) = &result {
      Err(Error::UserNotFound(Either::Left(id)))
    } else {
      Ok(result?)
    }
  }

  pub async fn get_user_player_id(&self, id: UserId) -> Result<db_PlayerId> {
    use crate::schema::user;

    let result = user::table
      .find(id)
      .select(user::player_id)
      .first::<db_PlayerId>(conn!(self))
      .await;

    if let Err(DieselError::NotFound) = &result {
      Err(Error::UserNotFound(Either::Right(id)))
    } else {
      Ok(result?)
    }
  }

  pub async fn user_exists(&self, id: impl Into<db_PlayerId>) -> Result<bool> {
    use crate::schema::user;
    use diesel::dsl::{exists, select};

    let id: db_PlayerId = id.into();

    select(exists(user::table.filter(user::player_id.eq(id))))
      .get_result(conn!(self))
      .await
      .map_err(Into::into)
  }
}