# Coalesce - an event and booking hApp
# Project discription
The synopsis for this app is that any event space would need a way to set up events that are happening, where people can choose to attend, pay for tickets, access information and contribute information (diet, preferences etc)
It would be very useful if this would also be connected to a zome that handles booking of a room so that events are tied to the space that they are going to be in.
Finding an event space to use to host an event at could also be seen as similar to finding an event that one wants to go to, so it's kind of a similar app design.
_(find possible event locations around some physical space --> find available timeslots --> attend that slot with a booking)_
If booking and event zomes could also operate independently so that a booking does not need to also be an event and an event does not need to be connected to a booked space, that flexibility would be beneficial. _(a laundry room booking scenario does not require events, online events might not need space booking)_
# Project category
Education, Event management, Social facilitation
# Difficulty
**Green-ish?**
## Usecases:
#### Creating bookings and events
* Event host finds an empty slot in an event space calendar to use for a gathering and books that space (time and place is set in booking)
* Booking is extended with a bunch of information about the event (price, description, no. of participants, etc.) so an event page is created. **Events can also be created without booking, assuming that is handled seperatly or just being outside or whatever**
#### Discovery, joining and feedback
* Attendees are able to be invited to or browse events and can choose to attend an event. (Internal mutual credit could handle potential attendance fees)
* Each event would have a comments thread (bridge to chat functionality) where people can ask questions about an event
#### Groups
* An agent should be able to start a group, join a group and leave a group. (group owner might also be able to approve new members)
* Events created in a group should automatically invite all people from a group and the attendee list would indicate if attendee is a part of the group (could also exclude non-members from attending).
* There may be restrictions on who gets to create events in a group (prior engagement, reputation, etc)
-------
# Design documents
## Simple UI sketch (or more)
(put an image of some sort here, with description)
## Zome layout
_(how many zomes, what are they going to be like)_
The application would be devided into two zomes.
The first zome would be all functionality and entries that are concerned with the **booking functionality** of a space (could also be exported/or imported as a zome that is used for booking a vehicle/tool thing, maybe look at [MailBoox](https://github.com/zaunders/MailBoox-SymCode)).
The Second zome would be things needed to **manage events**, have people join and handle details and conversation about it.
# Zome 1 - Booking Space
## Design diagram
```mermaid
graph TD
subgraph Booking Space zome
subgraph anchors
all_location_types
all_locations
end
subgraph Location Types
all_location_types --> public_bulding
all_location_types --> conference_center
all_location_types --> communal_building
all_location_types --> accomodation
end
subgraph Locations
all_locations --> town_liberary
all_locations --> hub_of_impact
public_bulding --> town_liberary
conference_center --> hub_of_impact
communal_building --> food_hub
end
subgraph Rooms
hub_of_impact --> meeting_room_alpha
hub_of_impact --> meeting_room_beta
food_hub --> fermentation_space
end
subgraph Timeboxes
timebox_afternoon
timebox_13-14
end
subgraph Reservations
timebox_afternoon --> reservation_0331
meeting_room_alpha --> reservation_0331
timebox_13-14 --> reservation_0332
fermentation_space --> reservation_0332
end
subgraph Users
Alice -.makes_reservation.-> reservation_0331
reservation_0331 -.made by.-> Alice
Bob -.makes_reservation.-> reservation_0332
reservation_0332 -.made by.-> Bob
end
end
```
## Functions needed
(a list of the functions that are going to bee needed in the application)
* create_location()
* create_room()
* create_timebox()
* allocate_timeboxes_to_rooms()
* make_reservation()
* varify_booking()
* cancel_booking()
* varify_payment() (_optional_)
## Entries structures
(what information is needed in the application entries in order for the app to work)
#### Building/place
* Location (GPS/Adress)
* Description (text)
#### Room
* Space (square meters/feet)
* Max occupancy (# people)
* Description (text)
#### Timebox
* Name (text)
* Start (time/date)
* End (time/date)
#### Reservation
* Start (time/date)
* End (time/date)
* comment_on_state (text)
* varified_booking()
* price() _(optional)_
#### Extras
_this entry could be used to expose customizations of the space. Things like equipment, facilitation or food may be created and listed as available with a timebox_
* room_option (text)
* price() _(optional)_
------
_Maybe borrow logic from the Mailboox loans zome using **reservation** instead of loan and **room** instead of item:_
```rust
#[derive(Serialize, Deserialize, Debug, DefaultJson)]
struct Loan {
item_address: Address,
borrower_address: Option<Address>,
started_at: Option<i64>
finished_at: Option<i64>
comment: Option<String>
return_by: Option<i64>
}
```
---
# Zome 2 - Events
## Design diagram
```mermaid
graph TD
subgraph Events zome
subgraph anchors
all_groups
all_event_types
end
subgraph Groups
all_groups --> Lisbon_tech_scene
all_groups --> AoH_Lisbon
end
subgraph Event Types
all_event_types --> Learning
all_event_types --> Tech
end
subgraph Events
Learning --> Facilitation_training
Learning --> Creative_writing
Tech --> Holochain_introduction
AoH_Lisbon -.group event.-> Facilitation_training
Lisbon_tech_scene --> Holochain_introduction
end
subgraph Users
Alice -.attending.-> Holochain_introduction
Holochain_introduction -.attended by.-> Alice
Bob -.hosting.-> Facilitation_training
Facilitation_training -.hosted by.-> Bob
Alice -.part of group.-> Lisbon_tech_scene
Bob -.part of group.-> AoH_Lisbon
end
end
```
## Functions needed
(a list of the functions that are going to bee needed in the application)
* create_event()
* edit_event()
* cancel_event()
* attend_event() _(yes or maybe?)_
* favourite_event()
* un_attend_event()
* get_events_near_location()
* get_my_events_attending()
* get_my_events_hosting()
* create_group()
* invite_to_group()
* approve_to_join()
## Entries structures
(what information is needed in the application entries in order for the app to work)
#### Event entry:
* Location (_set or read from booking_, adress)
* Getting there (_optional_, text)
* Date/time (_set or read from booking_, timestamp)
* Name (text)
* Details (text)
#### Group entry:
* Name
* Description
#### Links
agent --> event (my_event)
event --> agent (is_host)
agent --> event (is_attending)
event --> agent (participant)
agent --> event (starred/interested)
event --> agent (interest_shown)
group --> event (group_event)
event --> group (hosting_group
)
----------------
## Additional design conciderations
_(are there specific patterns that are used in the functioning of the app)_
* in case of overbooking (simultanious non-synch over-attendance by participants due to eventual consistensy) at an event, the event host should be able to choose who gets to go. Also special invite slots should be possible to extend as host. This would require accepting (counter-signing) anyone marked as going. Same thing goes for an owner of a space that is beeing booked.
* In case of an event cancellation, participants are automatically repayed fees if there is an internal currency.
Additional conversation can be found in [this](https://forum.holochain.org/t/alternative-to-meetup-com/1322/6) thread on the HC forum.
## Future integrations
* open standard digital lock integration (anyone that has an event in the space that day is also authorized to open the door (possibility of lending that capacity)). **There really ought to be a keyring app for that specific purpose.**
## Phasing
#### How many phases?
?
#### What functionality is in what phase?
?
#### What phase is the app in?
Phase 1 - design
# Phase-divided tasks
(also use github issues for tasks)
?
# Events planned for community to work with it
(is there anyone activly doing work with this that want to pair up?)
?
# People that have been involved that are open to be contacted
Bear, Lily