joystream/src/content_working_group/lib.rs

// Ensure we're `no_std` when compiling for Wasm.
#![cfg_attr(not(feature = "std"), no_std)]

//#[cfg(feature = "std")]
//use serde::{Deserialize, Serialize};

use codec::{Decode, Encode}; // Codec
                             //use rstd::collections::btree_map::BTreeMap;
use crate::membership::{members, role_types};
use hiring;
use minting;
use recurringrewards;
use rstd::collections::btree_set::BTreeSet;
use rstd::convert::From;
use rstd::prelude::*;
use runtime_primitives::traits::{One, Zero}; // Member, SimpleArithmetic, MaybeSerialize
use srml_support::traits::{Currency, ExistenceRequirement, WithdrawReasons};
use srml_support::{
    decl_event,
    decl_module,
    decl_storage,
    dispatch, // , StorageMap, , Parameter
    ensure,
};
use stake;
use system::{self, ensure_root, ensure_signed};
use versioned_store_permissions;

/// DIRTY IMPORT BECAUSE
/// InputValidationLengthConstraint has not been factored out yet!!!
use forum::InputValidationLengthConstraint;

/// Module configuration trait for this Substrate module.
pub trait Trait:
    system::Trait
    + minting::Trait
    + recurringrewards::Trait
    + stake::Trait
    + hiring::Trait
    + versioned_store_permissions::Trait
    + members::Trait
{
    // + Sized

    /// The event type.
    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
}

/// Type constraint for identifer used for actors in members module in this runtime.
pub type ActorIdInMembersModule<T> = <T as members::Trait>::ActorId;

/// Type for identifier for channels.
/// The ChannelId must be capable of behaving like an actor id for membership module,
/// since publishers are identified by their channel id.
pub type ChannelId<T> = ActorIdInMembersModule<T>;

/// Type identifier for lead role, which must be same as membership actor identifeir
pub type LeadId<T> = ActorIdInMembersModule<T>;

/// Type identifier for curator role, which must be same as membership actor identifeir
pub type CuratorId<T> = ActorIdInMembersModule<T>;

/// Type for the identifer for an opening for a curator.
pub type CuratorOpeningId<T> = <T as hiring::Trait>::OpeningId;

/// Tyoe for the indentifier for an application as a curator.
pub type CuratorApplicationId<T> = <T as hiring::Trait>::ApplicationId;

/// Balance type of runtime
pub type BalanceOf<T> =
    <<T as stake::Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::Balance;

/// Balance type of runtime
pub type CurrencyOf<T> = <T as stake::Trait>::Currency;

/// Negative imbalance of runtime.
pub type NegativeImbalance<T> =
    <<T as stake::Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::NegativeImbalance;

/// Type of mintin reward relationship identifiers
pub type RewardRelationshipId<T> = <T as recurringrewards::Trait>::RewardRelationshipId;

/// Stake identifier in staking module
pub type StakeId<T> = <T as stake::Trait>::StakeId;

/// Type of permissions module prinicipal identifiers
pub type PrincipalId<T> = <T as versioned_store_permissions::Trait>::Credential;

/*
 * MOVE ALL OF THESE OUT TO COMMON LATER
 */

static MSG_CHANNEL_CREATION_DISABLED: &str = "Channel creation currently disabled.";
static MSG_CHANNEL_HANDLE_TOO_SHORT: &str = "Channel handle too short.";
static MSG_CHANNEL_HANDLE_TOO_LONG: &str = "Channel handle too long.";
static MSG_CHANNEL_DESCRIPTION_TOO_SHORT: &str = "Channel description too short";
static MSG_CHANNEL_DESCRIPTION_TOO_LONG: &str = "Channel description too long";
//static MSG_MEMBER_CANNOT_BECOME_PUBLISHER: &str =
//    "Member cannot become a publisher";
static MSG_CHANNEL_ID_INVALID: &str = "Channel id invalid";
static MSG_ORIGIN_DOES_NOT_MATCH_CHANNEL_ROLE_ACCOUNT: &str =
    "Origin does not match channel role account";
static MSG_CURRENT_LEAD_ALREADY_SET: &str = "Current lead is already set";
static MSG_CURRENT_LEAD_NOT_SET: &str = "Current lead is not set";
//static MSG_MEMBER_CANNOT_BECOME_CURATOR_LEAD: &str =
//    "The member cannot become curator lead";
//static MSG_LEAD_IS_NOT_SET: &str =
//    "Lead is not set";
static MSG_ORIGIN_IS_NOT_LEAD: &str = "Origin is not lead";
static MSG_ORIGIN_IS_NOT_APPLICANT: &str = "Origin is not applicant";
//static MSG_OPENING_CANNOT_ACTIVATE_IN_THE_PAST: &str =
//    "Opening cannot activate in the past";
static MSG_CURATOR_OPENING_DOES_NOT_EXIST: &str = "Curator opening does not exist";
static MSG_CURATOR_APPLICATION_DOES_NOT_EXIST: &str = "Curator application does not exist";
//static MSG_INSUFFICIENT_BALANCE_TO_COVER_ROLE_STAKE: &str =
//    "Insufficient balance to cover role stake";
//static MSG_INSUFFICIENT_BALANCE_TO_COVER_APPLICATION_STAKE: &str =
//    "Insufficient balance to cover application stake";
static MSG_INSUFFICIENT_BALANCE_TO_APPLY: &str = "Insufficient balance to apply";
static MSG_SUCCESSFUL_CURATOR_APPLICATION_DOES_NOT_EXIST: &str =
    "Successful curatora pplication does not exist";
static MSG_MEMBER_NO_LONGER_REGISTRABLE_AS_CURATOR: &str =
    "Member no longer registrable as curator";
static MSG_CURATOR_DOES_NOT_EXIST: &str = "Curator does not exist";
static MSG_CURATOR_IS_NOT_ACTIVE: &str = "Curator is not active";
static MSG_CURATOR_EXIT_RATIOANEL_TEXT_TOO_LONG: &str = "Curator exit rationale text is too long";
static MSG_CURATOR_EXIT_RATIOANEL_TEXT_TOO_SHORT: &str = "Curator exit rationale text is too short";
static MSG_CURATOR_APPLICATION_TEXT_TOO_LONG: &str = "Curator application text too long";
static MSG_CURATOR_APPLICATION_TEXT_TOO_SHORT: &str = "Curator application text too short";
static MSG_SIGNER_IS_NOT_CURATOR_ROLE_ACCOUNT: &str = "Signer is not curator role account";
static MSG_UNSTAKER_DOES_NOT_EXIST: &str = "Unstaker does not exist";
static MSG_CURATOR_HAS_NO_REWARD: &str = "Curator has no recurring reward";
static MSG_CURATOR_NOT_CONTROLLED_BY_MEMBER: &str = "Curator not controlled by member";
static MSG_CHANNEL_NAME_ALREADY_TAKEN: &str = "Channel name is already taken";

/// The exit stage of a lead involvement in the working group.
#[derive(Encode, Decode, Debug, Clone)]
pub struct ExitedLeadRole<BlockNumber> {
    /// When exit was initiated.
    pub initiated_at_block_number: BlockNumber,
}

/// The stage of the involvement of a lead in the working group.
#[derive(Encode, Decode, Debug, Clone)]
pub enum LeadRoleState<BlockNumber> {
    /// Currently active.
    Active,

    /// No longer active, for some reason
    Exited(ExitedLeadRole<BlockNumber>),
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl<BlockNumber> Default for LeadRoleState<BlockNumber> {
    fn default() -> Self {
        LeadRoleState::Active
    }
}

/// Working group lead: curator lead
/// For now this role is not staked or inducted through an structured process, like the hiring module,
/// hence information about this is missing. Recurring rewards is included, somewhat arbitrarily!
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct Lead<AccountId, RewardRelationshipId, BlockNumber> {
    /// Account used to authenticate in this role,
    pub role_account: AccountId,

    /// Whether the role has recurring reward, and if so an identifier for this.
    pub reward_relationship: Option<RewardRelationshipId>,

    /// When was inducted
    /// TODO: Add richer information about circumstances of induction, like referencing a council proposal?
    pub inducted: BlockNumber,

    /// The stage of the involvement of this lead in the working group.
    pub stage: LeadRoleState<BlockNumber>,
}

/// Origin of exit initiation on behalf of a curator.'
#[derive(Encode, Decode, Debug, Clone)]
pub enum CuratorExitInitiationOrigin {
    /// Lead is origin.
    Lead,

    /// The curator exiting is the origin.
    Curator,
}

/// The exit stage of a curators involvement in the working group.
#[derive(Encode, Decode, Debug, Clone)]
pub struct CuratorExitSummary<BlockNumber> {
    /// Origin for exit.
    pub origin: CuratorExitInitiationOrigin,

    /// When exit was initiated.
    pub initiated_at_block_number: BlockNumber,

    /// Explainer for why exit was initited.
    pub rationale_text: Vec<u8>,
}

impl<BlockNumber: Clone> CuratorExitSummary<BlockNumber> {
    pub fn new(
        origin: &CuratorExitInitiationOrigin,
        initiated_at_block_number: &BlockNumber,
        rationale_text: &Vec<u8>,
    ) -> Self {
        CuratorExitSummary {
            origin: (*origin).clone(),
            initiated_at_block_number: (*initiated_at_block_number).clone(),
            rationale_text: (*rationale_text).clone(),
        }
    }
}

/// The stage of the involvement of a curator in the working group.
#[derive(Encode, Decode, Debug, Clone)]
pub enum CuratorRoleStage<BlockNumber> {
    /// Currently active.
    Active,

    /// Currently unstaking
    Unstaking(CuratorExitSummary<BlockNumber>),

