Data Models Reference

Table of Contents

1. Overview
2. Core Event Models
3. Registration Models
4. Booth Configuration Models
5. Bundle Models
6. Filter and Request Models
7. Enumerations
8. Supporting Models
9. Validation Rules

Overview

This document provides comprehensive documentation of all data models used in the Engagifii Events API. Models are categorized by their primary function and include field specifications, relationships, and validation rules.

Core Event Models

EventViewModel

Complete event information for display purposes.

interface EventViewModel {
  id: string;                          // GUID - Unique event identifier
  name: string;                         // Max 500 chars - Event name
  description?: string;                 // Event description
  iconUrl?: string;                     // URL to event icon
  startDateTime: DateTime;              // ISO 8601 - Event start
  endDateTime: DateTime;                // ISO 8601 - Event end
  eventWithClass: boolean;              // Has class components
  eventWithExhibitor: boolean;          // Has exhibitor components
  eventStatus: string;                  // Status: Draft|Published|Cancelled|Completed
  eventRegistrationState?: string;      // Registration status
  isFavourite: boolean;                 // User marked as favorite
  
  // Event categorization
  eventTypeId?: number;                 // Event type reference
  eventType?: string;                   // Event type name
  
  // Location
  location?: LocationViewModel;         // Venue details
  
  // Contacts
  contacts?: {
    regular: EventContactViewModel[];   // Primary contacts
    finance: EventContactViewModel[];   // Finance contacts
    exhibitor: EventContactViewModel[]; // Exhibitor contacts
  };
  
  // Related entities
  eventClasses?: string[];              // Array of class GUIDs
  eventBundles?: string[];              // Array of bundle GUIDs
  eventDates?: EventSessionItemModel[]; // Session schedule
  
  // Pricing
  pricingFramework?: PricingFrameworkViewModel;
  isFreeEvent: boolean;
  defaultPrice?: number;                // Decimal(18,2)
  
  // Registration
  isRegistrationAllowed: boolean;
  registrationStartFrom?: DateTime;
  registrationEndDate?: DateTime;
  registrantsCapacity: number;          // Max attendees
  availableRegistrantsCapacity: number; // Remaining spots
  
  // Statistics
  registrantsCount: number;
  attendeesCount: number;
  exhibitorAttendeesCount: number;
  
  // Workflows
  registrationWorkflows?: EventRegistrationFlow[];
  
  // Access control
  blacklist?: BlacklistViewModel[];
  isGuestRegistrationEnabled: boolean;
}

EventEditModel

Model for creating or updating events.

interface EventEditModel {
  id?: string;                          // GUID - null for create
  name: string;                         // Required, max 500 chars
  description?: string;
  iconUrl?: string;
  
  // Timing
  startDateTime: DateTime;              // Required
  endDateTime: DateTime;                // Required, must be after start
  duration?: number;                    // Duration in minutes
  durationType?: string;                // Hour|Day|Week
  sessionType?: string;                 // Single|Multiple
  
  // Event type
  eventWithClass: boolean;
  eventWithExhibitor: boolean;
  eventTypeId?: number;
  
  // Sessions
  eventDates?: EventSessionItemModel[];
  
  // Location
  location?: {
    venueId?: string;
    roomIds?: string[];
  };
  
  // Contacts
  contacts?: {
    regular?: EventContactEditModel[];
    finance?: EventContactEditModel[];
    exhibitor?: EventContactEditModel[];
  };
  
  // Pricing
  isFreeEvent: boolean;
  defaultPrice?: number;                // Required if not free
  pricingFramework?: PricingFrameworkViewModel;
  
  // Registration
  isRegistrationOn: boolean;
  registrationStartFrom?: DateTime;
  registrationEndDate?: DateTime;
  registrantsCapacity?: number;         // Default: unlimited
  
  // Prerequisites
  eventPreRequisites?: string[];        // Event GUIDs
  awardPreRequisites?: string[];        // Award GUIDs
  coursePreRequisites?: string[];       // Course GUIDs
  
  // Guest settings
  isGuestRegistrationEnabled?: boolean;
  guestSettings?: EventGuestSettingsViewModel;
  
  // Exhibitor settings
  eventExhibitorModel?: EventExhibitorModel;
  
  // Files
  eventAgenda?: FileModel;
  
  // Access control
  blacklist?: BlacklistViewModel[];
}

LocationViewModel

Venue and location information.

