298 lines
9.7 KiB
Rust
298 lines
9.7 KiB
Rust
//! SeaORM entity for Mentors table
|
|
//! Corresponding to ResourceEnum::Mentors
|
|
|
|
use chrono::{DateTime, Utc};
|
|
use sea_orm::entity::prelude::*;
|
|
use sea_orm::{ActiveModelBehavior, DeriveEntityModel, DeriveRelation};
|
|
use sea_orm::ActiveValue::Set;
|
|
use serde::{Deserialize, Serialize};
|
|
use uuid::Uuid;
|
|
|
|
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize, imphnen_macros::Builder)]
|
|
#[sea_orm(table_name = "app_mentors")]
|
|
pub struct Model {
|
|
#[sea_orm(primary_key, default = "gen_random_uuid()", auto_increment = false)]
|
|
pub id: Uuid,
|
|
|
|
#[sea_orm(unique, not_null)]
|
|
pub user_id: Uuid,
|
|
|
|
#[sea_orm(type = "jsonb", nullable)]
|
|
pub industries: Option<serde_json::Value>,
|
|
|
|
#[sea_orm(type = "jsonb", nullable)]
|
|
pub expertise: Option<serde_json::Value>,
|
|
|
|
#[sea_orm(type = "jsonb", nullable)]
|
|
pub languages: Option<serde_json::Value>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub current_company: Option<String>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub current_role: Option<String>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub years_of_experience: Option<i32>,
|
|
|
|
#[sea_orm(type = "jsonb", nullable)]
|
|
pub topics_of_interest: Option<serde_json::Value>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub preferred_mentee_level: Option<String>,
|
|
|
|
#[sea_orm(type = "jsonb", nullable)]
|
|
pub preferred_mentoring_formats: Option<serde_json::Value>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub availability_commitment: Option<String>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub mentoring_rate: Option<f64>,
|
|
|
|
#[sea_orm(nullable)]
|
|
pub status: Option<String>,
|
|
|
|
#[sea_orm(default = "false")]
|
|
pub is_deleted: bool,
|
|
|
|
#[sea_orm(not_null, default = "now()")]
|
|
pub created_at: DateTime<Utc>,
|
|
|
|
#[sea_orm(not_null, default = "now()")]
|
|
pub updated_at: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, sea_orm::EnumIter, DeriveRelation)]
|
|
pub enum Relation {
|
|
#[sea_orm(belongs_to = "super::users::Entity", from = "Column::UserId", to = "super::users::Column::Id")]
|
|
User,
|
|
}
|
|
|
|
impl Related<super::users::Entity> for Entity {
|
|
fn to() -> RelationDef {
|
|
Relation::User.def()
|
|
}
|
|
}
|
|
|
|
impl ActiveModelBehavior for ActiveModel {
|
|
// Default implementation - SeaORM will handle timestamps automatically
|
|
}
|
|
|
|
// Builder pattern for Mentor creation
|
|
#[derive(Default, Serialize, Deserialize)]
|
|
pub struct MentorBuilder {
|
|
user_id: Option<Uuid>,
|
|
industries: Option<Vec<String>>,
|
|
expertise: Option<Vec<String>>,
|
|
languages: Option<Vec<String>>,
|
|
current_company: Option<String>,
|
|
current_role: Option<String>,
|
|
years_of_experience: Option<i32>,
|
|
topics_of_interest: Option<Vec<String>>,
|
|
preferred_mentee_level: Option<String>,
|
|
preferred_mentoring_formats: Option<Vec<String>>,
|
|
availability_commitment: Option<String>,
|
|
mentoring_rate: Option<f64>,
|
|
status: Option<String>,
|
|
is_deleted: Option<bool>,
|
|
}
|
|
|
|
impl MentorBuilder {
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn user_id(mut self, user_id: Uuid) -> Self {
|
|
self.user_id = Some(user_id);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn industries(mut self, industries: Vec<String>) -> Self {
|
|
self.industries = Some(industries);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn expertise(mut self, expertise: Vec<String>) -> Self {
|
|
self.expertise = Some(expertise);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn languages(mut self, languages: Vec<String>) -> Self {
|
|
self.languages = Some(languages);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn current_company(mut self, current_company: String) -> Self {
|
|
self.current_company = Some(current_company);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn current_role(mut self, current_role: String) -> Self {
|
|
self.current_role = Some(current_role);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn years_of_experience(mut self, years_of_experience: i32) -> Self {
|
|
self.years_of_experience = Some(years_of_experience);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn topics_of_interest(mut self, topics_of_interest: Vec<String>) -> Self {
|
|
self.topics_of_interest = Some(topics_of_interest);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn preferred_mentee_level(mut self, preferred_mentee_level: String) -> Self {
|
|
self.preferred_mentee_level = Some(preferred_mentee_level);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn preferred_mentoring_formats(mut self, preferred_mentoring_formats: Vec<String>) -> Self {
|
|
self.preferred_mentoring_formats = Some(preferred_mentoring_formats);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn availability_commitment(mut self, availability_commitment: String) -> Self {
|
|
self.availability_commitment = Some(availability_commitment);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn mentoring_rate(mut self, mentoring_rate: f64) -> Self {
|
|
self.mentoring_rate = Some(mentoring_rate);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn status(mut self, status: String) -> Self {
|
|
self.status = Some(status);
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_deleted(mut self, is_deleted: bool) -> Self {
|
|
self.is_deleted = Some(is_deleted);
|
|
self
|
|
}
|
|
|
|
pub fn build(self) -> Result<ActiveModel, String> {
|
|
let mut active_model = <ActiveModel as std::default::Default>::default();
|
|
|
|
if let Some(user_id) = self.user_id {
|
|
active_model.user_id = Set(user_id);
|
|
} else {
|
|
return Err("User ID is required".to_string());
|
|
}
|
|
|
|
if let Some(industries) = self.industries {
|
|
active_model.industries = Set(Some(serde_json::to_value(industries).map_err(|e| format!("Failed to serialize industries: {}", e))?));
|
|
}
|
|
|
|
if let Some(expertise) = self.expertise {
|
|
active_model.expertise = Set(Some(serde_json::to_value(expertise).map_err(|e| format!("Failed to serialize expertise: {}", e))?));
|
|
}
|
|
|
|
if let Some(languages) = self.languages {
|
|
active_model.languages = Set(Some(serde_json::to_value(languages).map_err(|e| format!("Failed to serialize languages: {}", e))?));
|
|
}
|
|
|
|
if let Some(current_company) = self.current_company {
|
|
active_model.current_company = Set(Some(current_company));
|
|
}
|
|
|
|
if let Some(current_role) = self.current_role {
|
|
active_model.current_role = Set(Some(current_role));
|
|
}
|
|
|
|
if let Some(years_of_experience) = self.years_of_experience {
|
|
active_model.years_of_experience = Set(Some(years_of_experience));
|
|
}
|
|
|
|
if let Some(topics_of_interest) = self.topics_of_interest {
|
|
active_model.topics_of_interest = Set(Some(serde_json::to_value(topics_of_interest).map_err(|e| format!("Failed to serialize topics_of_interest: {}", e))?));
|
|
}
|
|
|
|
if let Some(preferred_mentee_level) = self.preferred_mentee_level {
|
|
active_model.preferred_mentee_level = Set(Some(preferred_mentee_level));
|
|
}
|
|
|
|
if let Some(preferred_mentoring_formats) = self.preferred_mentoring_formats {
|
|
active_model.preferred_mentoring_formats = Set(Some(serde_json::to_value(preferred_mentoring_formats).map_err(|e| format!("Failed to serialize preferred_mentoring_formats: {}", e))?));
|
|
}
|
|
|
|
if let Some(availability_commitment) = self.availability_commitment {
|
|
active_model.availability_commitment = Set(Some(availability_commitment));
|
|
}
|
|
|
|
if let Some(mentoring_rate) = self.mentoring_rate {
|
|
active_model.mentoring_rate = Set(Some(mentoring_rate));
|
|
}
|
|
|
|
if let Some(status) = self.status {
|
|
active_model.status = Set(Some(status));
|
|
}
|
|
|
|
if let Some(is_deleted) = self.is_deleted {
|
|
active_model.is_deleted = Set(is_deleted);
|
|
}
|
|
|
|
Ok(active_model)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::seaorm::common::utils::generate_uuid;
|
|
use serde_json::json;
|
|
|
|
#[test]
|
|
fn test_mentor_model_creation() {
|
|
let uid = generate_uuid();
|
|
let mentor = MentorBuilder::new()
|
|
.user_id(uid)
|
|
.industries(vec!["Technology".to_string(), "Finance".to_string()])
|
|
.expertise(vec!["Blockchain".to_string(), "AI".to_string()])
|
|
.languages(vec!["English".to_string(), "Spanish".to_string()])
|
|
.current_company("Tech Corp".to_string())
|
|
.current_role("Senior Engineer".to_string())
|
|
.years_of_experience(10)
|
|
.topics_of_interest(vec!["Web3".to_string(), "Machine Learning".to_string()])
|
|
.preferred_mentee_level("Intermediate".to_string())
|
|
.preferred_mentoring_formats(vec!["1:1".to_string(), "Group".to_string()])
|
|
.availability_commitment("Weekly".to_string())
|
|
.mentoring_rate(150.0)
|
|
.status("active".to_string())
|
|
.build();
|
|
|
|
assert!(mentor.is_ok());
|
|
let mentor_model = mentor.unwrap();
|
|
assert_eq!(mentor_model.user_id, Set(uid));
|
|
assert_eq!(mentor_model.industries, Set(Some(json!(["Technology", "Finance"]))));
|
|
assert_eq!(mentor_model.expertise, Set(Some(json!(["Blockchain", "AI"]))));
|
|
}
|
|
|
|
#[test]
|
|
fn test_mentor_model_missing_required_fields() {
|
|
let mentor = MentorBuilder::new()
|
|
// Missing user_id
|
|
.industries(vec!["Technology".to_string()])
|
|
.build();
|
|
|
|
assert!(mentor.is_err());
|
|
assert_eq!(mentor.unwrap_err(), "User ID is required");
|
|
}
|
|
} |