    /// No longer active and unstaked
    Exited(CuratorExitSummary<BlockNumber>),
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl<BlockNumber> Default for CuratorRoleStage<BlockNumber> {
    fn default() -> Self {
        CuratorRoleStage::Active
    }
}

/// The induction of a curator in the working group.
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct CuratorInduction<LeadId, CuratorApplicationId, BlockNumber> {
    /// Lead responsible for inducting curator
    pub lead: LeadId,

    /// Application through which curator was inducted
    pub curator_application_id: CuratorApplicationId,

    /// When induction occurred
    pub at_block: BlockNumber,
}

impl<LeadId: Clone, CuratorApplicationId: Clone, BlockNumber: Clone>
    CuratorInduction<LeadId, CuratorApplicationId, BlockNumber>
{
    pub fn new(
        lead: &LeadId,
        curator_application_id: &CuratorApplicationId,
        at_block: &BlockNumber,
    ) -> Self {
        CuratorInduction {
            lead: (*lead).clone(),
            curator_application_id: (*curator_application_id).clone(),
            at_block: (*at_block).clone(),
        }
    }
}

/// Role stake information for a curator.
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct CuratorRoleStakeProfile<StakeId, BlockNumber> {
    /// Whether participant is staked, and if so, the identifier for this staking in the staking module.
    pub stake_id: StakeId,

    /// Unstaking period when terminated.
    pub termination_unstaking_period: Option<BlockNumber>,

    /// Unstaking period when exiting.
    pub exit_unstaking_period: Option<BlockNumber>,
}

impl<StakeId: Clone, BlockNumber: Clone> CuratorRoleStakeProfile<StakeId, BlockNumber> {
    pub fn new(
        stake_id: &StakeId,
        termination_unstaking_period: &Option<BlockNumber>,
        exit_unstaking_period: &Option<BlockNumber>,
    ) -> Self {
        Self {
            stake_id: (*stake_id).clone(),
            termination_unstaking_period: (*termination_unstaking_period).clone(),
            exit_unstaking_period: (*exit_unstaking_period).clone(),
        }
    }
}

/// Working group participant: curator
/// This role can be staked, have reward and be inducted through the hiring module.
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct Curator<
    AccountId,
    RewardRelationshipId,
    StakeId,
    BlockNumber,
    LeadId,
    CuratorApplicationId,
    PrincipalId,
> {
    /// Account used to authenticate in this role,
    pub role_account: AccountId,

    /// Whether the role has recurring reward, and if so an identifier for this.
    pub reward_relationship: Option<RewardRelationshipId>,

    /// When set, describes role stake of curator.
    pub role_stake_profile: Option<CuratorRoleStakeProfile<StakeId, BlockNumber>>,

    /// The stage of this curator in the working group.
    pub stage: CuratorRoleStage<BlockNumber>,

    /// How the curator was inducted into the working group.
    pub induction: CuratorInduction<LeadId, CuratorApplicationId, BlockNumber>,

    /// Whether this curator can unilaterally alter the curation status of a channel.
    //pub can_update_channel_curation_status: bool,

    /// Permissions module principal id
    pub principal_id: PrincipalId,
}

impl<
        AccountId: Clone,
        RewardRelationshipId: Clone,
        StakeId: Clone,
        BlockNumber: Clone,
        LeadId: Clone,
        ApplicationId: Clone,
        PrincipalId: Clone,
    >
    Curator<
        AccountId,
        RewardRelationshipId,
        StakeId,
        BlockNumber,
        LeadId,
        ApplicationId,
        PrincipalId,
    >
{
    pub fn new(
        role_account: &AccountId,
        reward_relationship: &Option<RewardRelationshipId>,
        role_stake_profile: &Option<CuratorRoleStakeProfile<StakeId, BlockNumber>>,
        stage: &CuratorRoleStage<BlockNumber>,
        induction: &CuratorInduction<LeadId, ApplicationId, BlockNumber>,
        //can_update_channel_curation_status: bool,
        principal_id: &PrincipalId,
    ) -> Self {
        Curator {
            role_account: (*role_account).clone(),
            reward_relationship: (*reward_relationship).clone(),
            role_stake_profile: (*role_stake_profile).clone(),
            stage: (*stage).clone(),
            induction: (*induction).clone(),
            //can_update_channel_curation_status: can_update_channel_curation_status,
            principal_id: (*principal_id).clone(),
        }
    }
}

/// An opening for a curator role.
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct CuratorOpening<OpeningId, BlockNumber, Balance, CuratorApplicationId: core::cmp::Ord> {
    /// Identifer for underlying opening in the hiring module.
    pub opening_id: OpeningId,

    /// Set of identifiers for all curator applications ever added
    pub curator_applications: BTreeSet<CuratorApplicationId>,

    /// Commitment to policies in opening.
    pub policy_commitment: OpeningPolicyCommitment<BlockNumber, Balance>, /*
                                                                           * Add other stuff here in the future?
                                                                           * Like default payment terms, privilidges etc.?
                                                                           * Not obvious that it serves much of a purpose, they are mutable
                                                                           * after all, they need to be.
                                                                           * Revisit.
                                                                           */
}

/// An application for the curator role.
#[derive(Encode, Decode, Default, Debug, Clone)]
pub struct CuratorApplication<AccountId, CuratorOpeningId, MemberId, ApplicationId> {
    /// Account used to authenticate in this role,
    pub role_account: AccountId,

    /// Opening on which this application applies
    pub curator_opening_id: CuratorOpeningId,

    /// Member applying
    pub member_id: MemberId,

    /// Underlying application in hiring module
    pub application_id: ApplicationId,
}

impl<AccountId: Clone, CuratorOpeningId: Clone, MemberId: Clone, ApplicationId: Clone>
    CuratorApplication<AccountId, CuratorOpeningId, MemberId, ApplicationId>
{
    pub fn new(
        role_account: &AccountId,
        curator_opening_id: &CuratorOpeningId,
        member_id: &MemberId,
        application_id: &ApplicationId,
    ) -> Self {
        CuratorApplication {
            role_account: (*role_account).clone(),
            curator_opening_id: (*curator_opening_id).clone(),
            member_id: (*member_id).clone(),
            application_id: (*application_id).clone(),
        }
    }
}

/// Type of .... .
#[derive(Encode, Decode, Debug, Clone, PartialEq, Eq)]
pub enum CurationActor<CuratorId> {
    Lead,
    Curator(CuratorId),
}

/*
 * BEGIN: =========================================================
 * Channel stuff
 */

/// Type of channel content.
#[derive(Encode, Decode, Debug, Clone, PartialEq)]
pub enum ChannelContentType {
    Video,
    Music,
    Ebook,
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl Default for ChannelContentType {
    fn default() -> Self {
        ChannelContentType::Video
    }
}

/// Status of channel, as set by the owner.
/// Is only meant to affect visibility, mutation of channel and child content
/// is unaffected on runtime.
#[derive(Encode, Decode, Debug, Clone, PartialEq)]
pub enum ChannelPublishingStatus {
    /// Compliant UIs should render.
    Published,

    /// Compliant UIs should not render it or any child content.
    NotPublished,
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl Default for ChannelPublishingStatus {
    fn default() -> Self {
        ChannelPublishingStatus::Published
    }
}

/// Status of channel, as set by curators.
/// Is only meant to affect visibility currently, but in the future
/// it will also gate publication of new child content,
/// editing properties, revenue flows, etc.
#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChannelCurationStatus {
    Normal,
    Censored,
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl Default for ChannelCurationStatus {
    fn default() -> Self {
        ChannelCurationStatus::Normal
    }
}

/// A channel for publishing content.
#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
pub struct Channel<MemberId, AccountId, BlockNumber, PrincipalId> {
    /// Unique human readble channel name.
    pub channel_name: Vec<u8>,

    /// Whether channel has been verified, in the normal Web2.0 platform sense of being authenticated.
    pub verified: bool,

    /// Human readable description of channel purpose and scope.
    pub description: Vec<u8>,

    /// The type of channel.
    pub content: ChannelContentType,

    /// Member who owns channel.
    pub owner: MemberId,

    /// Account used to authenticate as owner.
    /// Can be updated through membership role key.
    pub role_account: AccountId,

    /// Publication status of channel.
    pub publishing_status: ChannelPublishingStatus,

    /// Curation status of channel.
    pub curation_status: ChannelCurationStatus,

    /// When channel was established.
    pub created: BlockNumber,

    /// Permissions module principal id
    pub principal_id: PrincipalId,
}

/*
 * END: =========================================================
 * Channel stuff
 */

/// Permissions module principal
#[derive(Encode, Decode, Debug, Clone)]
pub enum Principal<CuratorId, ChannelId> {
    /// Its sloppy to have this here, less safe,
    /// but its not worth the ffort to solve.
    Lead,

    Curator(CuratorId),

    ChannelOwner(ChannelId),
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl<CuratorId, ChannelId> Default for Principal<CuratorId, ChannelId> {
    fn default() -> Self {
        Principal::Lead
    }
}

/// Terms for slashings applied to a given role
#[derive(Encode, Decode, Debug, Clone, PartialEq, Eq)]
pub struct SlashableTerms {
    /// Maximum number of slashes.
    pub max_count: u16,

    /// Maximum percentage points of remaining stake which may be slashed in a single slash.
    pub max_percent_pts_per_time: u16,
}

/// Terms for what slashing can be applied in some context
#[derive(Encode, Decode, Debug, Clone, PartialEq, Eq)]
pub enum SlashingTerms {
    Unslashable,
    Slashable(SlashableTerms),
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl Default for SlashingTerms {
    fn default() -> Self {
        Self::Unslashable
    }
}

/// A commitment to the set of policy variables relevant to an opening.
/// An applicant can observe this commitment and be secure that the terms
/// of the application process cannot be changed ex-post.
#[derive(Encode, Decode, Debug, Clone, Default, PartialEq, Eq)]
pub struct OpeningPolicyCommitment<BlockNumber, Balance> {
    /// Rationing to be used
    pub application_rationing_policy: Option<hiring::ApplicationRationingPolicy>,

    /// Maximum length of review period of applications
    pub max_review_period_length: BlockNumber,

    /// Staking policy for application
    pub application_staking_policy: Option<hiring::StakingPolicy<Balance, BlockNumber>>,

    /// Staking policy for role itself
    pub role_staking_policy: Option<hiring::StakingPolicy<Balance, BlockNumber>>,

    // Slashing terms during application
    // pub application_slashing_terms: SlashingTerms,

    // Slashing terms during role, NOT application itself!
    pub role_slashing_terms: SlashingTerms,

    /// When filling an opening: Unstaking period for application stake of successful applicants
    pub fill_opening_successful_applicant_application_stake_unstaking_period: Option<BlockNumber>,

    /// When filling an opening:
    pub fill_opening_failed_applicant_application_stake_unstaking_period: Option<BlockNumber>,