interface LocationViewModel {
  venueId?: string;                     // GUID
  venueName?: string;
  address?: string;
  address2?: string;
  city?: string;
  state?: string;
  country?: string;
  zipCode?: string;
  latitude?: number;
  longitude?: number;
  rooms?: MeetingRoomViewModel[];
  timeZone?: string;                    // IANA timezone
}

Registration Models

MemberEventRegistrationViewModel

Complete registration details.

interface MemberEventRegistrationViewModel {
  id?: string;                          // GUID
  memberId?: string;                    // GUID - Member reference
  exhibitorId?: string;                 // GUID - Exhibitor reference
  eventId: string;                      // GUID - Required
  
  // Registration info
  registrationNumber?: string;          // Unique registration ID
  peopleRegistrationNumber?: string;    // People system reference
  registrationType: EventRegistrationType;
  exhibitorRegistrationType?: ExhibitorRegistrationType;
  registeredOn?: DateTime;
  registrationStatus: EventRegistrationStatus;
  
  // Participant info
  fullName?: string;
  firstName?: string;
  lastName?: string;
  middleName?: string;
  email?: string;
  phone?: string;
  organization?: string;
  title?: string;
  
  // Group management
  groupId?: string;                     // GUID
  groupNumber?: string;
  groupNumberIndex?: number;
  
  // Workflow
  registrationWorkflowId?: number;
  roleId?: number;
  currentStep?: string;
  approvalId?: number;
  stepsStatus?: string;
  
  // Financial
  invoiceDetail?: InvoiceView;
  paymentStatus?: string;
  
  // Items
  bundles?: EventBundleViewModel[];
  sessions?: EventActivityViewModel[];
  booths?: EventExhibitorBoothConfigurationViewModel[];
  boothStaffs?: EventExhibitorBoothStaffViewModel[];
  
  // Metadata
  isActive: boolean;
  isDeleted: boolean;
  isRegModified: boolean;
  modificationCount?: number;
  notifyMe: boolean;
  
  // Audit
  createdOn: DateTime;
  createdBy?: string;
  modifiedOn?: DateTime;
  modifiedBy?: string;
  registeredBy?: RegisteredBy;
}

AllEventRegistrationViewModel

Registration list view model with summary information.

interface AllEventRegistrationViewModel {
  id?: string;                          // Registration GUID
  memberId?: string;
  fullName: string;
  email?: string;
  organization?: string;
  
  // Registration details
  registrationNumber: string;
  registrationType: string;
  registrationStatus: string;
  registrationStatusByPayment?: string;
  registeredOn: DateTime;
  
  // Event info
  eventId: string;
  eventName: string;
  eventStartDate: DateTime;
  
  // Group info
  groupId?: string;
  groupNumber?: string;
  
  // Summary counts
  bundleCount?: number;
  sessionCount?: number;
  boothCount?: number;
  
  // Financial summary
  totalAmount?: number;
  paidAmount?: number;
  outstandingAmount?: number;
  
  // Status flags
  requiresApproval: boolean;
  isWaitlisted: boolean;
  isCancelled: boolean;
}

Booth Configuration Models

EventExhibitorBoothConfigurationViewModel

Booth configuration details.

interface EventExhibitorBoothConfigurationViewModel {
  id?: string;                          // GUID
  boothName: string;                    // Required, unique per event
  eventId: string;                      // GUID - Required
  
  // Booth type
  boothTypeId?: string;                 // GUID
  boothType?: string;                   // Type name
  
  // Dimensions
  length: number;                       // Decimal(18,2) - meters
  width: number;                        // Decimal(18,2) - meters
  area?: number;                        // Calculated: length * width
  
  // Capacity
  staffCapacity: number;                // Max staff allowed
  
  // Assignment
  assignedType: AssignedType;           // None|Person|Organization
  assignedToId?: string;                // GUID
  assignedTo?: AssignedToViewModel;
  buyer?: BuyerViewModel;
  
  // Pricing
  defaultPrice: number;                 // Decimal(18,2)
  price?: number;                       // Override price
  isPriceOverride: boolean;
  
  // Status
  status: EventExhibitorBoothStatus;    // PreAssigned|Available|Sold
  
  // Location
  floor?: string;
  hall?: string;
  markerAnnotation?: string;            // Map coordinates JSON
  
  // Flags
  isActive: boolean;
  isDeleted: boolean;
  isDuplicate: boolean;
  
  // Metadata
  createdOn?: DateTime;
  modifiedOn?: DateTime;
}

EventExhibitorBoothConfigurationEditModel

