Merge pull request #1 from crowdpass-live/feat/add-or-remove-organizer

Feat/add or remove organizer

Author: dadadave80

.gitignore

@@ -1,4 +1,8 @@
 target
 .snfoundry_cache/
 
+# profile and trace files
+profile
+snfoundry_trace
+
 .DS_Store

src/errors.cairo

@@ -6,7 +6,7 @@ pub mod Errors {
     pub const ZERO_AMOUNT: felt252 = 'Amount cannot be zero';
     pub const ZERO_ADDRESS_CALLER: felt252 = 'Caller cannot be zero address';
     pub const ZERO_ADDRESS_OWNER: felt252 = 'Owner cannot be zero address';
-    pub const NOT_EVENT_ORGANIZER: felt252 = 'Caller not organizer';
+    pub const NOT_EVENT_ORGANIZER: felt252 = 'Caller not main organizer';
     pub const EVENT_NOT_CREATED: felt252 = 'Event not yet created';
     pub const EVENT_ENDED: felt252 = 'Event has ended';
     pub const EVENT_CANCELED: felt252 = 'Event is canceled';

src/event_factory/event_factory.cairo

@@ -107,7 +107,6 @@ pub mod EventFactory {
         upgradeable: UpgradeableComponent::Storage,
         event_count: u256,
         events: Map<u256, EventData>,
-        event_array: Array<EventData>,
         event_ticket_balance: Map<u256, u256>,
         strk_token_address: felt252,
         ticket_721_class_hash: felt252,
@@ -152,72 +151,21 @@ pub mod EventFactory {
             end_date: u64,
             total_tickets: u256,
             ticket_price: u256,
-        ) -> bool {
-            let caller = get_caller_address();
-            let event_count = self.event_count.read() + 1;
-            let address_this = get_contract_address();
-
-            // assert not zero ContractAddress
-            assert(caller.is_non_zero(), Errors::ZERO_ADDRESS_CALLER);
-
-            // create event role
-            let event_hash = PedersenTrait::new(0)
-                .update('CROWD_PASS_EVENT')
-                .update(event_count.try_into().unwrap())
-                .finalize();
-            // grant role to caller
-            self.accesscontrol._grant_role(event_hash, caller);
-
-            // let event_ticket_addr = self.deploy_ticket(address_this, address_this, ''.into());
-
-            // deploy ticket721 contract
-            let event_ticket = deploy_syscall(
-                self.ticket_721_class_hash.read().try_into().unwrap(),
-                event_hash,
-                array![address_this.into(), address_this.into()].span(),
-                true,
-            );
-
-            let (event_ticket_addr, _) = event_ticket.unwrap_syscall();
-
-            // initialize ticket721 contract
-            ITicket721Dispatcher { contract_address: event_ticket_addr }
-                .initialize(name, symbol, uri,);
-
-            // new event struct instance
-            let event_instance = EventData {
-                id: event_count,
-                organizer: caller,
-                ticket_addr: event_ticket_addr,
-                description: description,
-                location: location,
-                created_at: get_block_timestamp(),
-                updated_at: 0,
-                start_date: start_date,
-                end_date: end_date,
-                total_tickets: total_tickets,
-                ticket_price: ticket_price,
-                is_canceled: false,
-            };
-
-            // Map event_id to new_event
-            self.events.entry(event_count).write(event_instance);
-
-            // Append event to event_array
-            // self.event_array.append(event_instance);
-
-            // Update event count
-            self.event_count.write(event_count);
-
-            // emit event for event creation
-            self
-                .emit(
-                    EventCreated {
-                        id: event_count, organizer: caller, ticket_address: event_ticket_addr
-                    }
+        ) -> EventData {
+            let event = self
+                ._create_event(
+                    name,
+                    symbol,
+                    uri,
+                    description,
+                    location,
+                    start_date,
+                    end_date,
+                    total_tickets,
+                    ticket_price
                 );
 
-            true
+            event
         }
 
         fn update_event(
@@ -235,10 +183,7 @@ pub mod EventFactory {
         ) -> bool {
             let caller = get_caller_address();
 
-            let event_hash = PedersenTrait::new(0)
-                .update('CROWD_PASS_EVENT')
-                .update(event_id.try_into().unwrap())
-                .finalize();
+            let event_hash = self._gen_event_hash(event_id);
             // assert caller has role
             self.accesscontrol.assert_only_role(event_hash);
 
@@ -269,17 +214,14 @@ pub mod EventFactory {
             let organizer = self.events.entry(event_id).read().organizer;
             let mut event_instance = self.events.entry(event_id).read();
 
-            let event_hash = PedersenTrait::new(0)
-                .update('CROWD_PASS_EVENT')
-                .update(event_id.try_into().unwrap())
-                .finalize();
-            // assert caller has role
-            self.accesscontrol.assert_only_role(event_hash);
+            let event_hash = self._gen_event_hash(event_id);
 
             assert(event_id <= event_count, Errors::EVENT_NOT_CREATED);
             // assert not zeroAddr caller
             assert(caller.is_non_zero(), Errors::ZERO_ADDRESS_CALLER);
-            // assert caller is event organizer
+            // assert caller has  role
+            self.accesscontrol.assert_only_role(event_hash);
+            // assert caller is the main event organizer
             assert(caller == organizer, Errors::NOT_EVENT_ORGANIZER);
             // assert event has not ended
             assert(event_instance.end_date > get_block_timestamp(), Errors::EVENT_ENDED);
@@ -293,6 +235,17 @@ pub mod EventFactory {
             true
         }
 
+        fn add_organizer(ref self: ContractState, event_id: u256, organizer: ContractAddress) {
+            let event_hash = self._gen_event_hash(event_id);
+            self.accesscontrol.assert_only_role(event_hash);
+            self._add_organizer(event_hash, organizer);
+        }
+        fn remove_organizer(ref self: ContractState, event_id: u256, organizer: ContractAddress) {
+            let event_hash = self._gen_event_hash(event_id);
+            self.accesscontrol.assert_only_role(event_hash);
+            self._remove_organizer(event_hash, organizer);
+        }
+
         fn purchase_ticket(ref self: ContractState, event_id: u256) -> bool {
             let caller: ContractAddress = get_caller_address();
             let event_count: u256 = self.event_count.read();
@@ -413,6 +366,98 @@ pub mod EventFactory {
     //////////////////////////////////////////////////////////////////////////*//
     impl AccessControlInternalImpl = AccessControlComponent::InternalImpl<ContractState>;
     impl UpgradeableInternalImpl = UpgradeableComponent::InternalImpl<ContractState>;
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        fn _gen_event_hash(self: @ContractState, event_id: u256) -> felt252 {
+            PedersenTrait::new(0)
+                .update('CROWD_PASS_EVENT')
+                .update(event_id.try_into().unwrap())
+                .finalize()
+        }
+
+        fn _create_event(
+            ref self: ContractState,
+            name: ByteArray,
+            symbol: ByteArray,
+            uri: ByteArray,
+            description: ByteArray,
+            location: ByteArray,
+            start_date: u64,
+            end_date: u64,
+            total_tickets: u256,
+            ticket_price: u256,
+        ) -> EventData {
+            let caller = get_caller_address();
+            let event_count = self.event_count.read() + 1;
+            let address_this = get_contract_address();
+
+            // create event role
+            let event_hash = self._gen_event_hash(event_count);
+            // grant caller event role
+            self.accesscontrol._grant_role(event_hash, caller);
+
+            // deploy ticket721 contract
+            let event_ticket = deploy_syscall(
+                self.ticket_721_class_hash.read().try_into().unwrap(),
+                event_hash,
+                array![address_this.into(), address_this.into()].span(),
+                true,
+            );
+
+            let (event_ticket_addr, _) = event_ticket.unwrap_syscall();
+
+            // initialize ticket721 contract
+            ITicket721Dispatcher { contract_address: event_ticket_addr }
+                .initialize(name, symbol, uri,);
+
+            // new event struct instance
+            let event_instance = EventData {
+                id: event_count,
+                organizer: caller,
+                ticket_addr: event_ticket_addr,
+                description: description,
+                location: location,
+                created_at: get_block_timestamp(),
+                updated_at: 0,
+                start_date: start_date,
+                end_date: end_date,
+                total_tickets: total_tickets,
+                ticket_price: ticket_price,
+                is_canceled: false,
+            };
+
+            // Map event_id to new_event
+            self.events.entry(event_count).write(event_instance);
+
+            // Update event count
+            self.event_count.write(event_count);
+
+            // emit event for event creation
+            self
+                .emit(
+                    EventCreated {
+                        id: event_count, organizer: caller, ticket_address: event_ticket_addr
+                    }
+                );
+
+            self.events.entry(event_count).read()
+        }
+
+        fn _add_organizer(
+            ref self: ContractState, event_hash: felt252, organizer: ContractAddress
+        ) {
+            // grant role to caller
+            self.accesscontrol._grant_role(event_hash, organizer);
+        }
+
+        fn _remove_organizer(
+            ref self: ContractState, event_hash: felt252, organizer: ContractAddress
+        ) {
+            // revoke role from caller
+            self.accesscontrol._revoke_role(event_hash, organizer);
+        }
+    }
     // #[generate_trait]
 // pub impl MultiCallImpl of IMultiCallTrait<ContractState> {
 //     // Internal function to execute multiple calls

src/interfaces/i_event_factory.cairo

@@ -14,7 +14,7 @@ pub trait IEventFactory<TContractState> {
         end_date: u64,
         total_tickets: u256,
         ticket_price: u256,
-    ) -> bool;
+    ) -> EventData;
     fn update_event(
         ref self: TContractState,
         event_id: u256,
@@ -29,6 +29,8 @@ pub trait IEventFactory<TContractState> {
         ticket_price: u256,
     ) -> bool;
     fn cancel_event(ref self: TContractState, event_id: u256) -> bool;
+    fn add_organizer(ref self: TContractState, event_id: u256, organizer: ContractAddress);
+    fn remove_organizer(ref self: TContractState, event_id: u256, organizer: ContractAddress);
     fn purchase_ticket(ref self: TContractState, event_id: u256) -> bool;
     fn get_all_events(self: @TContractState) -> Array<EventData>;
     fn get_event(self: @TContractState, event_id: u256) -> EventData;
@@ -41,8 +43,8 @@ pub trait IEventFactory<TContractState> {
 pub struct EventData {
     pub id: u256,
     pub organizer: ContractAddress,
-    pub description: ByteArray,
     pub ticket_addr: ContractAddress,
+    pub description: ByteArray,
     pub location: ByteArray,
     pub created_at: u64,
     pub updated_at: u64,

tests/test_event_factory.cairo

@@ -42,7 +42,7 @@ fn deploy_event_factory() -> ContractAddress {
     event_factory_address
 }
 
-fn create_event() -> (ContractAddress, bool, EventData, ITicket721Dispatcher,) {
+fn create_event() -> (ContractAddress, EventData, ITicket721Dispatcher,) {
     let event_factory_address = deploy_event_factory();
     let event_factory = IEventFactoryDispatcher { contract_address: event_factory_address };
 
@@ -61,37 +61,36 @@ fn create_event() -> (ContractAddress, bool, EventData, ITicket721Dispatcher,) {
             100
         );
 
-    let event_data: EventData = event_factory.get_event(1);
-    let evt_addr: ContractAddress = event_data.ticket_addr;
+    let evt_addr: ContractAddress = event.ticket_addr;
     let event_ticket = ITicket721Dispatcher { contract_address: evt_addr };
-    (event_factory_address, event, event_data, event_ticket)
+    (event_factory_address, event, event_ticket)
 }
 
 #[test]
 #[fork("SEPOLIA_LATEST")]
 fn test_create_event() {
-    let (event_factory_address, event, event_data, event_ticket) = create_event();
+    let (event_factory_address, event, event_ticket) = create_event();
     let event_factory = IEventFactoryDispatcher { contract_address: event_factory_address };
 
-    assert(event, 'Event creation failed');
-    assert(event_factory.get_event_count() == 1, 'Invalid event count');
-    assert(event_data.id == 1, 'Invalid event id');
-    assert(event_data.organizer == ACCOUNT.try_into().unwrap(), 'Invalid organizer');
-    assert(event_data.description == "Event Description", 'Invalid description');
-    assert(event_data.location == "Event Location", 'Invalid location');
-    assert(event_data.start_date <= get_block_timestamp(), 'Invalid start date');
-    assert(event_data.end_date <= get_block_timestamp() + 86400, 'Invalid end date');
-    assert(event_data.total_tickets == 100, 'Invalid total tickets');
-    assert(event_data.ticket_price == 100, 'Invalid ticket price');
-    assert(event_ticket.total_supply() == 0, 'Invalid total supply');
-    assert(event_ticket.name() == "Event Name", 'Invalid name');
-    assert(event_ticket.symbol() == "Event Symbol", 'Invalid symbol');
+    // assert(event, 'Event creation failed');
+    assert_eq!(event_factory.get_event_count(), 1);
+    assert_eq!(event.id, 1);
+    assert_eq!(event.organizer, ACCOUNT.try_into().unwrap());
+    assert_eq!(event.description, "Event Description");
+    assert_eq!(event.location, "Event Location");
+    assert(event.start_date <= get_block_timestamp(), 'Invalid start date');
+    assert(event.end_date <= get_block_timestamp() + 86400, 'Invalid end date');
+    assert_eq!(event.total_tickets, 100);
+    assert_eq!(event.ticket_price, 100);
+    assert_eq!(event_ticket.total_supply(), 0);
+    assert_eq!(event_ticket.name(), "Event Name");
+    assert_eq!(event_ticket.symbol(), "Event Symbol");
 }
 
 #[test]
 #[fork("SEPOLIA_LATEST")]
 fn test_cancel_event() {
-    let (event_factory_address, _, _, _) = create_event();
+    let (event_factory_address, _, _) = create_event();
     let event_factory = IEventFactoryDispatcher { contract_address: event_factory_address };
 
     let event_canceled = event_factory.cancel_event(1);
@@ -100,19 +99,21 @@ fn test_cancel_event() {
     assert(event_canceled, 'Event cancellation failed');
     assert(event_data.is_canceled == true, 'Event not canceled');
 }
-// #[test]
-// #[fork("SEPOLIA_LATEST")]
-// fn test_not_organizer_cancel_event() {
-//     let (event_factory_address, _, _, _) = create_event();
-//     let event_factory = IEventFactoryDispatcher { contract_address: event_factory_address };
 
-//     let event_canceled = event_factory.cancel_event(1);
-//     let event_data: EventData = event_factory.get_event(1);
+#[test]
+#[fork("SEPOLIA_LATEST")]
+#[should_panic(expected: 'Caller not main organizer')]
+fn test_not_main_organizer_cancel_event() {
+    let (event_factory_address, _, _) = create_event();
+    let event_factory = IEventFactoryDispatcher { contract_address: event_factory_address };
 
-//     assert(event_canceled, 'Event cancellation failed');
-//     assert(event_data.is_canceled == true, 'Event not canceled');
-// }
+    event_factory.add_organizer(1, ACCOUNT1.try_into().unwrap());
+    stop_cheat_caller_address(event_factory_address);
+
+    start_cheat_caller_address(event_factory_address, ACCOUNT1.try_into().unwrap());
 
+    let event_canceled = event_factory.cancel_event(1);
+}
 // #[test]
 // fn test_increase_balance() {
 //     let contract_address = deploy_contract("EventFactory");