beteran-server-service/src/repositories/member/repository.rs

//!
//!

use super::{models, schema::members};
use beteran_common_rust as bcr;
use diesel::prelude::*;
use diesel::result::Error;

///
pub struct Repository {}

impl std::fmt::Debug for Repository {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    f.debug_struct("Repository of members").finish()
  }
}

impl Default for Repository {
  fn default() -> Self {
    Self::new()
  }
}

impl Repository {
  ///
  pub fn new() -> Repository {
    Repository {}
  }

  ///
  pub fn insert(
    &self,
    conn: &diesel::PgConnection,
    new_member: &models::NewMember,
  ) -> Result<models::Member, Error> {
    let inserted = diesel::insert_into(members::table)
      .values(new_member)
      .get_result::<models::Member>(conn)?;

    Ok(inserted)
  }

  ///
  pub fn select(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
  ) -> Result<Option<models::Member>, Error> {
    match members::table.find(id).first::<models::Member>(conn) {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

  ///
  pub fn select_by_username(
    &self,
    conn: &diesel::PgConnection,
    username: &str,
  ) -> Result<Option<models::Member>, Error> {
    use members::dsl;

    match members::table
      .filter(dsl::username.eq(username))
      .first::<models::Member>(conn)
    {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

  ///
  pub fn select_by_nickname(
    &self,
    conn: &diesel::PgConnection,
    nickname: &str,
  ) -> Result<Option<models::Member>, Error> {
    use members::dsl;

    match members::table
      .filter(dsl::nickname.eq(nickname))
      .first::<models::Member>(conn)
    {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

  ///
  pub fn select_all_count(
    &self,
    conn: &diesel::PgConnection,
    find_all: &models::FindAll,
  ) -> Result<i64, Error> {
    use members::dsl;

    let mut q = members::table.into_boxed();

    if let Some(s) = &find_all.search {
      if let Some(sp) = s.site_id {
        q = q.filter(dsl::site_id.eq(sp));
      }
      if let Some(sp) = s.member_class_id {
        q = q.filter(dsl::member_class_id.eq(sp));
      }
      if let Some(sp) = s.member_level_id {
        q = q.filter(dsl::member_level_id.eq(sp));
      }
      if let Some(sp) = &s.username_like {
        q = q.filter(dsl::username.like(sp));
      }
      if let Some(sp) = &s.nickname_like {
        q = q.filter(dsl::nickname.like(sp));
      }
      if let Some(sp) = &s.mobile_phone_number_like {
        q = q.filter(dsl::mobile_phone_number.like(sp));
      }
      if let Some(sp) = &s.last_signined_ip {
        q = q.filter(dsl::last_signined_ip.eq(sp));
      }
      if let Some(sp) = s.state {
        q = q.filter(dsl::state.eq(sp));
      }
      if s.deleted_at.is_some() {
        q = q.filter(dsl::deleted_at.is_not_null());
      } else {
        q = q.filter(dsl::deleted_at.is_null());
      }
    }

    q.count().get_result(conn)
  }

  ///
  pub fn select_all(
    &self,
    conn: &diesel::PgConnection,
    find_all: &models::FindAll,
  ) -> Result<Vec<models::Member>, Error> {
    use members::dsl;

    let mut q = members::table.into_boxed();

    if let Some(s) = &find_all.search {
      if let Some(sp) = s.site_id {
        q = q.filter(dsl::site_id.eq(sp));
      }
      if let Some(sp) = s.member_class_id {
        q = q.filter(dsl::member_class_id.eq(sp));
      }
      if let Some(sp) = s.member_level_id {
        q = q.filter(dsl::member_level_id.eq(sp));
      }
      if let Some(sp) = &s.username_like {
        q = q.filter(dsl::username.like(sp));
      }
      if let Some(sp) = &s.nickname_like {
        q = q.filter(dsl::nickname.like(sp));
      }
      if let Some(sp) = &s.mobile_phone_number_like {
        q = q.filter(dsl::mobile_phone_number.like(sp));
      }
      if let Some(sp) = &s.last_signined_ip {
        q = q.filter(dsl::last_signined_ip.eq(sp));
      }
      if let Some(sp) = s.state {
        q = q.filter(dsl::state.eq(sp));
      }
      if s.deleted_at.is_some() {
        q = q.filter(dsl::deleted_at.is_not_null());
      } else {
        q = q.filter(dsl::deleted_at.is_null());
      }
    }

    if let Some(p) = &find_all.pagination {
      let page = p.page.unwrap_or(1);

      if let Some(page_size) = p.page_size {
        q = q.offset(((page - 1) * page_size) as i64);
        q = q.limit(page_size as i64);
      }
    }
    if let Some(orderbys) = &find_all.sorts {
      for s in orderbys {
        match s {
          bcr::models::pagination::Sort::ASC(property) => match property.as_str() {
            "username" => {
              q = q.order_by(dsl::username.asc());
            }
            "nickname" => {
              q = q.order_by(dsl::nickname.asc());
            }
            "mobile_phone_number" => {
              q = q.order_by(dsl::mobile_phone_number.asc());
            }
            "last_signined_ip" => {
              q = q.order_by(dsl::last_signined_ip.asc());
            }
            "state" => {
              q = q.order_by(dsl::state.asc());
            }
            "state_changed_at" => {
              q = q.order_by(dsl::state_changed_at.asc());
            }
            "created_at" => {
              q = q.order_by(dsl::created_at.asc());
            }
            "updated_at" => {
              q = q.order_by(dsl::updated_at.asc());
            }
            "deleted_at" => {
              q = q.order_by(dsl::deleted_at.asc());
            }
            _ => {}
          },
          bcr::models::pagination::Sort::DESC(property) => match property.as_str() {
            "username" => {
              q = q.order_by(dsl::username.desc());
            }
            "nickname" => {
              q = q.order_by(dsl::nickname.desc());
            }
            "mobile_phone_number" => {
              q = q.order_by(dsl::mobile_phone_number.desc());
            }
            "last_signined_ip" => {
              q = q.order_by(dsl::last_signined_ip.desc());
            }
            "state" => {
              q = q.order_by(dsl::state.desc());
            }
            "state_changed_at" => {
              q = q.order_by(dsl::state_changed_at.desc());
            }
            "created_at" => {
              q = q.order_by(dsl::created_at.desc());
            }
            "updated_at" => {
              q = q.order_by(dsl::updated_at.desc());
            }
            "deleted_at" => {
              q = q.order_by(dsl::deleted_at.desc());
            }
            _ => {}
          },
        };
      }
    }

    q.load::<models::Member>(conn)
  }

  ///
  pub fn update(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
    modify: &models::ModifyMember,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(modify)
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn update_state(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
    modify: &models::ModifyMemberForState,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(modify)
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn increase_child_member_count(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(dsl::child_member_count.eq(dsl::child_member_count + 1))
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn decrease_child_member_count(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(dsl::child_member_count.eq(dsl::child_member_count - 1))
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn update_last_signined_ip(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
    modify: &models::ModifyMember4LastSignined,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(modify)
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn update_deleted_at(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
    modify: &models::ModifyMember4DeletedAt,
  ) -> Result<u64, Error> {
    use members::dsl;

    diesel::update(dsl::members.filter(dsl::id.eq(id)))
      .set(modify)
      .execute(conn)
      .map(|c| c as u64)
  }
}