    /// When filling an opening:
    pub fill_opening_failed_applicant_role_stake_unstaking_period: Option<BlockNumber>,

    /// When terminating a curator:
    pub terminate_curator_application_stake_unstaking_period: Option<BlockNumber>,

    /// When terminating a curator:
    pub terminate_curator_role_stake_unstaking_period: Option<BlockNumber>,

    /// When a curator exists: ..
    pub exit_curator_role_application_stake_unstaking_period: Option<BlockNumber>,

    /// When a curator exists: ..
    pub exit_curator_role_stake_unstaking_period: Option<BlockNumber>,
}

/// Represents a possible unstaker in working group.
#[derive(Encode, Decode, Debug, Eq, PartialEq, Clone, PartialOrd)]
pub enum WorkingGroupUnstaker<LeadId, CuratorId> {
    ///
    Lead(LeadId),

    ///
    Curator(CuratorId),
}

/// Must be default constructible because it indirectly is a value in a storage map.
/// ***SHOULD NEVER ACTUALLY GET CALLED, IS REQUIRED TO DUE BAD STORAGE MODEL IN SUBSTRATE***
impl<LeadId: Default, CuratorId> Default for WorkingGroupUnstaker<LeadId, CuratorId> {
    fn default() -> Self {
        Self::Lead(LeadId::default())
    }
}

/*
pub enum ChannelActor<T: Trait> {

    ///
    WorkingGroupActor(WorkingGroupActor<T>),

    ///
    Owner
}
*/

// ======================================================================== //
// Move this out in its own file later //
// ======================================================================== //

/*
struct WrappedBeginAcceptingApplicationsError { // can this be made generic, or does that undermine the whole orhpan rule spirit?
    pub error: hiring::BeginAcceptingApplicationsError
}
*/

struct WrappedError<E> {
    // can this be made generic, or does that undermine the whole orhpan rule spirit?
    pub error: E,
}

/// ....
macro_rules! ensure_on_wrapped_error {
    ($call:expr) => {{
        { $call }.map_err(|err| WrappedError { error: err })
    }};
}

// Add macro here to make this
//derive_from_impl(hiring::BeginAcceptingApplicationsError)
//derive_from_impl(hiring::BeginAcceptingApplicationsError)

impl rstd::convert::From<WrappedError<hiring::BeginAcceptingApplicationsError>> for &str {
    fn from(wrapper: WrappedError<hiring::BeginAcceptingApplicationsError>) -> Self {
        match wrapper.error {
            hiring::BeginAcceptingApplicationsError::OpeningDoesNotExist => {
                "Opening does not exist"
            }
            hiring::BeginAcceptingApplicationsError::OpeningIsNotInWaitingToBeginStage => {
                "Opening Is Not in Waiting"
            }
        }
    }
}

impl rstd::convert::From<WrappedError<hiring::AddOpeningError>> for &str {
    fn from(wrapper: WrappedError<hiring::AddOpeningError>) -> Self {
        match wrapper.error {
            hiring::AddOpeningError::OpeningMustActivateInTheFuture => {
                "Opening must activate in the future"
            }
            hiring::AddOpeningError::StakeAmountLessThanMinimumCurrencyBalance(purpose) => {
                match purpose {
                    hiring::StakePurpose::Role => {
                        "Role stake amount less than minimum currency balance"
                    }
                    hiring::StakePurpose::Application => {
                        "Application stake amount less than minimum currency balance"
                    }
                }
            }
        }
    }
}

impl rstd::convert::From<WrappedError<hiring::BeginReviewError>> for &str {
    fn from(wrapper: WrappedError<hiring::BeginReviewError>) -> Self {
        match wrapper.error {
            hiring::BeginReviewError::OpeningDoesNotExist => "Opening does not exist",
            hiring::BeginReviewError::OpeningNotInAcceptingApplicationsStage => {
                "Opening not in accepting applications stage"
            }
        }
    }
}

impl<T: hiring::Trait> rstd::convert::From<WrappedError<hiring::FillOpeningError<T>>> for &str {
    fn from(wrapper: WrappedError<hiring::FillOpeningError<T>>) -> Self {
        match wrapper.error {
            hiring::FillOpeningError::<T>::OpeningDoesNotExist => "OpeningDoesNotExist",
            hiring::FillOpeningError::<T>::OpeningNotInReviewPeriodStage => {
                "OpeningNotInReviewPeriodStage"
            }
            hiring::FillOpeningError::<T>::UnstakingPeriodTooShort(
                stake_purpose,
                outcome_in_filled_opening,
            ) => match stake_purpose {
                hiring::StakePurpose::Application => match outcome_in_filled_opening {
                    hiring::ApplicationOutcomeInFilledOpening::Success => {
                        "Application stake unstaking period for successful applicants too short"
                    }
                    hiring::ApplicationOutcomeInFilledOpening::Failure => {
                        "Application stake unstaking period for failed applicants too short"
                    }
                },
                hiring::StakePurpose::Role => match outcome_in_filled_opening {
                    hiring::ApplicationOutcomeInFilledOpening::Success => {
                        "Role stake unstaking period for successful applicants too short"
                    }
                    hiring::ApplicationOutcomeInFilledOpening::Failure => {
                        "Role stake unstaking period for failed applicants too short"
                    }
                },
            },
            hiring::FillOpeningError::<T>::RedundantUnstakingPeriodProvided(
                stake_purpose,
                outcome_in_filled_opening,
            ) => match stake_purpose {
                hiring::StakePurpose::Application => match outcome_in_filled_opening {
                    hiring::ApplicationOutcomeInFilledOpening::Success => {
                        "Application stake unstaking period for successful applicants redundant"
                    }
                    hiring::ApplicationOutcomeInFilledOpening::Failure => {
                        "Application stake unstaking period for failed applicants redundant"
                    }
                },
                hiring::StakePurpose::Role => match outcome_in_filled_opening {
                    hiring::ApplicationOutcomeInFilledOpening::Success => {
                        "Role stake unstaking period for successful applicants redundant"
                    }
                    hiring::ApplicationOutcomeInFilledOpening::Failure => {
                        "Role stake unstaking period for failed applicants redundant"
                    }
                },
            },
            hiring::FillOpeningError::<T>::ApplicationDoesNotExist(_application_id) => {
                "ApplicationDoesNotExist"
            }
            hiring::FillOpeningError::<T>::ApplicationNotInActiveStage(_application_id) => {
                "ApplicationNotInActiveStage"
            }
        }
    }
}

impl rstd::convert::From<WrappedError<hiring::DeactivateApplicationError>> for &str {
    fn from(wrapper: WrappedError<hiring::DeactivateApplicationError>) -> Self {
        match wrapper.error {
            hiring::DeactivateApplicationError::ApplicationDoesNotExist => {
                "ApplicationDoesNotExist"
            }
            hiring::DeactivateApplicationError::ApplicationNotActive => "ApplicationNotActive",
            hiring::DeactivateApplicationError::OpeningNotAcceptingApplications => {
                "OpeningNotAcceptingApplications"
            }
            hiring::DeactivateApplicationError::UnstakingPeriodTooShort(_stake_purpose) => {
                "UnstakingPeriodTooShort ..."
            }
            hiring::DeactivateApplicationError::RedundantUnstakingPeriodProvided(
                _stake_purpose,
            ) => "RedundantUnstakingPeriodProvided ...",
        }
    }
}

impl rstd::convert::From<WrappedError<members::ControllerAccountForMemberCheckFailed>> for &str {
    fn from(wrapper: WrappedError<members::ControllerAccountForMemberCheckFailed>) -> Self {
        match wrapper.error {
            members::ControllerAccountForMemberCheckFailed::NotMember => "Is not a member",
            members::ControllerAccountForMemberCheckFailed::NotControllerAccount => {
                "Account is not controller account of member"
            }
        }
    }
}

impl rstd::convert::From<WrappedError<hiring::AddApplicationError>> for &str {
    fn from(wrapper: WrappedError<hiring::AddApplicationError>) -> Self {
        match wrapper.error {
            hiring::AddApplicationError::OpeningDoesNotExist => "OpeningDoesNotExist",
            hiring::AddApplicationError::StakeProvidedWhenRedundant(_stake_purpose) => {
                "StakeProvidedWhenRedundant ..."
            }
            hiring::AddApplicationError::StakeMissingWhenRequired(_stake_purpose) => {
                "StakeMissingWhenRequired ..."
            }
            hiring::AddApplicationError::StakeAmountTooLow(_stake_purpose) => {
                "StakeAmountTooLow ..."
            }
            hiring::AddApplicationError::OpeningNotInAcceptingApplicationsStage => {
                "OpeningNotInAcceptingApplicationsStage"
            }
            hiring::AddApplicationError::NewApplicationWasCrowdedOut => {
                "NewApplicationWasCrowdedOut"
            }
        }
    }
}

impl rstd::convert::From<WrappedError<members::MemberControllerAccountDidNotSign>> for &str {
    fn from(wrapper: WrappedError<members::MemberControllerAccountDidNotSign>) -> Self {
        match wrapper.error {
            members::MemberControllerAccountDidNotSign::UnsignedOrigin => "Unsigned origin",
            members::MemberControllerAccountDidNotSign::MemberIdInvalid => "Member id is invalid",
            members::MemberControllerAccountDidNotSign::SignerControllerAccountMismatch => {
                "Signer does not match controller account"
            }
        }
    }
}

// ======================================================================== //

decl_storage! {
    trait Store for Module<T: Trait> as ContentWorkingGroup {

        /// The mint currently funding the rewards for this module.
        pub Mint get(mint) config(): <T as minting::Trait>::MintId;

        /// The current lead.
        pub CurrentLeadId get(current_lead_id) config(): Option<LeadId<T>>;

        /// Maps identifier to corresponding lead.
        pub LeadById get(lead_by_id) config(): linked_map LeadId<T> => Lead<T::AccountId, T::RewardRelationshipId, T::BlockNumber>;

        /// Next identifier for new current lead.
        pub NextLeadId get(next_lead_id) config(): LeadId<T>;

        /// Maps identifeir to curator opening.
        pub CuratorOpeningById get(curator_opening_by_id) config(): linked_map CuratorOpeningId<T> => CuratorOpening<T::OpeningId, T::BlockNumber, BalanceOf<T>, CuratorApplicationId<T>>;

        /// Next identifier valuefor new curator opening.
        pub NextCuratorOpeningId get(next_curator_opening_id) config(): CuratorOpeningId<T>;

        /// Maps identifier to curator application on opening.
        pub CuratorApplicationById get(curator_application_by_id) config(): linked_map CuratorApplicationId<T> => CuratorApplication<T::AccountId, CuratorOpeningId<T>, T::MemberId, T::ApplicationId>;

        /// Next identifier value for new curator application.
        pub NextCuratorApplicationId get(next_curator_application_id) config(): CuratorApplicationId<T>;

        /// Maps identifier to corresponding channel.
        pub ChannelById get(channel_by_id) config(): linked_map ChannelId<T> => Channel<T::MemberId, T::AccountId, T::BlockNumber, PrincipalId<T>>;

        /// Identifier to be used by the next channel introduced.
        pub NextChannelId get(next_channel_id) config(): ChannelId<T>;

        /// Maps (unique) channel handle to the corresponding identifier for the channel.
        /// Mapping is required to allow efficient (O(log N)) on-chain verification that a proposed handle is indeed unique
        /// at the time it is being proposed.
        pub ChannelIdByName get(channel_id_by_handle) config(): linked_map Vec<u8> => ChannelId<T>;

        /// Maps identifier to corresponding curator.
        pub CuratorById get(curator_by_id) config(): linked_map CuratorId<T> => Curator<T::AccountId, T::RewardRelationshipId, T::StakeId, T::BlockNumber, LeadId<T>, CuratorApplicationId<T>, PrincipalId<T>>;

        /// Next identifier for new curator.
        pub NextCuratorId get(next_curator_id) config(): CuratorId<T>;

        /// Maps identifier to principal.
        pub PrincipalById get(principal_by_id) config(): linked_map PrincipalId<T> => Principal<CuratorId<T>, ChannelId<T>>;

        /// Next identifier for
        pub NextPrincipalId get(next_principal_id) config(): PrincipalId<T>;

        /// Whether it is currently possible to create a channel via `create_channel` extrinsic.
        pub ChannelCreationEnabled get(channel_creation_enabled) config(): bool;

        /// Recover curator by the role stake which is currently unstaking.
        pub UnstakerByStakeId get(unstaker_by_stake_id) config(): linked_map StakeId<T> => WorkingGroupUnstaker<LeadId<T>, CuratorId<T>>;

        // Limits

        /// Limits the total number of curators which can be active.
        //pub MaxSimultanouslyActiveCurators get(max_simultanously_active_curators) config(): Option<u16>;

        // Limits the total number of openings which are not yet deactivated.
        // pub MaxSimultaneouslyActiveOpenings get(max_simultaneously_active_openings) config(): Option<u16>,

        // Vector length input guards

        pub ChannelHandleConstraint get(channel_handle_constraint) config(): InputValidationLengthConstraint;
        pub ChannelDescriptionConstraint get(channel_description_constraint) config(): InputValidationLengthConstraint;
        pub OpeningHumanReadableText get(opening_human_readble_text) config(): InputValidationLengthConstraint;
        pub CuratorApplicationHumanReadableText get(curator_application_human_readable_text) config(): InputValidationLengthConstraint;
        pub CuratorExitRationaleText get(curator_exit_rationale_text) config(): InputValidationLengthConstraint;
    }
}

decl_event! {
    pub enum Event<T> where
        ChannelId = ChannelId<T>,
        LeadId = LeadId<T>,
        CuratorOpeningId = CuratorOpeningId<T>,
        CuratorApplicationId = CuratorApplicationId<T>,
        CuratorId = CuratorId<T>,
        <T as system::Trait>::AccountId,
    {
        ChannelCreated(ChannelId),
        ChannelOwnershipTransferred(ChannelId),
        LeadSet(LeadId),
        LeadUnset(LeadId),
        CuratorOpeningAdded(CuratorOpeningId),
        //LeadRewardUpdated
        //LeadRoleAccountUpdated
        //LeadRewardAccountUpdated
        //PermissionGroupAdded
        //PermissionGroupUpdated
        AcceptedCuratorApplications(CuratorOpeningId),
        BeganCuratorApplicationReview(CuratorOpeningId),
        CuratorOpeningFilled(CuratorOpeningId, BTreeSet<CuratorApplicationId>),
        //CuratorSlashed
        TerminatedCurator(CuratorId),
        AppliedOnCuratorOpening(CuratorOpeningId, CuratorApplicationId),
        //CuratorRewardUpdated
        //CuratorRoleAccountUpdated
        //CuratorRewardAccountUpdated
        CuratorExited(CuratorId),
        CuratorUnstaking(CuratorId),
        CuratorApplicationTerminated(CuratorApplicationId),
        CuratorApplicationWithdrawn(CuratorApplicationId),
        CuratorRoleAccountUpdated(CuratorId, AccountId),
        CuratorRewardAccountUpdated(CuratorId, AccountId),
        ChannelUpdatedByCurationActor(ChannelId),
    }
}

decl_module! {
    pub struct Module<T: Trait> for enum Call where origin: T::Origin {

        fn deposit_event() = default;

        /*
         * Channel management
         */

        /// Create a new channel.
        pub fn create_channel(origin, owner: T::MemberId, role_account: T::AccountId, channel_name: Vec<u8>, description: Vec<u8>, content: ChannelContentType) {

            // Ensure that it is signed
            let signer_account = ensure_signed(origin)?;

            // Ensure that owner member can authenticate with signer account
            ensure_on_wrapped_error!(
                members::Module::<T>::ensure_is_controller_account_for_member(&owner, &signer_account)
            )?;

            // Ensure it is currently possible to create channels (ChannelCreationEnabled).
            ensure!(
                ChannelCreationEnabled::get(),
                MSG_CHANNEL_CREATION_DISABLED
            );

            // Ensure prospective owner member is currently allowed to become channel owner
            let (member_in_role, next_channel_id) = Self::ensure_can_register_channel_owner_role_on_member(&owner, None)?;

            // Ensure channel name is acceptable length
            Self::ensure_channel_name_is_valid(&channel_name)?;

            // Ensure description is acceptable length
            Self::ensure_channel_description_is_valid(&description)?;

            //
            // == MUTATION SAFE ==
            //

            // Make and add new principal
            let principal_id = Self::add_new_principal(&Principal::ChannelOwner(next_channel_id));

            // Construct channel
            let new_channel = Channel {
                channel_name: channel_name.clone(),
                verified: false,
                description: description,
                content: content,
                owner: owner,
                role_account: role_account,
                publishing_status: ChannelPublishingStatus::NotPublished,
                curation_status: ChannelCurationStatus::Normal,
                created: <system::Module<T>>::block_number(),
                principal_id: principal_id
            };

            // Add channel to ChannelById under id
            ChannelById::<T>::insert(next_channel_id, new_channel);

            // Add id to ChannelIdByName under handle
            ChannelIdByName::<T>::insert(channel_name.clone(), next_channel_id);

            // Increment NextChannelId
            NextChannelId::<T>::mutate(|id| *id += <ChannelId<T> as One>::one());

            /// CREDENTIAL STUFF ///

            // Dial out to membership module and inform about new role as channe owner.
            let registered_role = <members::Module<T>>::register_role_on_member(owner, &member_in_role).is_ok();

            assert!(registered_role);

            // Trigger event
            Self::deposit_event(RawEvent::ChannelCreated(next_channel_id));

        }

        /// An owner transfers channel ownership to a new owner.
        ///
        /// Notice that working group participants cannot do this.
        /// Notice that censored or unpublished channel may still be transferred.
        /// Notice that transfers are unilateral, so new owner cannot block. This may be problematic: https://github.com/Joystream/substrate-runtime-joystream/issues/95
        pub fn transfer_channel_ownership(origin, channel_id: ChannelId<T>, new_owner: T::MemberId, new_role_account: T::AccountId) {

            // Ensure channel owner has signed
            let channel = Self::ensure_channel_owner_signed(origin, &channel_id)?;

            // Ensure prospective new owner can actually become a channel owner
            let (new_owner_as_channel_owner, _next_channel_id) = Self::ensure_can_register_channel_owner_role_on_member(&new_owner, Some(channel_id))?;

            //
            // == MUTATION SAFE ==
            //

            // Construct new channel with altered properties
            let new_channel = Channel {
                owner: new_owner,
                role_account: new_role_account.clone(),
                ..channel
            };

            // Overwrite entry in ChannelById
            ChannelById::<T>::insert(channel_id, new_channel);

            // Remove
            let unregistered_role = <members::Module<T>>::unregister_role(role_types::ActorInRole::new(role_types::Role::ChannelOwner, channel_id)).is_ok();

            assert!(unregistered_role);

            // Dial out to membership module and inform about new role as channe owner.
            let registered_role = <members::Module<T>>::register_role_on_member(
                new_owner,
                &new_owner_as_channel_owner)
                .is_ok();

            assert!(registered_role);

            // Trigger event
            Self::deposit_event(RawEvent::ChannelOwnershipTransferred(channel_id));
        }

        /// Channel owner updates some channel properties
        pub fn update_channel_as_owner(
            origin,
            channel_id: ChannelId<T>,
            new_channel_name: Option<Vec<u8>>,
            new_description: Option<Vec<u8>>,
            new_publishing_status: Option<ChannelPublishingStatus>) {

            // Ensure channel owner has signed
            Self::ensure_channel_owner_signed(origin, &channel_id)?;

            // If set, ensure handle is acceptable length
            if let Some(ref channel_name) = new_channel_name {
                Self::ensure_channel_name_is_valid(channel_name)?;
            }

            // If set, ensure description is acceptable length
            if let Some(ref description) = new_description {
                Self::ensure_channel_description_is_valid(description)?;
            }

            //
            // == MUTATION SAFE ==
            //

            Self::update_channel(
                &channel_id,
                &None,
                &None,
                &new_description,
                &new_publishing_status,
                &None
            );

        }

        /// Update channel as a curation actor
        pub fn update_channel_as_curation_actor(
            origin,
            curation_actor: CurationActor<CuratorId<T>>,
            channel_id: ChannelId<T>,
            new_verified: Option<bool>,
            new_description: Option<Vec<u8>>,
            new_curation_status: Option<ChannelCurationStatus>
            ) {

            // Ensure curation actor signed
            Self::ensure_curation_actor_signed(origin, &curation_actor)?;

            // If set, ensure description is acceptable length
            if let Some(ref description) = new_description {
                Self::ensure_channel_description_is_valid(description)?;
            }

            //
            // == MUTATION SAFE ==
            //


            Self::update_channel(
                &channel_id,
                &None,
                &new_verified,
                &new_description,
                &None,
                &new_curation_status
            );

        }

        /// Add an opening for a curator role.
        pub fn add_curator_opening(origin, activate_at: hiring::ActivateOpeningAt<T::BlockNumber>, commitment: OpeningPolicyCommitment<T::BlockNumber, BalanceOf<T>>, human_readable_text: Vec<u8>)  {

            // Ensure lead is set and is origin signer
            Self::ensure_origin_is_set_lead(origin)?;

            // Ensure human radable text is valid
            Self::ensure_opening_human_readable_text_is_valid(&human_readable_text)?;

            // Add opening
            // NB: This call can in principle fail, because the staking policies
            // may not respect the minimum currency requirement.

            let policy_commitment = commitment.clone();

            let opening_id = ensure_on_wrapped_error!(
                hiring::Module::<T>::add_opening(
                    activate_at,
                    commitment.max_review_period_length,
                    commitment.application_rationing_policy,
                    commitment.application_staking_policy,
                    commitment.role_staking_policy,
                    human_readable_text,
                ))?;

            //
            // == MUTATION SAFE ==
            //

            let new_curator_opening_id = NextCuratorOpeningId::<T>::get();

            // Create and add curator opening.
            let new_opening_by_id = CuratorOpening {
                opening_id : opening_id,
                curator_applications: BTreeSet::new(),
                policy_commitment: policy_commitment
            };

            CuratorOpeningById::<T>::insert(new_curator_opening_id, new_opening_by_id);

            // Update NextCuratorOpeningId
            NextCuratorOpeningId::<T>::mutate(|id| *id += <CuratorOpeningId<T> as One>::one());

            // Trigger event
            Self::deposit_event(RawEvent::CuratorOpeningAdded(new_curator_opening_id));
        }

        /// Begin accepting curator applications to an opening that is active.
        pub fn accept_curator_applications(origin, curator_opening_id: CuratorOpeningId<T>)  {

            // Ensure lead is set and is origin signer
            Self::ensure_origin_is_set_lead(origin)?;

            // Ensure opening exists in this working group
            // NB: Even though call to hiring modul will have implicit check for
            // existence of opening as well, this check is to make sure that the opening is for
            // this working group, not something else.
            let (curator_opening, _opening) = Self::ensure_curator_opening_exists(&curator_opening_id)?;

            // Attempt to begin accepting applicationsa
            // NB: Combined ensure check and mutation in hiring module
            ensure_on_wrapped_error!(
                hiring::Module::<T>::begin_accepting_applications(curator_opening.opening_id)
                )?;

            //
            // == MUTATION SAFE ==
            //

            // Trigger event
            Self::deposit_event(RawEvent::AcceptedCuratorApplications(curator_opening_id));
        }

        /// Begin reviewing, and therefore not accepting new applications.
        pub fn begin_curator_applicant_review(origin, curator_opening_id: CuratorOpeningId<T>) {

            // Ensure lead is set and is origin signer
            let (_lead_id, _lead) = Self::ensure_origin_is_set_lead(origin)?;

            // Ensure opening exists
            // NB: Even though call to hiring modul will have implicit check for
            // existence of opening as well, this check is to make sure that the opening is for
            // this working group, not something else.
            let (curator_opening, _opening) = Self::ensure_curator_opening_exists(&curator_opening_id)?;

            // Attempt to begin review of applications
            // NB: Combined ensure check and mutation in hiring module
            ensure_on_wrapped_error!(
                hiring::Module::<T>::begin_review(curator_opening.opening_id)
                )?;

            //
            // == MUTATION SAFE ==
            //

            // Trigger event
            Self::deposit_event(RawEvent::BeganCuratorApplicationReview(curator_opening_id));
        }

        /// Fill opening for curator
        pub fn fill_curator_opening(
            origin,
            curator_opening_id: CuratorOpeningId<T>,
            successful_curator_application_ids: BTreeSet<CuratorApplicationId<T>>
        ) {
            // Ensure lead is set and is origin signer
            let (lead_id, _lead) = Self::ensure_origin_is_set_lead(origin)?;

            // Ensure curator opening exists
            let (curator_opening, _) = Self::ensure_curator_opening_exists(&curator_opening_id)?;

            // Make iterator over successful curator application
            let successful_iter = successful_curator_application_ids
                                    .iter()
                                    // recover curator application from id
                                    .map(|curator_application_id| { Self::ensure_curator_application_exists(curator_application_id) })
                                    // remove Err cases, i.e. non-existing applications
                                    .filter_map(|result| result.ok());

            // Count number of successful curators provided
            let num_provided_successful_curator_application_ids = successful_curator_application_ids.len();

            // Ensure all curator applications exist
            let number_of_successful_applications = successful_iter
                                                    .clone()
                                                    .collect::<Vec<_>>()
                                                    .len();

            ensure!(
                number_of_successful_applications == num_provided_successful_curator_application_ids,
                MSG_SUCCESSFUL_CURATOR_APPLICATION_DOES_NOT_EXIST
            );

            // Attempt to fill opening
            let successful_application_ids = successful_iter
                                            .clone()
                                            .map(|(successful_curator_application, _, _)| successful_curator_application.application_id)
                                            .collect::<BTreeSet<_>>();

            // Ensure all applications are from members that _still_ can step into the given role
            let num_successful_applications_that_can_register_as_curator = successful_iter
                                                                        .clone()
                                                                        .map(|(successful_curator_application, _, _)| successful_curator_application.member_id)
                                                                        .filter_map(|successful_member_id| Self::ensure_can_register_curator_role_on_member(&successful_member_id).ok() )
                                                                        .collect::<Vec<_>>().len();

            ensure!(
                num_successful_applications_that_can_register_as_curator == num_provided_successful_curator_application_ids,
                MSG_MEMBER_NO_LONGER_REGISTRABLE_AS_CURATOR
            );

            // NB: Combined ensure check and mutation in hiring module
            ensure_on_wrapped_error!(
                hiring::Module::<T>::fill_opening(
                    curator_opening.opening_id,
                    successful_application_ids,
                    curator_opening.policy_commitment.fill_opening_successful_applicant_application_stake_unstaking_period,
                    curator_opening.policy_commitment.fill_opening_failed_applicant_application_stake_unstaking_period,
                    curator_opening.policy_commitment.fill_opening_failed_applicant_role_stake_unstaking_period
                )
            )?;

            //
            // == MUTATION SAFE ==
            //

            let current_block = <system::Module<T>>::block_number();

            // For each successful application
            // - create and hold on to curator
            // - register role with membership module

            successful_iter
            .clone()
            .for_each(|(successful_curator_application, id, _)| {

                // No reward is established by default
                let reward_relationship: Option<RewardRelationshipId<T>> = None;

                // Get possible stake for role
                let application = hiring::ApplicationById::<T>::get(successful_curator_application.application_id);

                // Staking profile for curator
                let stake_profile =
                    if let Some(ref stake_id) = application.active_role_staking_id {

                        Some(
                            CuratorRoleStakeProfile::new(
                                stake_id,
                                &curator_opening.policy_commitment.terminate_curator_role_stake_unstaking_period,
                                &curator_opening.policy_commitment.exit_curator_role_stake_unstaking_period
                            )
                        )
                    } else {
                        None
                    };

                // Get curator id
                let new_curator_id = NextCuratorId::<T>::get();

                // Make and add new principal
                let principal_id = Self::add_new_principal(&Principal::Curator(new_curator_id));

                // Construct curator
                let curator = Curator::new(
                    &(successful_curator_application.role_account),
                    &reward_relationship,
                    &stake_profile,
                    &CuratorRoleStage::Active,
                    &CuratorInduction::new(&lead_id, &id, &current_block),
                    //false,
                    &principal_id
                );

                // Store curator
                CuratorById::<T>::insert(new_curator_id, curator);

                // Register role on member
                let registered_role = members::Module::<T>::register_role_on_member(
                    successful_curator_application.member_id,
                    &role_types::ActorInRole::new(role_types::Role::Curator, new_curator_id)
                ).is_ok();

                assert!(registered_role);

                // Update next curator id
                NextCuratorId::<T>::mutate(|id| *id += <CuratorId<T> as One>::one());
            });

            // Trigger event
            Self::deposit_event(RawEvent::CuratorOpeningFilled(curator_opening_id, successful_curator_application_ids));

        }

        /*
        /// ...
        pub fn update_curator_reward(_origin) {

        }
        */

        /*
        /// ...
        pub fn slash_curator(_origin) {

        }
        */

        pub fn withdraw_curator_application(
            origin,
            curator_application_id: CuratorApplicationId<T>
        ) {
            // Ensuring curator application actually exists
            let (curator_application, _, curator_opening) = Self::ensure_curator_application_exists(&curator_application_id)?;

            // Ensure that it is signed
            let signer_account = ensure_signed(origin)?;

            // Ensure that signer is applicant role account
            ensure!(
                signer_account == curator_application.role_account,
                MSG_ORIGIN_IS_NOT_APPLICANT
            );

            // Attempt to deactivate application
            // NB: Combined ensure check and mutation in hiring module
            ensure_on_wrapped_error!(
                hiring::Module::<T>::deactive_application(
                    curator_application.application_id,
                    curator_opening.policy_commitment.exit_curator_role_application_stake_unstaking_period,
                    curator_opening.policy_commitment.exit_curator_role_stake_unstaking_period
                )
            )?;

            //
            // == MUTATION SAFE ==
            //

            // Trigger event
            Self::deposit_event(RawEvent::CuratorApplicationWithdrawn(curator_application_id));

        }

        /// Lead terminate curator application
        pub fn terminate_curator_application(
            origin,
            curator_application_id: CuratorApplicationId<T>
            ) {

            // Ensure lead is set and is origin signer
            Self::ensure_origin_is_set_lead(origin)?;

            // Ensuring curator application actually exists
            let (curator_application, _, curator_opening) = Self::ensure_curator_application_exists(&curator_application_id)?;

            // Attempt to deactivate application
            // NB: Combined ensure check and mutation in hiring module
            ensure_on_wrapped_error!(
                hiring::Module::<T>::deactive_application(
                    curator_application.application_id,
                    curator_opening.policy_commitment.terminate_curator_application_stake_unstaking_period,
                    curator_opening.policy_commitment.terminate_curator_role_stake_unstaking_period
                )
            )?;

            //
            // == MUTATION SAFE ==
            //

            // Trigger event
            Self::deposit_event(RawEvent::CuratorApplicationTerminated(curator_application_id));
        }

        /// Apply on a curator opening.
        pub fn apply_on_curator_opening(
            origin,
            member_id: T::MemberId,
            curator_opening_id: CuratorOpeningId<T>,
            role_account: T::AccountId,
            source_account: T::AccountId,
            opt_role_stake_balance: Option<BalanceOf<T>>,
            opt_application_stake_balance: Option<BalanceOf<T>>,
            human_readable_text: Vec<u8>
        ) {
            // Ensure that origin is signed by member with given id.
            ensure_on_wrapped_error!(
                members::Module::<T>::ensure_member_controller_account_signed(origin, &member_id)
            )?;

            // Ensure curator opening exists
            let (curator_opening, _opening) = Self::ensure_curator_opening_exists(&curator_opening_id)?;

            // Ensure new owner can actually become a curator
            let (_member_as_curator, _new_curator_id) = Self::ensure_can_register_curator_role_on_member(&member_id)?;

            // Ensure that there is sufficient balance to cover stake proposed
            Self::ensure_can_make_stake_imbalance(
                vec![&opt_role_stake_balance, &opt_application_stake_balance],
                &source_account)
                .map_err(|_err| MSG_INSUFFICIENT_BALANCE_TO_APPLY)?;

            // Ensure application text is valid
            Self::ensure_curator_application_text_is_valid(&human_readable_text)?;

            // Ensure application can actually be added
            ensure_on_wrapped_error!(
                hiring::Module::<T>::ensure_can_add_application(curator_opening.opening_id, opt_role_stake_balance, opt_application_stake_balance)
            )?;

            //
            // == MUTATION SAFE ==
            //

            // Make imbalances for staking
            let opt_role_stake_imbalance = Self::make_stake_opt_imbalance(&opt_role_stake_balance, &source_account);
            let opt_application_stake_imbalance = Self::make_stake_opt_imbalance(&opt_application_stake_balance, &source_account);

            // Call hiring module to add application
            let add_application_result = hiring::Module::<T>::add_application(
                curator_opening.opening_id,
                opt_role_stake_imbalance,
                opt_application_stake_imbalance,
                human_readable_text
            );

            // Has to hold
            assert!(add_application_result.is_ok());

            let application_id = add_application_result.unwrap().application_id_added;

            // Get id of new curator application
            let new_curator_application_id = NextCuratorApplicationId::<T>::get();

            // Make curator application
            let curator_application = CuratorApplication::new(&role_account, &curator_opening_id, &member_id, &application_id);

            // Store application
            CuratorApplicationById::<T>::insert(new_curator_application_id, curator_application);

            // Update next curator application identifier value
            NextCuratorApplicationId::<T>::mutate(|id| *id += <CuratorApplicationId<T> as One>::one());

            // Add application to set of application in curator opening
            CuratorOpeningById::<T>::mutate(curator_opening_id, |curator_opening| {
                curator_opening.curator_applications.insert(new_curator_application_id);
            });

            // Trigger event
            Self::deposit_event(RawEvent::AppliedOnCuratorOpening(curator_opening_id, new_curator_application_id));
        }

        /// An active curator can update the associated role account.
        pub fn update_curator_role_account(
            origin,
            member_id: T::MemberId,
            curator_id: CuratorId<T>,
            new_role_account: T::AccountId
        ) {
            // Ensure that origin is signed by member with given id.
            ensure_on_wrapped_error!(
                members::Module::<T>::ensure_member_controller_account_signed(origin, &member_id)
            )?;

            // Ensure that member is this curator
            let actor_in_role = role_types::ActorInRole::new(role_types::Role::Curator, curator_id);

            ensure!(
                members::MembershipIdByActorInRole::<T>::get(actor_in_role) == member_id,
                MSG_CURATOR_NOT_CONTROLLED_BY_MEMBER
            );

            //
            // == MUTATION SAFE ==
            //

            // Update role account
            CuratorById::<T>::mutate(curator_id, |curator| {
                curator.role_account = new_role_account.clone()
            });

            // Trigger event
            Self::deposit_event(RawEvent::CuratorRoleAccountUpdated(curator_id, new_role_account));
        }

        /// An active curator can update the reward account associated
        /// with a set reward relationship.
        pub fn update_curator_reward_account(
            origin,
            curator_id: CuratorId<T>,
            new_reward_account: T::AccountId
        ) {

            // Ensure there is a signer which matches role account of curator corresponding to provided id.
            let curator = Self::ensure_active_curator_signed(origin, &curator_id)?;

            // Ensure the curator actually has a recurring reward
            let relationship_id = Self::ensure_curator_has_recurring_reward(&curator)?;

            //
            // == MUTATION SAFE ==
            //

            // Update, only, reward account.
            recurringrewards::Module::<T>::set_reward_relationship(
                relationship_id,
                Some(new_reward_account.clone()), // new_account
                None, // new_payout
                None, //new_next_payment_at
                None //new_payout_interval
            )
            .expect("Must be set, since curator has recurring reward");

            // Trigger event
            Self::deposit_event(RawEvent::CuratorRewardAccountUpdated(curator_id, new_reward_account));
        }

        /// An active curator leaves role
        pub fn leave_curator_role(
            origin,
            curator_id: CuratorId<T>,
            rationale_text: Vec<u8>
        ) {
            // Ensure there is a signer which matches role account of curator corresponding to provided id.
            let active_curator = Self::ensure_active_curator_signed(origin, &curator_id)?;

            //
            // == MUTATION SAFE ==
            //

            Self::deactivate_curator(
                &curator_id,
                &active_curator,
                &CuratorExitInitiationOrigin::Curator,
                &rationale_text
            );
        }

        /// Lead can terminate and active curator
        pub fn terminate_curator_role(
            origin,
            curator_id: CuratorId<T>,
            rationale_text: Vec<u8>
            ) {

            // Ensure lead is set and is origin signer
            Self::ensure_origin_is_set_lead(origin)?;

            // Ensuring curator actually exists and is active
            let curator = Self::ensure_active_curator_exists(&curator_id)?;

            // Ensure rationale text is valid
            Self::ensure_curator_exit_rationale_text_is_valid(&rationale_text)?;

            //
            // == MUTATION SAFE ==
            //

            Self::deactivate_curator(
                &curator_id,
                &curator,
                &CuratorExitInitiationOrigin::Lead,
                &rationale_text
            );
        }

        /*
         * Root origin routines for managing lead.
         */


        /// Introduce a lead when one is not currently set.
        pub fn set_lead(origin, member: T::MemberId, role_account: T::AccountId) {

            // Ensure root is origin
            ensure_root(origin)?;

            // Ensure there is no current lead
            ensure!(
                <CurrentLeadId<T>>::get().is_none(),
                MSG_CURRENT_LEAD_ALREADY_SET
            );

            // Ensure that member can actually become lead
            let new_lead_id = <NextLeadId<T>>::get();

            let _profile = <members::Module<T>>::can_register_role_on_member(
                &member,
                &role_types::ActorInRole::new(role_types::Role::CuratorLead, new_lead_id)
            )?;

            //
            // == MUTATION SAFE ==
            //

            // Construct lead
            let new_lead = Lead{
                role_account: role_account.clone(),
                reward_relationship: None,
                inducted: <system::Module<T>>::block_number(),
                stage: LeadRoleState::Active
            };

            // Store lead
            <LeadById<T>>::insert(new_lead_id, new_lead);

            // Update current lead
            <CurrentLeadId<T>>::put(new_lead_id); // Some(new_lead_id)

            // Update next lead counter
            <NextLeadId<T>>::mutate(|id| *id += <LeadId<T> as One>::one());

            // Trigger event
            Self::deposit_event(RawEvent::LeadSet(new_lead_id));
        }

        /// Evict the currently unset lead
        pub fn unset_lead(origin) {

            // Ensure root is origin
            ensure_root(origin)?;

            // Ensure there is a lead set
            let (lead_id,lead) = Self::ensure_lead_is_set()?;

            //
            // == MUTATION SAFE ==
            //

            // Unregister from role in membership model
            let current_lead_role = role_types::ActorInRole{
                role: role_types::Role::CuratorLead,
                actor_id: lead_id
            };

            let unregistered_role = <members::Module<T>>::unregister_role(current_lead_role).is_ok();

            assert!(unregistered_role);

            // Update lead stage as exited
            let current_block = <system::Module<T>>::block_number();

            let new_lead = Lead{
                stage: LeadRoleState::Exited(ExitedLeadRole { initiated_at_block_number: current_block}),
                ..lead
            };

            <LeadById<T>>::insert(lead_id, new_lead);

            // Update current lead
            <CurrentLeadId<T>>::take(); // None

            // Trigger event
            Self::deposit_event(RawEvent::LeadUnset(lead_id));
        }

        /// The stake, with the given id, was unstaked.
        pub fn unstaked(
            origin,
            stake_id: StakeId<T>
        ) {
            // Ensure its a runtime root origin
            ensure_root(origin)?;

            // Ensure its an unstaker in this group
            let unstaker = Self::ensure_unstaker_exists(&stake_id)?;

            // Get curator doing the unstaking,
            // urrently the only possible unstaker in this module.
            let curator_id =
                if let WorkingGroupUnstaker::Curator(curator_id) = unstaker {
                    curator_id
                } else {
                    panic!("Should not be possible, only curators unstake in this module currently.");
                };

            // Grab curator from id, unwrap, because this curator _must_ exist.
            let unstaking_curator = Self::ensure_curator_exists(&curator_id).unwrap();

            //
            // == MUTATION SAFE ==
            //

            // Update stage of curator
            let curator_exit_summary =
                if let CuratorRoleStage::Unstaking(summary) = unstaking_curator.stage {
                    summary
                } else {
                    panic!("Curator must be in unstaking stage.");
                };

            let new_curator = Curator{
                stage: CuratorRoleStage::Exited(curator_exit_summary.clone()),
                ..unstaking_curator
            };

            CuratorById::<T>::insert(curator_id, new_curator);

            // Remove from unstaker
            UnstakerByStakeId::<T>::remove(stake_id);

            // Trigger event
            let event = match curator_exit_summary.origin {
                CuratorExitInitiationOrigin::Lead => RawEvent::TerminatedCurator(curator_id),
                CuratorExitInitiationOrigin::Curator => RawEvent::CuratorExited(curator_id),
            };

            Self::deposit_event(event);
        }

    }
}

impl<T: Trait> versioned_store_permissions::CredentialChecker<T> for Module<T> {
    fn account_has_credential(account: &T::AccountId, id: PrincipalId<T>) -> bool {
        // Check that principal exists
        if !PrincipalById::<T>::exists(&id) {
            return false;
        }

        // Get principal
        let principal = PrincipalById::<T>::get(&id);

        // Get possible
        let opt_prinicipal_account = match principal {
            Principal::Lead => {
                // Try to get lead
                match Self::ensure_lead_is_set() {
                    Ok((_, lead)) => Some(lead.role_account),
                    Err(_) => None,
                }
            }

            Principal::Curator(curator_id) => Some(
                Self::ensure_curator_exists(&curator_id)
                    .expect("Curator must exist")
                    .role_account,
            ),

            Principal::ChannelOwner(channel_id) => Some(
                Self::ensure_channel_id_is_valid(&channel_id)
                    .expect("Channel must exist")
                    .role_account,
            ),
        };

        // Compare, possibly set, principal account with the given account
        match opt_prinicipal_account {
            Some(principal_account) => *account == principal_account,
            None => false,
        }
    }
}

impl<T: Trait> Module<T> {
    fn ensure_can_register_role_on_member(
        member_id: &T::MemberId,
        role: role_types::Role,
        actor_id: &ActorIdInMembersModule<T>,
    ) -> Result<members::ActorInRole<ActorIdInMembersModule<T>>, &'static str> {
        let new_actor_in_role = role_types::ActorInRole::new(role, *actor_id);

