MahmoudEmad/herolib
1
0
Fork 0
Code Issues 55 Pull Requests 1 Actions Packages Projects Releases 26 Wiki Activity

...

Browse Source
This commit is contained in:
despiegk
2025-09-18 06:57:59 +02:00
parent 6be418f8cb
commit ba190c20cd
5 changed files with 866 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
lib/hero/heromodels/calendar_event.v
View File

@@ -9,30 +9,32 @@ import freeflowuniverse.herolib.hero.db
pub struct CalendarEvent {
db.Base
pub mut:
title string
start_time i64 // Unix timestamp
end_time i64 // Unix timestamp
location string
attendees []Attendee
fs_items []u32 // IDs of linked files or dirs
calendar_id u32 // Associated calendar
status EventStatus
is_all_day bool
is_recurring bool
recurrence []RecurrenceRule // normally empty
reminder_mins []int // Minutes before event for reminders
color string // Hex color code
timezone string
priority EventPriority
public bool
title string
start_time i64 // Unix timestamp
end_time i64 // Unix timestamp
location string
registration_desks []u32 //link to object for registration, is where we track invitees, are not attendee unless accepted
attendees []Attendee
fs_items []FileAttachment // link to docs
calendar_id u32 // Associated calendar
status EventStatus
is_all_day bool
is_recurring bool
recurrence []RecurrenceRule // normally empty
reminder_mins []int // Minutes before event for reminders
color string // Hex color code
timezone string
priority EventPriority
public bool
}
pub struct Attendee {
pub mut:
user_id u32
status_latest AttendanceStatus
attendance_required bool
admin bool // if set can manage the main elements of the event = description, ...
admin bool // if set can manage the main elements of the event = description, can accept invitee...
organizer bool // if set means others can ask for support, doesn't mean is admin
log []AttendeeLog
}
@@ -82,6 +84,13 @@ pub enum RecurrenceFreq {
yearly
}
pub struct FileAttachment {
pub mut:
fs_item u32
cat string // can be freely chosen, will always be made lowercase e.g. agenda
public bool // everyone can see the file, otherwise only the organizers, attendees
}
@[params]
pub struct CalendarEventListArg {
pub mut:
@@ -154,6 +163,9 @@ pub fn (self CalendarEvent) dump(mut e encoder.Encoder) ! {
e.add_i64(self.end_time)
e.add_string(self.location)
// Encode registration_desks array
e.add_list_u32(self.registration_desks)
// Encode attendees array
e.add_u16(u16(self.attendees.len))
for attendee in self.attendees {
@@ -172,7 +184,14 @@ pub fn (self CalendarEvent) dump(mut e encoder.Encoder) ! {
}
}
e.add_list_u32(self.fs_items)
// Encode fs_items array
e.add_u16(u16(self.fs_items.len))
for fs_item in self.fs_items {
e.add_u32(fs_item.fs_item)
e.add_string(fs_item.cat)
e.add_bool(fs_item.public)
}
e.add_u32(self.calendar_id)
e.add_u8(u8(self.status))
e.add_bool(self.is_all_day)
@@ -202,6 +221,9 @@ pub fn (mut self DBCalendarEvent) load(mut o CalendarEvent, mut e encoder.Decode
o.end_time = e.get_i64()!
o.location = e.get_string()!
// Decode registration_desks array
o.registration_desks = e.get_list_u32()!
// Decode attendees array
attendees_len := e.get_u16()!
mut attendees := []Attendee{}
@@ -238,7 +260,22 @@ pub fn (mut self DBCalendarEvent) load(mut o CalendarEvent, mut e encoder.Decode
}
o.attendees = attendees
o.fs_items = e.get_list_u32()!
// Decode fs_items array
fs_items_len := e.get_u16()!
mut fs_items := []FileAttachment{}
for _ in 0 .. fs_items_len {
fs_item := e.get_u32()!
cat := e.get_string()!
public := e.get_bool()!
fs_items << FileAttachment{
fs_item: fs_item
cat: cat
public: public
}
}
o.fs_items = fs_items
o.calendar_id = e.get_u32()!
o.status = unsafe { EventStatus(e.get_u8()!) } // TODO: is there no better way?
o.is_all_day = e.get_bool()!
@@ -300,11 +337,21 @@ pub mut:
// get new calendar event, not from the DB
pub fn (mut self DBCalendarEvent) new(args CalendarEventArg) !CalendarEvent {
// Convert fs_items from []u32 to []FileAttachment
mut fs_attachments := []FileAttachment{}
for fs_item_id in args.fs_items {
fs_attachments << FileAttachment{
fs_item: fs_item_id
cat: ''
public: false
}
}
mut o := CalendarEvent{
title: args.title
location: args.location
attendees: []Attendee{}
fs_items: args.fs_items
fs_items: fs_attachments
calendar_id: args.calendar_id
status: args.status
is_all_day: args.is_all_day
@@ -314,6 +361,7 @@ pub fn (mut self DBCalendarEvent) new(args CalendarEventArg) !CalendarEvent {
color: args.color
timezone: args.timezone
priority: args.priority // Added missing priority field
public: false
}
// Set base fields

156
lib/hero/heromodels/calendar_event_test.v
View File

@@ -41,6 +41,7 @@ fn test_calendar_event_new() ! {
assert calendar_event.title == 'Team Meeting'
assert calendar_event.location == 'Office'
assert calendar_event.fs_items.len == 0
assert calendar_event.registration_desks.len == 0
assert calendar_event.calendar_id == 1
assert calendar_event.status == .published
assert calendar_event.is_all_day == false
@@ -89,6 +90,16 @@ fn test_calendar_event_crud_operations() ! {
mut calendar_event := db_calendar_event.new(args)!
// Add some data for registration_desks and fs_items
calendar_event.registration_desks = [u32(1001), u32(1002)]
mut fs_item := FileAttachment{
fs_item: 2001
cat: 'agenda'
public: true
}
calendar_event.fs_items = [fs_item]
// Test set operation
calendar_event = db_calendar_event.set(calendar_event)!
original_id := calendar_event.id
@@ -107,6 +118,13 @@ fn test_calendar_event_crud_operations() ! {
assert retrieved_event.color == '#0000FF'
assert retrieved_event.timezone == 'UTC'
assert retrieved_event.id == original_id
assert retrieved_event.registration_desks.len == 2
assert retrieved_event.registration_desks[0] == 1001
assert retrieved_event.registration_desks[1] == 1002
assert retrieved_event.fs_items.len == 1
assert retrieved_event.fs_items[0].fs_item == 2001
assert retrieved_event.fs_items[0].cat == 'agenda'
assert retrieved_event.fs_items[0].public == true
// Test exist operation
exists := db_calendar_event.exist(original_id)!
@@ -137,6 +155,17 @@ fn test_calendar_event_crud_operations() ! {
mut updated_event := db_calendar_event.new(updated_args)!
updated_event.id = original_id
// Update registration_desks and fs_items
updated_event.registration_desks = [u32(1003)]
mut updated_fs_item := FileAttachment{
fs_item: 2002
cat: 'minutes'
public: false
}
updated_event.fs_items = [updated_fs_item]
updated_event = db_calendar_event.set(updated_event)!
// Verify update
@@ -152,6 +181,12 @@ fn test_calendar_event_crud_operations() ! {
assert final_event.reminder_mins == [30]
assert final_event.color == '#FF0000'
assert final_event.timezone == 'EST'
assert final_event.registration_desks.len == 1
assert final_event.registration_desks[0] == 1003
assert final_event.fs_items.len == 1
assert final_event.fs_items[0].fs_item == 2002
assert final_event.fs_items[0].cat == 'minutes'
assert final_event.fs_items[0].public == false
// Test delete operation
db_calendar_event.delete(original_id)!
@@ -343,6 +378,127 @@ fn test_calendar_event_recurrence_encoding_decoding() ! {
println('✓ CalendarEvent recurrence encoding/decoding test passed!')
}
fn test_calendar_event_registration_desks_encoding_decoding() ! {
// Initialize DBCalendarEvent for testing
mut mydb := db.new_test()!
mut db_calendar_event := DBCalendarEvent{
db: &mydb
}
// Create a new calendar event with registration desks
mut args := CalendarEventArg{
name: 'registration_desks_test_event'
description: 'Test calendar event for registration desks encoding/decoding'
title: 'Team Meeting'
start_time: '2025-01-01 10:00:00'
end_time: '2025-01-01 11:00:00'
location: 'Office'
attendees: []u32{}
fs_items: []u32{}
calendar_id: 1
status: .published
is_all_day: false
is_recurring: false
recurrence: []RecurrenceRule{}
reminder_mins: [15]
color: '#0000FF'
timezone: 'UTC'
priority: .normal
securitypolicy: 0
tags: []string{}
comments: []db.CommentArg{}
}
mut calendar_event := db_calendar_event.new(args)!
// Add registration desks manually
calendar_event.registration_desks = [u32(1001), u32(1002), u32(1003)]
// Save the calendar event
calendar_event = db_calendar_event.set(calendar_event)!
calendar_event_id := calendar_event.id
// Retrieve and verify all fields were properly encoded/decoded
retrieved_event := db_calendar_event.get(calendar_event_id)!
assert retrieved_event.registration_desks.len == 3
assert retrieved_event.registration_desks[0] == 1001
assert retrieved_event.registration_desks[1] == 1002
assert retrieved_event.registration_desks[2] == 1003
println('✓ CalendarEvent registration_desks encoding/decoding test passed!')
}
fn test_calendar_event_fs_items_encoding_decoding() ! {
// Initialize DBCalendarEvent for testing
mut mydb := db.new_test()!
mut db_calendar_event := DBCalendarEvent{
db: &mydb
}
// Create a new calendar event with file attachments
mut args := CalendarEventArg{
name: 'fs_items_test_event'
description: 'Test calendar event for fs_items encoding/decoding'
title: 'Team Meeting'
start_time: '2025-01-01 10:00:00'
end_time: '2025-01-01 11:00:00'
location: 'Office'
attendees: []u32{}
fs_items: []u32{}
calendar_id: 1
status: .published
is_all_day: false
is_recurring: false
recurrence: []RecurrenceRule{}
reminder_mins: [15]
color: '#0000FF'
timezone: 'UTC'
priority: .normal
securitypolicy: 0
tags: []string{}
comments: []db.CommentArg{}
}
mut calendar_event := db_calendar_event.new(args)!
// Add file attachments manually
mut fs_item1 := FileAttachment{
fs_item: 2001
cat: 'agenda'
public: true
}
mut fs_item2 := FileAttachment{
fs_item: 2002
cat: 'minutes'
public: false
}
calendar_event.fs_items = [fs_item1, fs_item2]
// Save the calendar event
calendar_event = db_calendar_event.set(calendar_event)!
calendar_event_id := calendar_event.id
// Retrieve and verify all fields were properly encoded/decoded
retrieved_event := db_calendar_event.get(calendar_event_id)!
assert retrieved_event.fs_items.len == 2
// Verify first file attachment details
assert retrieved_event.fs_items[0].fs_item == 2001
assert retrieved_event.fs_items[0].cat == 'agenda'
assert retrieved_event.fs_items[0].public == true
// Verify second file attachment details
assert retrieved_event.fs_items[1].fs_item == 2002
assert retrieved_event.fs_items[1].cat == 'minutes'
assert retrieved_event.fs_items[1].public == false
println('✓ CalendarEvent fs_items encoding/decoding test passed!')
}
fn test_calendar_event_type_name() ! {
// Initialize DBCalendarEvent for testing
mut mydb := db.new_test()!

2
lib/hero/heromodels/group_test.v
View File

@@ -259,7 +259,7 @@ fn test_group_list_operations() ! {
public_groups := db_group.list(public_list_args)!
assert public_groups.len >= 1
found_public := false
mut found_public := false
for group in public_groups {
if group.id == public_group.id {
found_public = true

252
lib/hero/heromodels/registration_desk.v Normal file
View File

@@ -0,0 +1,252 @@
module heromodels
import freeflowuniverse.herolib.data.encoder
import freeflowuniverse.herolib.data.ourtime
import freeflowuniverse.herolib.hero.db
@[heap]
pub struct RegistrationDesk {
db.Base
pub mut:
name string
description string //probably in markdown
fs_items []u32 // link to docs
white_list []u32 // users who can enter, if 1 specified then people need to be in this list
white_list_accepted []u32 // if in this list automatically accepted
black_list []u32 // users not allowed
start_time u64 // time when users can start registration
end_time u64 // time when registration desk stops
acceptance_required bool // if set then admins need to approve
registrations []Registration
}
pub struct Registration {
pub mut:
user_id u32
accepted bool // an administrator needs to accept this person, now becomes an attendee
accepted_by u32 // the user who did the acceptance
timestamp u64 // time when registration happened
timestamp_acceptation u64 // when acceptation was done
}
pub struct DBRegistrationDesk {
pub mut:
db &db.DB @[skip; str: skip]
}
pub fn (self RegistrationDesk) type_name() string {
return 'registration_desk'
}
// return example rpc call and result for each methodname
pub fn (self RegistrationDesk) description(methodname string) string {
match methodname {
'set' {
return 'Create or update a registration desk. Returns the ID of the registration desk.'
}
'get' {
return 'Retrieve a registration desk by ID. Returns the registration desk object.'
}
'delete' {
return 'Delete a registration desk by ID. Returns true if successful.'
}
'exist' {
return 'Check if a registration desk exists by ID. Returns true or false.'
}
'list' {
return 'List all registration desks. Returns an array of registration desk objects.'
}
else {
return 'This is generic method for the root object, TODO fill in, ...'
}
}
}
// return example rpc call and result for each methodname, so example for call and the result
pub fn (self RegistrationDesk) example(methodname string) (string, string) {
match methodname {
'set' {
return '{"registration_desk": {"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}}', '1'
}
'get' {
return '{"id": 1}', '{"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}'
}
'delete' {
return '{"id": 1}', 'true'
}
'exist' {
return '{"id": 1}', 'true'
}
'list' {
return '{}', '[{"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}]'
}
else {
return '{}', '{}'
}
}
}
pub fn (self RegistrationDesk) dump(mut e encoder.Encoder) ! {
e.add_string(self.name)
e.add_string(self.description)
e.add_list_u32(self.fs_items)
e.add_list_u32(self.white_list)
e.add_list_u32(self.white_list_accepted)
e.add_list_u32(self.black_list)
e.add_u64(self.start_time)
e.add_u64(self.end_time)
e.add_bool(self.acceptance_required)
// Encode registrations array
e.add_u16(u16(self.registrations.len))
for registration in self.registrations {
e.add_u32(registration.user_id)
e.add_bool(registration.accepted)
e.add_u32(registration.accepted_by)
e.add_u64(registration.timestamp)
e.add_u64(registration.timestamp_acceptation)
}
}
pub fn (mut self DBRegistrationDesk) load(mut o RegistrationDesk, mut e encoder.Decoder) ! {
o.name = e.get_string()!
o.description = e.get_string()!
o.fs_items = e.get_list_u32()!
o.white_list = e.get_list_u32()!
o.white_list_accepted = e.get_list_u32()!
o.black_list = e.get_list_u32()!
o.start_time = e.get_u64()!
o.end_time = e.get_u64()!
o.acceptance_required = e.get_bool()!
// Decode registrations array
registrations_len := e.get_u16()!
mut registrations := []Registration{}
for _ in 0 .. registrations_len {
user_id := e.get_u32()!
accepted := e.get_bool()!
accepted_by := e.get_u32()!
timestamp := e.get_u64()!
timestamp_acceptation := e.get_u64()!
registrations << Registration{
user_id: user_id
accepted: accepted
accepted_by: accepted_by
timestamp: timestamp
timestamp_acceptation: timestamp_acceptation
}
}
o.registrations = registrations
}
@[params]
pub struct RegistrationDeskArg {
pub mut:
name string
description string
fs_items []u32 // IDs of linked files or dirs
white_list []u32 // users who can enter, if 1 specified then people need to be in this list
white_list_accepted []u32 // if in this list automatically accepted
black_list []u32 // users not allowed
start_time string // use ourtime module to go from string to epoch
end_time string // use ourtime module to go from string to epoch
acceptance_required bool // if set then admins need to approve
securitypolicy u32
tags []string
comments []db.CommentArg
}
pub fn (mut self DBRegistrationDesk) new(args RegistrationDeskArg) !RegistrationDesk {
mut o := RegistrationDesk{
name: args.name
description: args.description
fs_items: args.fs_items
white_list: args.white_list
white_list_accepted: args.white_list_accepted
black_list: args.black_list
acceptance_required: args.acceptance_required
registrations: []Registration{}
}
// Set base fields
o.securitypolicy = args.securitypolicy
o.tags = self.db.tags_get(args.tags)!
o.comments = self.db.comments_get(args.comments)!
o.updated_at = ourtime.now().unix()
// Convert string times to Unix timestamps
mut start_time_obj := ourtime.new(args.start_time)!
o.start_time = u64(start_time_obj.unix())
mut end_time_obj := ourtime.new(args.end_time)!
o.end_time = u64(end_time_obj.unix())
return o
}
pub fn (mut self DBRegistrationDesk) set(o RegistrationDesk) !RegistrationDesk {
// Use db set function which returns the object with assigned ID
return self.db.set[RegistrationDesk](o)!
}
pub fn (mut self DBRegistrationDesk) delete(id u32) ! {
self.db.delete[RegistrationDesk](id)!
}
pub fn (mut self DBRegistrationDesk) exist(id u32) !bool {
return self.db.exists[RegistrationDesk](id)!
}
pub fn (mut self DBRegistrationDesk) get(id u32) !RegistrationDesk {
mut o, data := self.db.get_data[RegistrationDesk](id)!
mut e_decoder := encoder.decoder_new(data)
self.load(mut o, mut e_decoder)!
return o
}
@[params]
pub struct RegistrationDeskListArg {
pub mut:
name string
description string
limit int = 100 // Default limit is 100
}
pub fn (mut self DBRegistrationDesk) list(args RegistrationDeskListArg) ![]RegistrationDesk {
// Require at least one parameter to be provided
if args.name == '' && args.description == '' {
return error('At least one filter parameter must be provided')
}
// Get all registration desks from the database
all_desks := self.db.list[RegistrationDesk]()!.map(self.get(it)!)
// Apply filters
mut filtered_desks := []RegistrationDesk{}
for desk in all_desks {
// Filter by name if provided
if args.name != '' && desk.name != args.name {
continue
}
// Filter by description if provided
if args.description != '' && !desk.description.contains(args.description) {
continue
}
filtered_desks << desk
}
// Limit results to 100 or the specified limit
mut limit := args.limit
if limit > 100 {
limit = 100
}
if filtered_desks.len > limit {
return filtered_desks[..limit]
}
return filtered_desks
}

388
lib/hero/heromodels/registration_desk_test.v Normal file
View File

@@ -0,0 +1,388 @@
module heromodels
import freeflowuniverse.herolib.hero.db
import freeflowuniverse.herolib.data.ourtime
fn test_registration_desk_new() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Test creating a new registration desk
mut args := RegistrationDeskArg{
name: "test_registration_desk"
description: "Test registration desk for unit testing"
fs_items: [u32(1001), u32(1002)]
white_list: [u32(2001), u32(2002), u32(2003)]
white_list_accepted: [u32(3001)]
black_list: [u32(4001), u32(4002)]
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: true
securitypolicy: 0
tags: ["test", "registration"]
comments: []
}
registration_desk := db_registration_desk.new(args)!
assert registration_desk.name == "test_registration_desk"
assert registration_desk.description == "Test registration desk for unit testing"
assert registration_desk.fs_items == [u32(1001), u32(1002)]
assert registration_desk.white_list == [u32(2001), u32(2002), u32(2003)]
assert registration_desk.white_list_accepted == [u32(3001)]
assert registration_desk.black_list == [u32(4001), u32(4002)]
assert registration_desk.acceptance_required == true
assert registration_desk.registrations.len == 0
println("✓ RegistrationDesk new test passed!")
}
fn test_registration_desk_crud_operations() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a new registration desk
mut args := RegistrationDeskArg{
name: "crud_test_registration_desk"
description: "Test registration desk for CRUD operations"
fs_items: [u32(1001), u32(1002)]
white_list: [u32(2001), u32(2002)]
white_list_accepted: [u32(3001)]
black_list: [u32(4001)]
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: false
securitypolicy: 0
tags: ["crud", "test"]
comments: []
}
mut registration_desk := db_registration_desk.new(args)!
// Test set operation
registration_desk = db_registration_desk.set(registration_desk)!
original_id := registration_desk.id
// Test get operation
retrieved_desk := db_registration_desk.get(original_id)!
assert retrieved_desk.name == "crud_test_registration_desk"
assert retrieved_desk.description == "Test registration desk for CRUD operations"
assert retrieved_desk.fs_items == [u32(1001), u32(1002)]
assert retrieved_desk.white_list == [u32(2001), u32(2002)]
assert retrieved_desk.white_list_accepted == [u32(3001)]
assert retrieved_desk.black_list == [u32(4001)]
assert retrieved_desk.acceptance_required == false
assert retrieved_desk.id == original_id
// Test exist operation
exists := db_registration_desk.exist(original_id)!
assert exists == true
// Test update
mut updated_args := RegistrationDeskArg{
name: "updated_registration_desk"
description: "Updated test registration desk"
fs_items: [u32(1003)]
white_list: [u32(2003), u32(2004)]
white_list_accepted: [u32(3002)]
black_list: [u32(4002), u32(4003)]
start_time: "2025-01-01 12:00:00"
end_time: "2025-01-01 13:00:00"
acceptance_required: true
securitypolicy: 0
tags: ["updated", "test"]
comments: []
}
mut updated_desk := db_registration_desk.new(updated_args)!
updated_desk.id = original_id
updated_desk = db_registration_desk.set(updated_desk)!
// Verify update
final_desk := db_registration_desk.get(original_id)!
assert final_desk.name == "updated_registration_desk"
assert final_desk.description == "Updated test registration desk"
assert final_desk.fs_items == [u32(1003)]
assert final_desk.white_list == [u32(2003), u32(2004)]
assert final_desk.white_list_accepted == [u32(3002)]
assert final_desk.black_list == [u32(4002), u32(4003)]
assert final_desk.acceptance_required == true
// Test delete operation
db_registration_desk.delete(original_id)!
// Verify deletion
exists_after_delete := db_registration_desk.exist(original_id)!
assert exists_after_delete == false
println("✓ RegistrationDesk CRUD operations test passed!")
}
fn test_registration_desk_registrations_encoding_decoding() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a new registration desk
mut args := RegistrationDeskArg{
name: "registrations_test_desk"
description: "Test registration desk for registrations encoding/decoding"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: true
securitypolicy: 0
tags: []
comments: []
}
mut registration_desk := db_registration_desk.new(args)!
// Add some registrations manually
mut registration1 := Registration{
user_id: 100
accepted: true
accepted_by: 200
timestamp: 1234567890
timestamp_acceptation: 1234567900
}
mut registration2 := Registration{
user_id: 101
accepted: false
accepted_by: 0
timestamp: 1234567891
timestamp_acceptation: 0
}
registration_desk.registrations = [registration1, registration2]
// Save the registration desk
registration_desk = db_registration_desk.set(registration_desk)!
registration_desk_id := registration_desk.id
// Retrieve and verify all fields were properly encoded/decoded
retrieved_desk := db_registration_desk.get(registration_desk_id)!
assert retrieved_desk.registrations.len == 2
// Verify first registration details
assert retrieved_desk.registrations[0].user_id == 100
assert retrieved_desk.registrations[0].accepted == true
assert retrieved_desk.registrations[0].accepted_by == 200
assert retrieved_desk.registrations[0].timestamp == 1234567890
assert retrieved_desk.registrations[0].timestamp_acceptation == 1234567900
// Verify second registration details
assert retrieved_desk.registrations[1].user_id == 101
assert retrieved_desk.registrations[1].accepted == false
assert retrieved_desk.registrations[1].accepted_by == 0
assert retrieved_desk.registrations[1].timestamp == 1234567891
assert retrieved_desk.registrations[1].timestamp_acceptation == 0
println("✓ RegistrationDesk registrations encoding/decoding test passed!")
}
fn test_registration_desk_type_name() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a new registration desk
mut args := RegistrationDeskArg{
name: "type_test_desk"
description: "Test registration desk for type name"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: false
securitypolicy: 0
tags: []
comments: []
}
registration_desk := db_registration_desk.new(args)!
// Test type_name method
type_name := registration_desk.type_name()
assert type_name == "registration_desk"
println("✓ RegistrationDesk type_name test passed!")
}
fn test_registration_desk_description() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a new registration desk
mut args := RegistrationDeskArg{
name: "description_test_desk"
description: "Test registration desk for description"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: false
securitypolicy: 0
tags: []
comments: []
}
registration_desk := db_registration_desk.new(args)!
// Test description method for each methodname
assert registration_desk.description("set") == "Create or update a registration desk. Returns the ID of the registration desk."
assert registration_desk.description("get") == "Retrieve a registration desk by ID. Returns the registration desk object."
assert registration_desk.description("delete") == "Delete a registration desk by ID. Returns true if successful."
assert registration_desk.description("exist") == "Check if a registration desk exists by ID. Returns true or false."
assert registration_desk.description("list") == "List all registration desks. Returns an array of registration desk objects."
assert registration_desk.description("unknown") == "This is generic method for the root object, TODO fill in, ..."
println("✓ RegistrationDesk description test passed!")
}
fn test_registration_desk_example() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a new registration desk
mut args := RegistrationDeskArg{
name: "example_test_desk"
description: "Test registration desk for example"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: false
securitypolicy: 0
tags: []
comments: []
}
registration_desk := db_registration_desk.new(args)!
// Test example method for each methodname
set_call, set_result := registration_desk.example("set")
assert set_call == '{"registration_desk": {"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}}'
assert set_result == "1"
get_call, get_result := registration_desk.example("get")
assert get_call == '{"id": 1}'
assert get_result == '{"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}'
delete_call, delete_result := registration_desk.example("delete")
assert delete_call == '{"id": 1}'
assert delete_result == "true"
exist_call, exist_result := registration_desk.example("exist")
assert exist_call == '{"id": 1}'
assert exist_result == "true"
list_call, list_result := registration_desk.example("list")
assert list_call == '{}'
assert list_result == '[{"name": "event_registration", "description": "Registration desk for team meeting", "fs_items": [], "white_list": [], "white_list_accepted": [], "black_list": [], "start_time": 1672564800, "end_time": 1672568400, "acceptance_required": true, "registrations": []}]'
unknown_call, unknown_result := registration_desk.example("unknown")
assert unknown_call == '{}'
assert unknown_result == '{}'
println("✓ RegistrationDesk example test passed!")
}
fn test_registration_desk_list() ! {
// Initialize DBRegistrationDesk for testing
mut mydb := db.new_test()!
mut db_registration_desk := DBRegistrationDesk{
db: &mydb
}
// Create a few registration desks
mut args1 := RegistrationDeskArg{
name: "list_test_desk_1"
description: "First test registration desk for list operations"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: false
securitypolicy: 0
tags: []
comments: []
}
mut args2 := RegistrationDeskArg{
name: "list_test_desk_2"
description: "Second test registration desk for list operations"
fs_items: []
white_list: []
white_list_accepted: []
black_list: []
start_time: "2025-01-01 10:00:00"
end_time: "2025-01-01 11:00:00"
acceptance_required: true
securitypolicy: 0
tags: []
comments: []
}
mut desk1 := db_registration_desk.new(args1)!
mut desk2 := db_registration_desk.new(args2)!
// Save the registration desks
desk1 = db_registration_desk.set(desk1)!
desk2 = db_registration_desk.set(desk2)!
// Test list by name
mut listed_desks := db_registration_desk.list(RegistrationDeskListArg{
name: "list_test_desk_1"
})!
assert listed_desks.len == 1
assert listed_desks[0].name == "list_test_desk_1"
// Test list by description
listed_desks = db_registration_desk.list(RegistrationDeskListArg{
description: "test registration desk"
})!
assert listed_desks.len == 2
// Test list with limit
listed_desks = db_registration_desk.list(RegistrationDeskListArg{
description: "test registration desk"
limit: 1
})!
assert listed_desks.len == 1
println("✓ RegistrationDesk list test passed!")
}