Model for creating/updating booth configurations.

interface EventExhibitorBoothConfigurationEditModel {
  id?: string;                          // null for create
  boothName: string;                    // Required
  eventId: string;                      // Required
  boothTypeId: string;                  // Required
  
  // Dimensions
  length: number;                       // Required, > 0
  width: number;                        // Required, > 0
  
  // Assignment
  assignedType: AssignedType;
  assignedToId?: string;                // Required if assignedType != None
  
  // Capacity & Pricing
  staffCapacity: number;                // Required, > 0
  defaultPrice: number;                 // Required, >= 0
  
  // Status
  isActive?: boolean;                   // Default: true
  isDeleted?: boolean;                  // Default: false
}

Bundle Models

EventBundleViewModel

Bundle configuration for events.

interface EventBundleViewModel {
  id?: string;                          // GUID
  bundleName: string;                   // Required
  eventId: string;                      // GUID - Required
  description?: string;
  iconUrl?: string;
  
  // Pricing
  defaultPrice: number;                 // Decimal(18,2)
  
  // Configuration
  isDefault: boolean;                   // Auto-selected
  isEnabled: boolean;                   // Available for selection
  maxUnit: number;                      // Max quantity per registration
  sequence: number;                     // Display order
  
  // Items
  items?: {
    sessions?: string[];                // Session GUIDs
    activities?: string[];              // Activity GUIDs
    classes?: string[];                 // Class GUIDs
    inclusions?: string[];              // Text descriptions
  };
  
  // Visibility
  isDefaultVisibility: boolean;
  visibilityRules?: VisibilityRules;
  
  // Statistics
  registrationCount?: number;
  availableUnits?: number;
}

BundleItemConfiguration

Individual items within a bundle.

interface BundleItemConfiguration {
  id?: string;                          // GUID
  bundleId: string;                     // GUID - Required
  itemType: BundleItemType;             // Session|Activity|Class|Inclusion
  itemId?: string;                      // GUID for entity items
  itemName?: string;                    // Name/description
  quantity: number;                     // Default: 1
  price?: number;                       // Item price
  isMandatory: boolean;                 // Required item
  sequence: number;                     // Display order
}

Filter and Request Models

ListViewRequest<TFilter>

Generic paginated request wrapper.

interface ListViewRequest<TFilter> {
  filter: TFilter;                      // Filter criteria
  pageNumber: number;                   // Starting from 1
  pageSize: number;                     // Max 100
  sortBy?: string;                      // Field name
  sortOrder?: 'ASC' | 'DESC';          // Default: ASC
}

ListViewResult<TData>

Generic paginated response wrapper.

interface ListViewResult<TData> {
  data: TData[];                        // Result items
  totalCount: number;                   // Total items matching filter
  pageNumber: number;                   // Current page
  pageSize: number;                     // Items per page
  totalPages?: number;                  // Calculated total pages
  hasNextPage?: boolean;                // More results available
  hasPreviousPage?: boolean;            // Previous page exists
}

EventListFilterModel

Filter criteria for event listings.

interface EventListFilterModel {
  // Text search
  searchText?: string;                  // Search in name, description
  
  // Date filters
  startDateFrom?: DateTime;
  startDateTo?: DateTime;
  endDateFrom?: DateTime;
  endDateTo?: DateTime;
  
  // Type filters
  eventTypeIds?: number[];
  tags?: string[];
  
  // Status filters
  eventStatus?: string[];                // Draft|Published|Cancelled
  onlyUpcoming?: boolean;
  onlyPast?: boolean;
  
  // Feature filters
  withExhibitor?: boolean;
  withClass?: boolean;
  isFreeEvent?: boolean;
  
  // Registration filters
  isRegistrationOpen?: boolean;
  hasAvailableSpots?: boolean;
  
  // Location filters
  venueIds?: string[];
  cities?: string[];
  states?: string[];
  countries?: string[];
  
  // Favorites
  onlyFavorites?: boolean;
}

EventRegistrantFilterModel

Filter criteria for registration searches.

interface EventRegistrantFilterModel {
  eventId?: string;                     // GUID
  
  // Registration filters
  registrationType?: EventRegistrationType;
  registrationStatus?: EventRegistrationStatus[];
  registrationDateFrom?: DateTime;
  registrationDateTo?: DateTime;
  
  // Participant filters
  searchText?: string;                  // Name, email, registration number
  personIds?: string[];
  organizationIds?: string[];
  parentOrgIds?: string[];
  personType?: number[];
  titles?: string[];
  
