Implement fetch all unpaid events

CONTRIBUTING.md

@@ -13,7 +13,7 @@ Welcome, contributing to `chainevents` is easy!
 1. Submit or comment your intent on an issue
 1. We will try to respond quickly
 1. Fork this repo (fork all branches)
-1. Submit your PR against `develop`
+1. Submit your PR against `main`
 1. Address PR Review
 
 ### Issue

src/events/chainevents.cairo

@@ -3,7 +3,6 @@
 /// @notice A contract for creating and managing events with registration and attendance tracking
 /// @dev Implements Ownable and Upgradeable components from OpenZeppelin
 pub mod ChainEvents {
-    use openzeppelin_access::ownable::interface::IOwnable;
     use core::num::traits::zero::Zero;
     use chainevents_contracts::base::types::{EventDetails, EventRegistration, EventType};
     use chainevents_contracts::base::errors::Errors::{
@@ -417,6 +416,10 @@ pub mod ChainEvents {
         fn fetch_all_paid_events(self: @ContractState) -> Array<EventDetails> {
             self._fetch_all_paid_events()
         }
+
+        fn fetch_all_unpaid_events(self: @ContractState) -> Array<EventDetails> {
+            self._fetch_all_unpaid_events()
+        }
     }
 
     #[generate_trait]
@@ -753,10 +756,26 @@ pub mod ChainEvents {
 
         fn _paid_event_ticket_counts(self: @ContractState, event_id: u256) -> u256 {
             let caller = get_caller_address();
-            let (event_id, amount_paid) = self.paid_events.read(caller);
+            let (event_id, _) = self.paid_events.read(caller);
             self.paid_event_ticket_count.read(event_id)
         }
 
+        fn _fetch_all_unpaid_events(self: @ContractState) -> Array<EventDetails> {
+            let mut all_unpaid_events = ArrayTrait::new();
+            let total_events_counts = self.event_counts.read();
+
+            let mut count: u256 = 1;
+
+            while count <= total_events_counts {
+                let current_event = self.event_details.read(count);
+                if current_event.event_type == EventType::Free {
+                    all_unpaid_events.append(current_event);
+                }
+                count += 1;
+            };
+            all_unpaid_events
+        }
+
         fn _fetch_user_paid_event(self: @ContractState, caller: ContractAddress) -> (u256, u256) {
             // read the paid event details.
             let (event_id, amount_paid) = self.paid_events.read(caller);

src/interfaces/IEvent.cairo

@@ -37,6 +37,7 @@ pub trait IEvent<TContractState> {
     fn get_open_events(self: @TContractState) -> Array<EventDetails>;
     fn get_closed_events(self: @TContractState) -> Array<EventDetails>;
     fn fetch_all_paid_events(self: @TContractState) -> Array<EventDetails>;
+    fn fetch_all_unpaid_events(self: @TContractState) -> Array<EventDetails>;
 
     fn upgrade(ref self: TContractState, new_class_hash: ClassHash);
 }

tests/test_contract.cairo

@@ -1095,6 +1095,37 @@ fn test_fetch_all_paid_events() {
     assert(paid_events == expected_events, 'Paid events not retrieved');
 }
 
+#[test]
+fn test_fetch_all_unpaid_events() {
+    let strk_token = deploy_token_contract();
+    let event_contract_address = __setup__(strk_token);
+    let event_dispatcher = IEventDispatcher { contract_address: event_contract_address };
+
+    let mut expected_events = ArrayTrait::new();
+
+    let customer: ContractAddress = USER_ONE.try_into().unwrap();
+
+    start_cheat_caller_address(event_contract_address, customer);
+    let initial_event_id = event_dispatcher.add_event("Blockchain Conference", "Zone Tech Park");
+    stop_cheat_caller_address(event_contract_address);
+
+    let customer: ContractAddress = USER_TWO.try_into().unwrap();
+    start_cheat_caller_address(event_contract_address, customer);
+    let second_event_id = event_dispatcher
+        .add_event("Starknet ZK Stark Proof Workshop", "TheBuidl Hub");
+    stop_cheat_caller_address(event_contract_address);
+
+    start_cheat_caller_address(event_contract_address, USER_ONE.try_into().unwrap());
+
+    let unpaid_events = event_dispatcher.fetch_all_unpaid_events();
+    let expected = event_dispatcher.event_details(initial_event_id);
+    let expected_2 = event_dispatcher.event_details(second_event_id);
+    println!("Unpaid event numbers : {:?}", unpaid_events.len());
+    expected_events.append(expected);
+    expected_events.append(expected_2);
+    assert(unpaid_events.len() == expected_events.len(), 'Unpaid events not retrieved');
+}
+
 #[test]
 #[should_panic(expected: 'Caller Not Owner')]
 fn test_only_owner_can_withdraw_paid_event_amount() {