        <members::Module<T>>::can_register_role_on_member(member_id, &new_actor_in_role)
            .map(|_| new_actor_in_role)
    }

    fn ensure_can_register_curator_role_on_member(
        member_id: &T::MemberId,
    ) -> Result<
        (
            members::ActorInRole<ActorIdInMembersModule<T>>,
            CuratorId<T>,
        ),
        &'static str,
    > {
        let next_id = <NextCuratorId<T>>::get();

        Self::ensure_can_register_role_on_member(member_id, role_types::Role::Curator, &next_id)
            .map(|curator_in_role| (curator_in_role, next_id))
    }

    fn ensure_can_register_channel_owner_role_on_member(
        member_id: &T::MemberId,
        opt_channel_id: Option<ChannelId<T>>,
    ) -> Result<
        (
            members::ActorInRole<ActorIdInMembersModule<T>>,
            CuratorId<T>,
        ),
        &'static str,
    > {
        let next_channel_id = opt_channel_id.unwrap_or(NextChannelId::<T>::get());

        Self::ensure_can_register_role_on_member(
            member_id,
            role_types::Role::ChannelOwner,
            &next_channel_id,
        )
        .map(|member_in_role| (member_in_role, next_channel_id))
    }

    // TODO: convert InputConstraint ensurer routines into macroes