  // Item filters
  bundleIds?: string[];
  sessionIds?: string[];
  classIds?: string[];
  boothIds?: string[];
  
  // Financial filters
  invoiceNumber?: string;
  paymentStatus?: string[];
  
  // Group filters
  groupIds?: string[];
  
  // Exhibitor filters
  exhibitorIds?: string[];
  boothAssignmentStatus?: string[];
  
  // Include options
  includeDeleted?: boolean;
  includeCancelled?: boolean;
  allParticipants?: boolean;
}

Enumerations

EventRegistrationStatus

enum EventRegistrationStatus {
  InProgress = 1,              // Registration started
  ApprovalPending = 2,         // Awaiting approval
  EligibleButApprovalPending = 3, // Eligible, needs approval
  ApprovalDenied = 4,          // Rejected
  ApprovalComplete = 5,        // Approved
  Cancelled = 6,               // Cancelled
  BoothAssignmentPending = 7   // Awaiting booth assignment
}

EventRegistrationType

enum EventRegistrationType {
  All = 0,                     // All types
  Member = 1,                  // Member registration
  Exhibitor = 2                // Exhibitor registration
}

ExhibitorRegistrationType

enum ExhibitorRegistrationType {
  None = 0,                    // Not exhibitor
  Direct = 1,                  // Direct purchase
  Preference = 2,              // Submit preferences
  AssignBooth = 3              // Manual assignment
}

EventExhibitorBoothStatus

enum EventExhibitorBoothStatus {
  PreAssigned = 1,             // Reserved
  Available = 2,               // Open for booking
  Sold = 3                     // Assigned
}

AssignedType

enum AssignedType {
  None = 0,                    // Not assigned
  Person = 1,                  // Assigned to individual
  Organization = 2             // Assigned to company
}

BundleItemType

enum BundleItemType {
  Session = 1,                 // Session/activity
  Activity = 2,                // Workshop/activity
  Class = 3,                   // Educational class
  Inclusion = 4,               // Other items (meals, materials)
  Accommodation = 5            // Hotel/lodging
}

Supporting Models

InvoiceView

Invoice information for registrations.

interface InvoiceView {
  invoiceId?: string;                   // GUID
  invoiceNumber?: string;                // Unique invoice number
  invoiceDate?: DateTime;
  dueDate?: DateTime;
  
  // Amounts
  subtotal: number;                     // Decimal(18,2)
  tax: number;                           // Decimal(18,2)
  discount: number;                      // Decimal(18,2)
  totalAmount: number;                   // Decimal(18,2)
  paidAmount: number;                    // Decimal(18,2)
  balanceDue: number;                    // Decimal(18,2)
  
  // Status
  status: string;                        // Draft|Sent|Paid|Overdue|Cancelled
  paymentStatus: string;                 // Pending|Partial|Paid
  
  // Line items
  items?: InvoiceItemView[];
}

PricingFrameworkViewModel

Event pricing configuration.

interface PricingFrameworkViewModel {
  defaultPrice: number;                  // Base price
  
  // Early bird
  earlyBirdPrice?: number;
  earlyBirdEndDate?: DateTime;
  
  // Group discounts
  groupDiscounts?: {
    minQuantity: number;
    discountPercent: number;
    discountAmount?: number;
  }[];
  
  // Member pricing
  memberPrice?: number;
  nonMemberPrice?: number;
  
  // Dynamic pricing
  tiers?: {
    name: string;
    price: number;
    startDate?: DateTime;
    endDate?: DateTime;
    maxQuantity?: number;
  }[];
  
  // Promo codes
  promoCodes?: {
    code: string;
    discountType: 'Percentage' | 'Amount';
    discountValue: number;
    validFrom?: DateTime;
    validTo?: DateTime;
    maxUses?: number;
  }[];
}

FileModel

File attachment information.

interface FileModel {
  id?: string;                          // GUID
  fileName: string;
  fileUrl: string;
  fileSize?: number;                    // Bytes
  mimeType?: string;
  uploadedOn?: DateTime;
  uploadedBy?: string;
}

EventContactViewModel

Contact person information.

interface EventContactViewModel {
  id?: string;                          // GUID
  contactTypeId: number;
  contactType?: string;                 // Primary|Finance|Exhibitor|Support
  name: string;                          // Required
  title?: string;
  email?: string;                        // Required for most types
  phone?: string;
  mobile?: string;
  isPrimary: boolean;
}

