added 3 instances of OperationsWorkingGroup

runtime-modules/common/src/working_group.rs

@@ -17,7 +17,11 @@ pub enum WorkingGroup {
     /// Storage working group: working_group::Instance3.
     Content,
     /// Operations working group: working_group::Instance4.
-    Operations,
+    Operations1,
+    /// Operations working group: working_group::Instance6.
+    Operations2,
+    /// Operations working group: working_group::Instance7.
+    Operations3,
     /// Gateway working group: working_group::Instance5.
     Gateway,
 }

runtime/src/integration/proposals/proposal_encoder.rs

@@ -22,7 +22,15 @@ macro_rules! wrap_working_group_call {
                 Call::ContentDirectoryWorkingGroup($working_group_instance_call)
             }
             WorkingGroup::Storage => Call::StorageWorkingGroup($working_group_instance_call),
-            WorkingGroup::Operations => Call::OperationsWorkingGroup($working_group_instance_call),
+            WorkingGroup::Operations1 => {
+                Call::OperationsWorkingGroup1($working_group_instance_call)
+            }
+            WorkingGroup::Operations2 => {
+                Call::OperationsWorkingGroup2($working_group_instance_call)
+            }
+            WorkingGroup::Operations3 => {
+                Call::OperationsWorkingGroup3($working_group_instance_call)
+            }
             WorkingGroup::Gateway => Call::GatewayWorkingGroup($working_group_instance_call),
         }
     }};

runtime/src/integration/working_group.rs

@@ -3,7 +3,8 @@ use sp_std::marker::PhantomData;
 
 use crate::{
     ContentDirectoryWorkingGroupInstance, GatewayWorkingGroupInstance,
-    OperationsWorkingGroupInstance, StorageWorkingGroupInstance,
+    OperationsWorkingGroupInstance1, OperationsWorkingGroupInstance2,
+    OperationsWorkingGroupInstance3, StorageWorkingGroupInstance,
 };
 use stake::{BalanceOf, NegativeImbalance};
 
@@ -97,12 +98,12 @@ impl<T: stake::Trait + working_group::Trait<StorageWorkingGroupInstance>>
     }
 }
 