    fn ensure_channel_name_is_valid(channel_name: &Vec<u8>) -> dispatch::Result {
        ChannelHandleConstraint::get().ensure_valid(
            channel_name.len(),
            MSG_CHANNEL_HANDLE_TOO_SHORT,
            MSG_CHANNEL_HANDLE_TOO_LONG,
        )?;

        // Has to not already be occupied
        ensure!(
            ChannelIdByName::<T>::exists(channel_name),
            MSG_CHANNEL_NAME_ALREADY_TAKEN
        );

        Ok(())
    }

    fn ensure_channel_description_is_valid(description: &Vec<u8>) -> dispatch::Result {
        ChannelDescriptionConstraint::get().ensure_valid(
            description.len(),
            MSG_CHANNEL_DESCRIPTION_TOO_SHORT,
            MSG_CHANNEL_DESCRIPTION_TOO_LONG,
        )
    }

    fn ensure_curator_application_text_is_valid(text: &Vec<u8>) -> dispatch::Result {
        CuratorApplicationHumanReadableText::get().ensure_valid(
            text.len(),
            MSG_CURATOR_APPLICATION_TEXT_TOO_SHORT,
            MSG_CURATOR_APPLICATION_TEXT_TOO_LONG,
        )
    }

    fn ensure_curator_exit_rationale_text_is_valid(text: &Vec<u8>) -> dispatch::Result {
        CuratorExitRationaleText::get().ensure_valid(
            text.len(),
            MSG_CURATOR_EXIT_RATIOANEL_TEXT_TOO_SHORT,
            MSG_CURATOR_EXIT_RATIOANEL_TEXT_TOO_LONG,
        )
    }