ApprovalWorkflowStepsClientView

Approval workflow configuration.

interface ApprovalWorkflowStepsClientView {
  workflowId: number;
  workflowName: string;
  steps: {
    stepId: number;
    stepName: string;
    approverType: 'User' | 'Role' | 'Manager';
    approvers: string[];               // User IDs or role names
    isParallel: boolean;               // Multiple approvers simultaneously
    isMandatory: boolean;
    sequence: number;
  }[];
  currentStep?: number;
  completedSteps?: number[];
}

Validation Rules

Common Validation Rules

Field Type	Rules
GUID	Valid UUID v4 format
Email	Valid email format, max 254 chars
Phone	E.164 format or local format with country code
URL	Valid HTTP/HTTPS URL, max 2048 chars
Date/Time	ISO 8601 format, future dates for events
Currency	Decimal(18,2), non-negative for prices
Percentage	0-100, decimal allowed
Count/Capacity	Integer, non-negative, max varies by field

Field-Specific Validations

Event Fields

Field	Validation
name	Required, 1-500 chars, unique per tenant
startDateTime	Required, must be future date for new events
endDateTime	Required, must be after startDateTime
registrantsCapacity	Optional, if set must be > 0
defaultPrice	Required if not free event, >= 0

Registration Fields

Field	Validation
eventId	Required, must exist and be active
memberId	Required for member registration
exhibitorId	Required for exhibitor registration
bundleIds	At least one if event has bundles

Booth Fields

Field	Validation
boothName	Required, unique per event
length	Required, > 0, max 100
width	Required, > 0, max 100
staffCapacity	Required, 1-50
defaultPrice	Required, >= 0

Business Rule Validations

1. Event Dates: End date must be after start date
2. Registration Window: Registration end must be before event start
3. Capacity: Cannot reduce capacity below current registrations
4. Booth Assignment: Can only assign to registered exhibitors
5. Bundle Items: Cannot remove bundles with existing registrations
6. Approval Workflow: Cannot skip mandatory approval steps
7. Group Registration: Group size cannot exceed event capacity
8. Pricing: Member price must be less than or equal to non-member price
9. Prerequisites: Prerequisite events must be completed before registration
10. Cancellation: Cannot cancel events with active registrations without confirmation

Model Relationships

Entity Relationship Diagram

erDiagram
    Event ||--o{ MemberEventRegistration : has
    Event ||--o{ EventBundle : contains
    Event ||--o{ EventActivity : includes
    Event ||--o{ EventExhibitorBoothConfiguration : offers
    
    MemberEventRegistration ||--o{ MemberEventRegistrationItem : contains
    MemberEventRegistration }o--|| Member : registers
    MemberEventRegistration }o--|| Invoice : generates
    
    EventBundle ||--o{ BundleItemConfiguration : contains
    EventExhibitorBoothConfiguration }o--|| EventExhibitorBoothStaff : staffed_by
    
    Member ||--o{ Organization : belongs_to
    Invoice ||--o{ InvoiceItem : contains
    Invoice }o--|| Payment : paid_by

Key Relationships

1. Event → Registration: One-to-many, cascade delete blocked
2. Registration → Bundle: Many-to-many through registration items
3. Registration → Invoice: One-to-one, optional
4. Booth → Staff: One-to-many, max per staffCapacity
5. Bundle → Items: One-to-many, ordered by sequence
6. Event → Prerequisites: Many-to-many self-reference
7. Registration → Approval: One-to-many approval history

JSON Schema Examples

Event Creation Request

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["name", "startDateTime", "endDateTime"],
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500
    },
    "startDateTime": {
      "type": "string",
      "format": "date-time"
    },
    "endDateTime": {
      "type": "string",
      "format": "date-time"
    },
    "defaultPrice": {
      "type": "number",
      "minimum": 0,
      "multipleOf": 0.01
    },
    "registrantsCapacity": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100000
    }
  }
}

Type Definitions

For TypeScript/JavaScript implementations:

// Install type definitions
npm install @engagifii/events-api-types

// Import types
import { 
  EventViewModel, 
  MemberEventRegistrationViewModel,
  EventExhibitorBoothConfigurationViewModel 
} from '@engagifii/events-api-types';

For C#/.NET implementations:

// Install NuGet package
Install-Package Engagifii.Events.Api.Models

// Use models
using Engagifii.Events.Api.Models;
using Engagifii.Events.Api.Models.ViewModels;
using Engagifii.Events.Api.Models.EditModels;