-pub struct OperationsWgStakingEventsHandler<T> {
+pub struct OperationsWgStakingEventsHandler1<T> {
     pub marker: PhantomData<T>,
 }
 
-impl<T: stake::Trait + working_group::Trait<OperationsWorkingGroupInstance>>
-    stake::StakingEventsHandler<T> for OperationsWgStakingEventsHandler<T>
+impl<T: stake::Trait + working_group::Trait<OperationsWorkingGroupInstance1>>
+    stake::StakingEventsHandler<T> for OperationsWgStakingEventsHandler1<T>
 {
     /// Unstake remaining sum back to the source_account_id
     fn unstaked(
@@ -117,10 +118,10 @@ impl<T: stake::Trait + working_group::Trait<OperationsWorkingGroupInstance>>
 
         let hiring_application_id = hiring::ApplicationIdByStakingId::<T>::get(*stake_id);
 
-        if working_group::MemberIdByHiringApplicationId::<T, OperationsWorkingGroupInstance>::contains_key(
+        if working_group::MemberIdByHiringApplicationId::<T, OperationsWorkingGroupInstance1>::contains_key(
             hiring_application_id,
         ) {
-            return <working_group::Module<T, OperationsWorkingGroupInstance>>::refund_working_group_stake(
+            return <working_group::Module<T, OperationsWorkingGroupInstance1>>::refund_working_group_stake(
 				*stake_id,
 				remaining_imbalance,
 			);
@@ -184,3 +185,91 @@ impl<T: stake::Trait + working_group::Trait<GatewayWorkingGroupInstance>>
         remaining_imbalance
     }
 }
+
+pub struct OperationsWgStakingEventsHandler2<T> {
+    pub marker: PhantomData<T>,
+}
+
+impl<T: stake::Trait + working_group::Trait<OperationsWorkingGroupInstance2>>
+    stake::StakingEventsHandler<T> for OperationsWgStakingEventsHandler2<T>
+{
+    /// Unstake remaining sum back to the source_account_id
+    fn unstaked(
+        stake_id: &<T as stake::Trait>::StakeId,
+        _unstaked_amount: BalanceOf<T>,
+        remaining_imbalance: NegativeImbalance<T>,
+    ) -> NegativeImbalance<T> {
+        // Stake not related to a staked role managed by the hiring module.
+        if !hiring::ApplicationIdByStakingId::<T>::contains_key(*stake_id) {
+            return remaining_imbalance;
+        }
+
+        let hiring_application_id = hiring::ApplicationIdByStakingId::<T>::get(*stake_id);
+
+        if working_group::MemberIdByHiringApplicationId::<T, OperationsWorkingGroupInstance2>::contains_key(
+            hiring_application_id,
+        ) {
+            return <working_group::Module<T, OperationsWorkingGroupInstance2>>::refund_working_group_stake(
+				*stake_id,
+				remaining_imbalance,
+			);
+        }
+
+        remaining_imbalance
+    }
+
+    /// Empty handler for the slashing.
+    fn slashed(
+        _: &<T as stake::Trait>::StakeId,
+        _: Option<<T as stake::Trait>::SlashId>,
+        _: BalanceOf<T>,
+        _: BalanceOf<T>,
+        remaining_imbalance: NegativeImbalance<T>,
+    ) -> NegativeImbalance<T> {
+        remaining_imbalance
+    }
+}
+
+pub struct OperationsWgStakingEventsHandler3<T> {
+    pub marker: PhantomData<T>,
+}
+
+impl<T: stake::Trait + working_group::Trait<OperationsWorkingGroupInstance3>>
+    stake::StakingEventsHandler<T> for OperationsWgStakingEventsHandler3<T>
+{
+    /// Unstake remaining sum back to the source_account_id
+    fn unstaked(
+        stake_id: &<T as stake::Trait>::StakeId,
+        _unstaked_amount: BalanceOf<T>,
+        remaining_imbalance: NegativeImbalance<T>,
+    ) -> NegativeImbalance<T> {
+        // Stake not related to a staked role managed by the hiring module.
+        if !hiring::ApplicationIdByStakingId::<T>::contains_key(*stake_id) {
+            return remaining_imbalance;
+        }
+
+        let hiring_application_id = hiring::ApplicationIdByStakingId::<T>::get(*stake_id);
+
+        if working_group::MemberIdByHiringApplicationId::<T, OperationsWorkingGroupInstance3>::contains_key(
+            hiring_application_id,
+        ) {
+            return <working_group::Module<T, OperationsWorkingGroupInstance3>>::refund_working_group_stake(
+				*stake_id,
+				remaining_imbalance,
+			);
+        }
+
+        remaining_imbalance
+    }
+
+    /// Empty handler for the slashing.
+    fn slashed(
+        _: &<T as stake::Trait>::StakeId,
+        _: Option<<T as stake::Trait>::SlashId>,
+        _: BalanceOf<T>,
+        _: BalanceOf<T>,
+        remaining_imbalance: NegativeImbalance<T>,
+    ) -> NegativeImbalance<T> {
+        remaining_imbalance
+    }
+}

runtime/src/lib.rs

@@ -481,7 +481,7 @@ impl stake::Trait for Runtime {
                 crate::integration::working_group::StorageWgStakingEventsHandler<Self>,
             ),
             (
-                crate::integration::working_group::OperationsWgStakingEventsHandler<Self>,
+                crate::integration::working_group::OperationsWgStakingEventsHandler1<Self>,
                 crate::integration::working_group::GatewayWgStakingEventsHandler<Self>,
             ),
         ),
@@ -567,11 +567,17 @@ pub type StorageWorkingGroupInstance = working_group::Instance2;
 pub type ContentDirectoryWorkingGroupInstance = working_group::Instance3;
 
 // The builder working group instance alias.
-pub type OperationsWorkingGroupInstance = working_group::Instance4;
+pub type OperationsWorkingGroupInstance1 = working_group::Instance4;
 
 // The gateway working group instance alias.
 pub type GatewayWorkingGroupInstance = working_group::Instance5;
 
+// The builder working group instance alias.
+pub type OperationsWorkingGroupInstance2 = working_group::Instance6;
+
+// The builder working group instance alias.
+pub type OperationsWorkingGroupInstance3 = working_group::Instance7;
+
 parameter_types! {
     pub const MaxWorkerNumberLimit: u32 = 100;
 }
@@ -586,7 +592,7 @@ impl working_group::Trait<ContentDirectoryWorkingGroupInstance> for Runtime {
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
 }
 
-impl working_group::Trait<OperationsWorkingGroupInstance> for Runtime {
+impl working_group::Trait<OperationsWorkingGroupInstance1> for Runtime {
     type Event = Event;
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
 }
@@ -596,6 +602,16 @@ impl working_group::Trait<GatewayWorkingGroupInstance> for Runtime {
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
 }
 
+impl working_group::Trait<OperationsWorkingGroupInstance2> for Runtime {
+    type Event = Event;
+    type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+}
+
+impl working_group::Trait<OperationsWorkingGroupInstance3> for Runtime {
+    type Event = Event;
+    type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+}
+
 parameter_types! {
     pub const ProposalCancellationFee: u64 = 10000;
     pub const ProposalRejectionFee: u64 = 5000;
@@ -725,7 +741,10 @@ construct_runtime!(
         // reserved for the future use: ForumWorkingGroup: working_group::<Instance1>::{Module, Call, Storage, Event<T>},
         StorageWorkingGroup: working_group::<Instance2>::{Module, Call, Storage, Config<T>, Event<T>},
         ContentDirectoryWorkingGroup: working_group::<Instance3>::{Module, Call, Storage, Config<T>, Event<T>},
-        OperationsWorkingGroup: working_group::<Instance4>::{Module, Call, Storage, Config<T>, Event<T>},
+        OperationsWorkingGroup1: working_group::<Instance4>::{Module, Call, Storage, Config<T>, Event<T>},
         GatewayWorkingGroup: working_group::<Instance5>::{Module, Call, Storage, Config<T>, Event<T>},
+        OperationsWorkingGroup2: working_group::<Instance6>::{Module, Call, Storage, Config<T>, Event<T>},
+        OperationsWorkingGroup3: working_group::<Instance7>::{Module, Call, Storage, Config<T>, Event<T>},
+
     }
 );