    fn ensure_opening_human_readable_text_is_valid(text: &Vec<u8>) -> dispatch::Result {
        OpeningHumanReadableText::get().ensure_valid(
            text.len(),
            MSG_CHANNEL_DESCRIPTION_TOO_SHORT,
            MSG_CHANNEL_DESCRIPTION_TOO_LONG,
        )
    }

    fn ensure_channel_id_is_valid(
        channel_id: &ChannelId<T>,
    ) -> Result<Channel<T::MemberId, T::AccountId, T::BlockNumber, PrincipalId<T>>, &'static str>
    {
        if ChannelById::<T>::exists(channel_id) {
            let channel = ChannelById::<T>::get(channel_id);

            Ok(channel)
        } else {
            Err(MSG_CHANNEL_ID_INVALID)
        }
    }

    fn ensure_lead_is_set() -> Result<
        (
            LeadId<T>,
            Lead<T::AccountId, T::RewardRelationshipId, T::BlockNumber>,
        ),
        &'static str,
    > {
        // Ensure lead id is set
        let lead_id = Self::ensure_lead_id_set()?;

        // If so, grab actual lead
        let lead = <LeadById<T>>::get(lead_id);

        // and return both
        Ok((lead_id, lead))
    }

    fn ensure_lead_id_set() -> Result<LeadId<T>, &'static str> {
        let opt_current_lead_id = <CurrentLeadId<T>>::get();

