Struct ScenarioPromotion 

pub struct ScenarioPromotion {

    pub id: Uuid,
    pub scenario_id: Uuid,
    pub scenario_version: String,
    pub workspace_id: Uuid,
    pub from_environment: String,
    pub to_environment: String,
    pub promoted_by: Uuid,
    pub approved_by: Option<Uuid>,
    pub status: String,
    pub requires_approval: bool,
    pub approval_required_reason: Option<String>,
    pub comments: Option<String>,
    pub approval_comments: Option<String>,
    pub completed_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Scenario promotion model

Fields

id: Uuid

Unique identifier

scenario_id: Uuid

Scenario ID being promoted

scenario_version: String

Scenario version being promoted

workspace_id: Uuid

Workspace ID where promotion occurs

from_environment: String

Source environment (dev or test)

to_environment: String

Target environment (test or prod)

promoted_by: Uuid

User who initiated the promotion

approved_by: Option<Uuid>

User who approved the promotion (nullable)

status: String

Promotion status

requires_approval: bool

Whether this promotion requires approval

approval_required_reason: Option<String>

Reason why approval is required

comments: Option<String>

Comments from promoter

approval_comments: Option<String>

Comments from approver

completed_at: Option<DateTime<Utc>>

When promotion was completed

created_at: DateTime<Utc>

Creation timestamp

updated_at: DateTime<Utc>

Last update timestamp

Implementations

impl ScenarioPromotion

pub fn status_enum(&self) -> Option<PromotionStatus>

Get status as enum

pub async fn create( pool: &Pool<Postgres>, scenario_id: Uuid, scenario_version: &str, workspace_id: Uuid, from_environment: &str, to_environment: &str, promoted_by: Uuid, requires_approval: bool, approval_required_reason: Option<&str>, comments: Option<&str>, ) -> Result<ScenarioPromotion, Error>

Create a new promotion request

pub async fn find_by_id( pool: &Pool<Postgres>, id: Uuid, ) -> Result<Option<ScenarioPromotion>, Error>

Find by ID

pub async fn list_by_workspace( pool: &Pool<Postgres>, workspace_id: Uuid, status: Option<PromotionStatus>, ) -> Result<Vec<ScenarioPromotion>, Error>

List promotions for a workspace

pub async fn list_by_scenario( pool: &Pool<Postgres>, scenario_id: Uuid, ) -> Result<Vec<ScenarioPromotion>, Error>

List promotions for a scenario

pub async fn approve( &self, pool: &Pool<Postgres>, approved_by: Uuid, approval_comments: Option<&str>, ) -> Result<ScenarioPromotion, Error>

Approve a promotion

pub async fn reject( &self, pool: &Pool<Postgres>, rejected_by: Uuid, rejection_reason: &str, ) -> Result<ScenarioPromotion, Error>

Reject a promotion

pub async fn mark_completed( pool: &Pool<Postgres>, id: Uuid, ) -> Result<ScenarioPromotion, Error>

Mark promotion as completed

pub async fn mark_failed( pool: &Pool<Postgres>, id: Uuid, error_message: &str, ) -> Result<ScenarioPromotion, Error>

Mark promotion as failed

Trait Implementations

impl Clone for ScenarioPromotion

fn clone(&self) -> ScenarioPromotion

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScenarioPromotion

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScenarioPromotion

fn deserialize<__D>( __deserializer: __D, ) -> Result<ScenarioPromotion, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, R> FromRow<'a, R> for ScenarioPromotion

where R: Row, &'a str: ColumnIndex<R>, Uuid: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, String: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, Option<Uuid>: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, bool: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, Option<String>: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, Option<DateTime<Utc>>: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>, DateTime<Utc>: Decode<'a, <R as Row>::Database> + Type<<R as Row>::Database>,

fn from_row(__row: &'a R) -> Result<ScenarioPromotion, Error>

impl Serialize for ScenarioPromotion

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.