        if let Some(lead_id) = opt_current_lead_id {
            Ok(lead_id)
        } else {
            Err(MSG_CURRENT_LEAD_NOT_SET)
        }
    }

    fn ensure_origin_is_set_lead(
        origin: T::Origin,
    ) -> Result<
        (
            LeadId<T>,
            Lead<T::AccountId, T::RewardRelationshipId, T::BlockNumber>,
        ),
        &'static str,
    > {
        // Ensure lead is actually set
        let (lead_id, lead) = Self::ensure_lead_is_set()?;

        // Ensure is signed
        let signer = ensure_signed(origin)?;

        // Ensure signer is lead
        ensure!(signer == lead.role_account, MSG_ORIGIN_IS_NOT_LEAD);

        Ok((lead_id, lead))
    }
    /*
        fn ensure_activate_opening_at_valid(activate_at: &hiring::ActivateOpeningAt<T::BlockNumber>) -> Result<T::BlockNumber, &'static str>{

            let current_block = <system::Module<T>>::block_number();

            let starting_block =
                match activate_at {
                    hiring::ActivateOpeningAt::CurrentBlock => current_block,
                    hiring::ActivateOpeningAt::ExactBlock(block_number) => block_number.clone()
            };

            ensure!(
                starting_block >= current_block,
                MSG_OPENING_CANNOT_ACTIVATE_IN_THE_PAST
            );

            Ok(starting_block)
        }
    */
    fn ensure_curator_opening_exists(
        curator_opening_id: &CuratorOpeningId<T>,
    ) -> Result<
        (
            CuratorOpening<T::OpeningId, T::BlockNumber, BalanceOf<T>, CuratorApplicationId<T>>,
            hiring::Opening<BalanceOf<T>, T::BlockNumber, <T as hiring::Trait>::ApplicationId>,
        ),
        &'static str,
    > {
        ensure!(
            CuratorOpeningById::<T>::exists(curator_opening_id),
            MSG_CURATOR_OPENING_DOES_NOT_EXIST
        );

        let curator_opening = CuratorOpeningById::<T>::get(curator_opening_id);

        let opening = hiring::OpeningById::<T>::get(curator_opening.opening_id);

        Ok((curator_opening, opening))
    }

    fn ensure_curator_exists(
        curator_id: &CuratorId<T>,
    ) -> Result<
        Curator<
            T::AccountId,
            T::RewardRelationshipId,
            T::StakeId,
            T::BlockNumber,
            LeadId<T>,
            T::ApplicationId,
            PrincipalId<T>,
        >,
        &'static str,
    > {
        ensure!(
            CuratorById::<T>::exists(curator_id),
            MSG_CURATOR_DOES_NOT_EXIST
        );

        let curator = CuratorById::<T>::get(curator_id);

        Ok(curator)
    }

    fn ensure_unstaker_exists(
        stake_id: &StakeId<T>,
    ) -> Result<WorkingGroupUnstaker<LeadId<T>, CuratorId<T>>, &'static str> {
        ensure!(
            UnstakerByStakeId::<T>::exists(stake_id),
            MSG_UNSTAKER_DOES_NOT_EXIST
        );

        let unstaker = UnstakerByStakeId::<T>::get(stake_id);

        Ok(unstaker)
    }

    fn ensure_active_curator_exists(
        curator_id: &CuratorId<T>,
    ) -> Result<
        Curator<
            T::AccountId,
            T::RewardRelationshipId,
            T::StakeId,
            T::BlockNumber,
            LeadId<T>,
            T::ApplicationId,
            PrincipalId<T>,
        >,
        &'static str,
    > {
        // Ensuring curator actually exists
        let curator = Self::ensure_curator_exists(curator_id)?;

        // Ensure curator is still active
        ensure!(
            match curator.stage {
                CuratorRoleStage::Active => true,
                _ => false,
            },
            MSG_CURATOR_IS_NOT_ACTIVE
        );

        Ok(curator)
    }

    fn ensure_active_curator_signed(
        origin: T::Origin,
        curator_id: &CuratorId<T>,
    ) -> Result<
        Curator<
            T::AccountId,
            T::RewardRelationshipId,
            T::StakeId,
            T::BlockNumber,
            LeadId<T>,
            T::ApplicationId,
            PrincipalId<T>,
        >,
        &'static str,
    > {
        // Ensure that it is signed
        let signer_account = ensure_signed(origin)?;

        // Ensure that id corresponds to active curator
        let curator = Self::ensure_active_curator_exists(&curator_id)?;

        // Ensure that signer is actually role account of curator
        ensure!(
            signer_account == curator.role_account,
            MSG_SIGNER_IS_NOT_CURATOR_ROLE_ACCOUNT
        );

        Ok(curator)
    }

    fn ensure_curation_actor_signed(
        origin: T::Origin,
        curation_actor: &CurationActor<CuratorId<T>>,
    ) -> Result<(), &'static str> {
        match curation_actor {
            CurationActor::Lead => {
                // Ensure lead is set and is origin signer
                Self::ensure_origin_is_set_lead(origin).map(|_| ())
            }
            CurationActor::Curator(curator_id) => {
                // Ensure there is a signer which matches role account of curator corresponding to provided id.
                Self::ensure_active_curator_signed(origin, &curator_id).map(|_| ())
            }
        }
    }

    /// Ensure origin is signed by account matching role account corresponding to the channel
    fn ensure_channel_owner_signed(
        origin: T::Origin,
        channel_id: &ChannelId<T>,
    ) -> Result<Channel<T::MemberId, T::AccountId, T::BlockNumber, PrincipalId<T>>, &'static str>
    {
        // Ensure that it is signed
        let signer_account = ensure_signed(origin)?;

        // Ensure channel id is valid
        let channel = Self::ensure_channel_id_is_valid(&channel_id)?;

        // Ensure origin matches channel role account
        ensure!(
            signer_account == channel.role_account,
            MSG_ORIGIN_DOES_NOT_MATCH_CHANNEL_ROLE_ACCOUNT
        );

        Ok(channel)
    }

    fn ensure_curator_application_exists(
        curator_application_id: &CuratorApplicationId<T>,
    ) -> Result<
        (
            CuratorApplication<T::AccountId, CuratorOpeningId<T>, T::MemberId, T::ApplicationId>,
            CuratorApplicationId<T>,
            CuratorOpening<T::OpeningId, T::BlockNumber, BalanceOf<T>, CuratorApplicationId<T>>,
        ),
        &'static str,
    > {
        //Result<(hiring::Application<<T as hiring::Trait>::OpeningId, T::BlockNumber, <T as stake::Trait>::StakeId>, CuratorOpening<T::OpeningId, T::BlockNumber, BalanceOf<T>, CuratorApplicationId<T>> ,hiring::Opening<BalanceOf<T>, T::BlockNumber, <T as hiring::Trait>::ApplicationId>), &'static str> {

        ensure!(
            CuratorApplicationById::<T>::exists(curator_application_id),
            MSG_CURATOR_APPLICATION_DOES_NOT_EXIST
        );

        let curator_application = CuratorApplicationById::<T>::get(curator_application_id);

        //let application = hiring::ApplicationById::<T>::get(curator_application.application_id);

        let curator_opening = CuratorOpeningById::<T>::get(curator_application.curator_opening_id);

        //let opening = hiring::OpeningById::<T>::get(curator_opening.opening_id);

        Ok((
            curator_application,
            curator_application_id.clone(),
            curator_opening,
        ))
    }

    fn ensure_curator_has_recurring_reward(
        curator: &Curator<
            T::AccountId,
            T::RewardRelationshipId,
            T::StakeId,
            T::BlockNumber,
            LeadId<T>,
            T::ApplicationId,
            PrincipalId<T>,
        >,
    ) -> Result<T::RewardRelationshipId, &'static str> {
        ensure!(
            curator.reward_relationship.is_some(),
            MSG_CURATOR_HAS_NO_REWARD
        );

        let relationship_id = curator.reward_relationship.unwrap();

        Ok(relationship_id)
    }

    /// CRITICAL:
    /// https://github.com/Joystream/substrate-runtime-joystream/issues/92
    /// This assumes that ensure_can_withdraw can be don
    /// for a sum of balance that later will be actually withdrawn
    /// using individual terms in that sum.
    /// This needs to be fully checked across all possibly scenarios
    /// of actual balance, minimum balance limit, reservation, vesting and locking.
    fn ensure_can_make_stake_imbalance(
        opt_balances: Vec<&Option<BalanceOf<T>>>,
        source_account: &T::AccountId,
    ) -> Result<(), &'static str> {
        let zero_balance = <BalanceOf<T> as Zero>::zero();

        // Total amount to be staked
        let total_amount = opt_balances.iter().fold(zero_balance, |sum, opt_balance| {
            sum + if let Some(balance) = opt_balance {
                *balance
            } else {
                zero_balance
            }
        });

        if total_amount > zero_balance {
            let new_balance = CurrencyOf::<T>::free_balance(source_account) - total_amount;

            CurrencyOf::<T>::ensure_can_withdraw(
                source_account,
                total_amount,
                WithdrawReasons::all(),
                new_balance,
            )
        } else {
            Ok(())
        }
    }

    fn make_stake_opt_imbalance(
        opt_balance: &Option<BalanceOf<T>>,
        source_account: &T::AccountId,
    ) -> Option<NegativeImbalance<T>> {
        if let Some(balance) = opt_balance {
            let withdraw_result = CurrencyOf::<T>::withdraw(
                source_account,
                *balance,
                WithdrawReasons::all(),
                ExistenceRequirement::AllowDeath,
            );

            assert!(withdraw_result.is_ok());

            withdraw_result.ok()
        } else {
            None
        }
    }

    fn deactivate_curator(
        curator_id: &CuratorId<T>,
        curator: &Curator<
            T::AccountId,
            T::RewardRelationshipId,
            T::StakeId,
            T::BlockNumber,
            LeadId<T>,
            CuratorApplicationId<T>,
            PrincipalId<T>,
        >,
        exit_initiation_origin: &CuratorExitInitiationOrigin,
        rationale_text: &Vec<u8>,
    ) {
        // Stop any possible recurring rewards
        let _did_deactivate_recurring_reward = if let Some(ref reward_relationship_id) =
            curator.reward_relationship
        {
            // Attempt to deactivate
            recurringrewards::Module::<T>::try_to_deactivate_relationship(*reward_relationship_id)
                .expect("Relatioship must exist")
        } else {
            // Did not deactivate, there was no reward relationship!
            false
        };

        // When the curator is staked, unstaking must first be initated,
        // otherwise they can be terminted right away.

        // Create exit summary for this termination
        let current_block = <system::Module<T>>::block_number();

        let curator_exit_summary =
            CuratorExitSummary::new(exit_initiation_origin, &current_block, rationale_text);

        // Determine new curator stage and event to emit
        let (new_curator_stage, unstake_directions, event) =
            if let Some(ref stake_profile) = curator.role_stake_profile {
                // Determine unstaknig period based on who initiated deactivation
                let unstaking_period = match curator_exit_summary.origin {
                    CuratorExitInitiationOrigin::Lead => stake_profile.termination_unstaking_period,
                    CuratorExitInitiationOrigin::Curator => stake_profile.exit_unstaking_period,
                };

                (
                    CuratorRoleStage::Unstaking(curator_exit_summary),
                    Some((stake_profile.stake_id.clone(), unstaking_period)),
                    RawEvent::CuratorUnstaking(curator_id.clone()),
                )
            } else {
                (
                    CuratorRoleStage::Exited(curator_exit_summary.clone()),
                    None,
                    match curator_exit_summary.origin {
                        CuratorExitInitiationOrigin::Lead => {
                            RawEvent::TerminatedCurator(curator_id.clone())
                        }
                        CuratorExitInitiationOrigin::Curator => {
                            RawEvent::CuratorExited(curator_id.clone())
                        }
                    },
                )
            };

        // Update curator
        let new_curator = Curator {
            stage: new_curator_stage,
            ..(curator.clone())
        };

        CuratorById::<T>::insert(curator_id, new_curator);

        // Unstake if directions provided
        if let Some(directions) = unstake_directions {
            // Unstake
            stake::Module::<T>::initiate_unstaking(&directions.0, directions.1)
                .expect("Unstaking must be possible at this time.");
        }

        // Trigger event
        Self::deposit_event(event);
    }

    /// Adds the given principal to storage under the returned identifier.
    fn add_new_principal(principal: &Principal<CuratorId<T>, ChannelId<T>>) -> PrincipalId<T> {
        // Get principal id for curator
        let principal_id = NextPrincipalId::<T>::get();

        // Update next principal id value
        NextPrincipalId::<T>::mutate(|id| *id += PrincipalId::<T>::one());

        // Store principal
        PrincipalById::<T>::insert(principal_id, principal);

        // Return id
        principal_id
    }

    fn update_channel(
        channel_id: &ChannelId<T>,
        new_channel_name: &Option<Vec<u8>>,
        new_verified: &Option<bool>,
        new_descriptin: &Option<Vec<u8>>,
        new_publishing_status: &Option<ChannelPublishingStatus>,
        new_curation_status: &Option<ChannelCurationStatus>,
    ) {
        // Update name to channel mapping if there is a new name mapping
        if let Some(ref channel_name) = new_channel_name {

            // Remove mapping under old name
            let current_channel_name = ChannelById::<T>::get(channel_id).channel_name;

            ChannelIdByName::<T>::remove(current_channel_name);

            // Establish mapping under new name
            ChannelIdByName::<T>::insert(channel_name.clone(), channel_id);
        }

        // Update channel
        ChannelById::<T>::mutate(channel_id, |channel| {
            if let Some(ref channel_name) = new_channel_name {
                channel.channel_name = channel_name.clone();
            }

            if let Some(ref verified) = new_verified {
                channel.verified = *verified;
            }

            if let Some(ref description) = new_descriptin {
                channel.description = description.clone();
            }

            if let Some(ref publishing_status) = new_publishing_status {
                channel.publishing_status = publishing_status.clone();
            }

            if let Some(ref curation_status) = new_curation_status {
                channel.curation_status = *curation_status;
            }
        });

        // Trigger event
        Self::deposit_event(RawEvent::ChannelUpdatedByCurationActor(*channel_id));
    }
}