Krow/Krow-workspace
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

moving dataconnect to dev

Browse Source
This commit is contained in:
José Salazar
2026-01-19 19:18:11 -05:00
parent 6960e9e472
commit c5afbd99cd
147 changed files with 10531 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
backend/dataconnect/connector/account/mutations.gql Normal file
View File

@@ -0,0 +1,39 @@
mutation createAccount(
$bank: String!
$type: AccountType!
$last4: String!
$isPrimary: Boolean
$ownerId: UUID!
) @auth(level: USER) {
account_insert(
data: {
bank: $bank
type: $type
last4: $last4
isPrimary: $isPrimary
ownerId: $ownerId
}
)
}
mutation updateAccount(
$id: UUID!
$bank: String
$type: AccountType
$last4: String
$isPrimary: Boolean
) @auth(level: USER) {
account_update(
id: $id
data: {
bank: $bank
type: $type
last4: $last4
isPrimary: $isPrimary
}
)
}
mutation deleteAccount($id: UUID!) @auth(level: USER) {
account_delete(id: $id)
}

64
backend/dataconnect/connector/account/queries.gql Normal file
View File

@@ -0,0 +1,64 @@
query listAccounts @auth(level: USER) {
accounts {
id
bank
type
last4
isPrimary
ownerId
createdAt
updatedAt
createdBy
}
}
query getAccountById($id: UUID!) @auth(level: USER) {
account(id: $id) {
id
bank
type
last4
isPrimary
ownerId
createdAt
updatedAt
createdBy
}
}
query getAccountsByOwnerId($ownerId: UUID!) @auth(level: USER) {
accounts(where: { ownerId: { eq: $ownerId } }) {
id
bank
type
last4
isPrimary
ownerId
createdAt
updatedAt
createdBy
}
}
query filterAccounts(
$bank: String
$type: AccountType
$isPrimary: Boolean
$ownerId: UUID
) @auth(level: USER) {
accounts(
where: {
bank: { eq: $bank }
type: { eq: $type }
isPrimary: { eq: $isPrimary }
ownerId: { eq: $ownerId }
}
) {
id
bank
type
last4
isPrimary
ownerId
}
}

96
backend/dataconnect/connector/activityLog/mutations.gql Normal file
View File

@@ -0,0 +1,96 @@
mutation createActivityLog(
$userId: String!
$date: Timestamp!
$hourStart: String
$hourEnd: String
$totalhours: String
$iconType: ActivityIconType
$iconColor: String
$title: String!
$description: String!
$isRead: Boolean
$activityType: ActivityType!
) @auth(level: USER) {
activityLog_insert(
data: {
userId: $userId
date: $date
hourStart: $hourStart
hourEnd: $hourEnd
totalhours: $totalhours
iconType: $iconType
iconColor: $iconColor
title: $title
description: $description
isRead: $isRead
activityType: $activityType
}
)
}
mutation updateActivityLog(
$id: UUID!
$userId: String
$date: Timestamp
$hourStart: String
$hourEnd: String
$totalhours: String
$iconType: ActivityIconType
$iconColor: String
$title: String
$description: String
$isRead: Boolean
$activityType: ActivityType
) @auth(level: USER) {
activityLog_update(
id: $id
data: {
userId: $userId
date: $date
hourStart: $hourStart
hourEnd: $hourEnd
totalhours: $totalhours
iconType: $iconType
iconColor: $iconColor
title: $title
description: $description
isRead: $isRead
activityType: $activityType
}
)
}
# ----------------------------------------------------------
# MARK AS READ (single)
# ----------------------------------------------------------
mutation markActivityLogAsRead($id: UUID!) @auth(level: USER) {
activityLog_update(
id: $id
data: { isRead: true }
)
}
# ----------------------------------------------------------
# MARK MANY AS READ (correct op name in your DC)
# ----------------------------------------------------------
mutation markActivityLogsAsRead(
$ids: [UUID!]!
) @auth(level: USER) {
activityLog_updateMany(
where: { id: { in: $ids } }
data: { isRead: true }
)
}
mutation deleteActivityLog($id: UUID!) @auth(level: USER) {
activityLog_delete(id: $id)
}

175
backend/dataconnect/connector/activityLog/queries.gql Normal file
View File

@@ -0,0 +1,175 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listActivityLogs(
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(offset: $offset, limit: $limit) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getActivityLogById($id: UUID!) @auth(level: USER) {
activityLog(id: $id) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# LIST BY USER
# ----------------------------------------------------------
query listActivityLogsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: { userId: { eq: $userId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# LIST UNREAD BY USER (common for notifications UI)
# ----------------------------------------------------------
query listUnreadActivityLogsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: {
userId: { eq: $userId }
isRead: { eq: false }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# FILTER (user + date range + read status + type)
# NOTE: Timestamp filter uses ge/le (NOT gte/lte)
# ----------------------------------------------------------
query filterActivityLogs(
$userId: String
$dateFrom: Timestamp
$dateTo: Timestamp
$isRead: Boolean
$activityType: ActivityType
$iconType: ActivityIconType
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: {
userId: { eq: $userId }
date: { ge: $dateFrom, le: $dateTo }
isRead: { eq: $isRead }
activityType: { eq: $activityType }
iconType: { eq: $iconType }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}

47
backend/dataconnect/connector/application/mutations.gql Normal file
View File

@@ -0,0 +1,47 @@
mutation createApplication(
$shiftId: UUID!
$staffId: UUID!
$status: ApplicationStatus!
$checkInTime: Timestamp
$checkOutTime: Timestamp
$origin: ApplicationOrigin!
$roleId: UUID!
) @auth(level: USER) {
application_insert(
data: {
shiftId: $shiftId
staffId: $staffId
status: $status
checkInTime: $checkInTime
checkOutTime: $checkOutTime
origin: $origin
roleId: $roleId
}
)
}
mutation updateApplicationStatus(
$id: UUID!
$shiftId: UUID
$staffId: UUID
$status: ApplicationStatus
$checkInTime: Timestamp
$checkOutTime: Timestamp
$roleId: UUID!
) @auth(level: USER) {
application_update(
id: $id
data: {
shiftId: $shiftId
staffId: $staffId
status: $status
checkInTime: $checkInTime
checkOutTime: $checkOutTime
roleId: $roleId
}
)
}
mutation deleteApplication($id: UUID!) @auth(level: USER) {
application_delete(id: $id)
}

304
backend/dataconnect/connector/application/queries.gql Normal file
View File

@@ -0,0 +1,304 @@
query listApplications @auth(level: USER) {
applications {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationById($id: UUID!) @auth(level: USER) {
application(id: $id) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByShiftId($shiftId: UUID!) @auth(level: USER) {
applications(where: { shiftId: { eq: $shiftId } }) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByShiftIdAndStatus(
$shiftId: UUID!
$status: ApplicationStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: {
shiftId: { eq: $shiftId }
status: { eq: $status }
}
offset: $offset
limit: $limit
) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}

71
backend/dataconnect/connector/assignment/mutations.gql Normal file
View File

@@ -0,0 +1,71 @@
mutation CreateAssignment(
$workforceId: UUID!
$title: String
$description: String
$instructions: String
$status: AssignmentStatus
$tipsAvailable: Boolean
$travelTime: Boolean
$mealProvided: Boolean
$parkingAvailable: Boolean
$gasCompensation: Boolean
$managers: [Any!]
$roleId: UUID!
$shiftId: UUID!
) @auth(level: USER) {
assignment_insert(
data: {
workforceId: $workforceId
title: $title
description: $description
instructions: $instructions
status: $status
tipsAvailable: $tipsAvailable
travelTime: $travelTime
mealProvided: $mealProvided
parkingAvailable: $parkingAvailable
gasCompensation: $gasCompensation
managers: $managers
roleId: $roleId
shiftId: $shiftId
}
)
}
mutation UpdateAssignment(
$id: UUID!
$title: String
$description: String
$instructions: String
$status: AssignmentStatus
$tipsAvailable: Boolean
$travelTime: Boolean
$mealProvided: Boolean
$parkingAvailable: Boolean
$gasCompensation: Boolean
$managers: [Any!]
$roleId: UUID!
$shiftId: UUID!
) @auth(level: USER) {
assignment_update(
id: $id
data: {
title: $title
description: $description
instructions: $instructions
status: $status
tipsAvailable: $tipsAvailable
travelTime: $travelTime
mealProvided: $mealProvided
parkingAvailable: $parkingAvailable
gasCompensation: $gasCompensation
managers: $managers
roleId: $roleId
shiftId: $shiftId
}
)
}
mutation DeleteAssignment($id: UUID!) @auth(level: USER) {
assignment_delete(id: $id)
}

278
backend/dataconnect/connector/assignment/queries.gql Normal file
View File

@@ -0,0 +1,278 @@
# ------------------------------------------------------------
# LIST ALL ASSIGNMENTS (admin/debug)
# ------------------------------------------------------------
query listAssignments(
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(offset: $offset, limit: $limit) {
id
title
status
createdAt
workforce {
id
workforceNumber
staff { id fullName }
}
shiftRole {
id
count
assigned
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
location
locationAddress
latitude
longitude
status
order {
id
eventName
business { id businessName email contactName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# GET ASSIGNMENT BY ID
# ------------------------------------------------------------
query getAssignmentById($id: UUID!) @auth(level: USER) {
assignment(id: $id) {
id
title
description
instructions
status
tipsAvailable
travelTime
mealProvided
parkingAvailable
gasCompensation
managers
createdAt
updatedAt
createdBy
workforce {
id
workforceNumber
status
staff { id fullName }
}
shiftRole {
id
startTime
endTime
hours
totalValue
breakType
uniform
department
role { id name costPerHour }
shift {
id
title
date
location
locationAddress
latitude
longitude
status
managers
order {
id
eventName
orderType
business { id businessName email contactName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# MY ASSIGNMENTS (by workforceId) - Staff view
# ------------------------------------------------------------
query listAssignmentsByWorkforceId(
$workforceId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: { workforceId: { eq: $workforceId } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
title
status
createdAt
workforce {
id
workforceNumber
staff { id fullName }
}
shiftRole {
id
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
location
status
order {
id
eventName
business { id businessName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# ASSIGNMENTS FOR A VENDOR (Vendor dashboard)
# Approach: filter by workforce.vendorId (relation)
# If Data Connect can't filter nested, use 2-step:
# 1) listWorkforceByVendorId => workforce ids
# 2) assignments(where: { workforceId: { in: [...] } })
# ------------------------------------------------------------
query listAssignmentsByWorkforceIds(
$workforceIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: { workforceId: { in: $workforceIds } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
shiftRole {
id
role { id name }
shift {
id
title
date
order {
id
eventName
business { id businessName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# ASSIGNMENTS BY SHIFT ROLE (useful for staffing)
# ------------------------------------------------------------
query listAssignmentsByShiftRole(
$shiftId: UUID!
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: {
shiftId: { eq: $shiftId }
roleId: { eq: $roleId }
}
offset: $offset
limit: $limit
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
}
}
# ------------------------------------------------------------
# FILTER ASSIGNMENTS (status + date range)
# Date range is based on Shift.date through the relation (NOT filterable directly).
#
# Since ShiftRole uses a composite key (shiftId + roleId),
# Assignments must be filtered using BOTH fields.
#
# So the filtering flow is:
# 1) Get Shifts in the date range => shiftIds
# 2) Get ShiftRoles where shiftId IN shiftIds => (shiftId, roleId) pairs
# 3) Get Assignments where:
# - shiftId matches
# - roleId matches
# - status matches (optional)
#
# This query represents step 3.
# ------------------------------------------------------------
query filterAssignments(
$shiftIds: [UUID!]!
$roleIds: [UUID!]!
$status: AssignmentStatus
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: {
shiftId: { in: $shiftIds }
roleId: { in: $roleIds }
status: { eq: $status }
}
offset: $offset
limit: $limit
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
shiftRole {
id
role { id name }
shift { id title date location status }
}
}
}

45
backend/dataconnect/connector/attireOption/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation createAttireOption(
$itemId: String!
$label: String!
$icon: String
$imageUrl: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOption_insert(
data: {
itemId: $itemId
label: $label
icon: $icon
imageUrl: $imageUrl
isMandatory: $isMandatory
vendorId: $vendorId
}
)
}
mutation updateAttireOption(
$id: UUID!
$itemId: String
$label: String
$icon: String
$imageUrl: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOption_update(
id: $id
data: {
itemId: $itemId
label: $label
icon: $icon
imageUrl: $imageUrl
isMandatory: $isMandatory
vendorId: $vendorId
}
)
}
mutation deleteAttireOption($id: UUID!) @auth(level: USER) {
attireOption_delete(id: $id)
}

47
backend/dataconnect/connector/attireOption/queries.gql Normal file
View File

@@ -0,0 +1,47 @@
query listAttireOptions @auth(level: USER) {
attireOptions {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
createdAt
}
}
query getAttireOptionById($id: UUID!) @auth(level: USER) {
attireOption(id: $id) {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
createdAt
}
}
query filterAttireOptions(
$itemId: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOptions(
where: {
itemId: { eq: $itemId }
isMandatory: { eq: $isMandatory }
vendorId: { eq: $vendorId }
}
) {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
}
}

36
backend/dataconnect/connector/benefitsData/mutations.gql Normal file
View File

@@ -0,0 +1,36 @@
mutation createBenefitsData(
$vendorBenefitPlanId: UUID!
$staffId: UUID!
$current: Int!
) @auth(level: USER) {
benefitsData_insert(
data: {
vendorBenefitPlanId: $vendorBenefitPlanId
staffId: $staffId
current: $current
}
)
}
mutation updateBenefitsData(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
$current: Int
) @auth(level: USER) {
benefitsData_update(
key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }
data: {
current: $current
}
)
}
mutation deleteBenefitsData(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
) @auth(level: USER) {
benefitsData_delete(
key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }
)
}

165
backend/dataconnect/connector/benefitsData/queries.gql Normal file
View File

@@ -0,0 +1,165 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listBenefitsData(
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(offset: $offset, limit: $limit) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# GET BY KEY (staffId + vendorBenefitPlanId) ✅ (replaces getById in practice)
# ----------------------------------------------------------
query getBenefitsDataByKey(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
) @auth(level: USER) {
benefitsData(key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY STAFF
# ----------------------------------------------------------
query listBenefitsDataByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR BENEFIT PLAN
# ----------------------------------------------------------
query listBenefitsDataByVendorBenefitPlanId(
$vendorBenefitPlanId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { vendorBenefitPlanId: { eq: $vendorBenefitPlanId } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR (2-step helper: planIds -> benefitsDatas IN)
# ----------------------------------------------------------
query listBenefitsDataByVendorBenefitPlanIds(
$vendorBenefitPlanIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { vendorBenefitPlanId: { in: $vendorBenefitPlanIds } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}

75
backend/dataconnect/connector/business/mutations.gql Normal file
View File

@@ -0,0 +1,75 @@
mutation createBusiness(
$businessName: String!,
$contactName: String,
$userId: String!,
$companyLogoUrl: String,
$phone: String,
$email: String,
$hubBuilding: String,
$address: String,
$city: String,
$area: BusinessArea,
$sector: BusinessSector,
$rateGroup: BusinessRateGroup!,
$status: BusinessStatus!,
$notes: String
) @auth(level: USER) {
business_insert(
data: {
businessName: $businessName,
contactName: $contactName,
userId: $userId,
companyLogoUrl: $companyLogoUrl,
phone: $phone,
email: $email,
hubBuilding: $hubBuilding,
address: $address,
city: $city,
area: $area,
sector: $sector,
rateGroup: $rateGroup,
status: $status,
notes: $notes
}
)
}
mutation updateBusiness(
$id: UUID!,
$businessName: String,
$contactName: String,
$companyLogoUrl: String,
$phone: String,
$email: String,
$hubBuilding: String,
$address: String,
$city: String,
$area: BusinessArea,
$sector: BusinessSector,
$rateGroup: BusinessRateGroup,
$status: BusinessStatus,
$notes: String
) @auth(level: USER) {
business_update(
id: $id,
data: {
businessName: $businessName,
contactName: $contactName,
companyLogoUrl: $companyLogoUrl,
phone: $phone,
email: $email,
hubBuilding: $hubBuilding,
address: $address,
city: $city,
area: $area,
sector: $sector,
rateGroup: $rateGroup,
status: $status,
notes: $notes
}
)
}
mutation deleteBusiness($id: UUID!) @auth(level: USER) {
business_delete(id: $id)
}

65
backend/dataconnect/connector/business/queries.gql Normal file
View File

@@ -0,0 +1,65 @@
query listBusinesses @auth(level: USER) {
businesses {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}
query getBusinessesByUserId($userId: String!) @auth(level: USER) {
businesses(where: { userId: { eq: $userId } }) {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}
query getBusinessById($id: UUID!) @auth(level: USER) {
business(id: $id) {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}

34
backend/dataconnect/connector/category/mutations.gql Normal file
View File

@@ -0,0 +1,34 @@
mutation createCategory(
$categoryId: String!
$label: String!
$icon: String
) @auth(level: USER) {
category_insert(
data: {
categoryId: $categoryId
label: $label
icon: $icon
}
)
}
mutation updateCategory(
$id: UUID!
$categoryId: String
$label: String
$icon: String
) @auth(level: USER) {
category_update(
id: $id
data: {
categoryId: $categoryId
label: $label
icon: $icon
}
)
}
mutation deleteCategory($id: UUID!) @auth(level: USER) {
category_delete(id: $id)
}

43
backend/dataconnect/connector/category/queries.gql Normal file
View File

@@ -0,0 +1,43 @@
query listCategories @auth(level: USER) {
categories {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}
query getCategoryById($id: UUID!) @auth(level: USER) {
category(id: $id) {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}
query filterCategories(
$categoryId: String
$label: String
) @auth(level: USER) {
categories(
where: {
categoryId: { eq: $categoryId }
label: { eq: $label }
}
) {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}

65
backend/dataconnect/connector/certificate/mutations.gql Normal file
View File

@@ -0,0 +1,65 @@
mutation CreateCertificate(
$name: String!
$description: String
$expiry: Timestamp
$status: CertificateStatus!
$fileUrl: String
$icon: String
$certificationType: ComplianceType
$issuer: String
$staffId: UUID!
$validationStatus: ValidationStatus
$certificateNumber: String
) @auth(level: USER) {
certificate_insert(
data: {
name: $name
description: $description
expiry: $expiry
status: $status
fileUrl: $fileUrl
icon: $icon
staffId: $staffId
certificationType: $certificationType
issuer: $issuer
validationStatus: $validationStatus
certificateNumber: $certificateNumber
}
)
}
mutation UpdateCertificate(
$id: UUID!
$name: String
$description: String
$expiry: Timestamp
$status: CertificateStatus
$fileUrl: String
$icon: String
$staffId: UUID
$certificationType: ComplianceType
$issuer: String
$validationStatus: ValidationStatus
$certificateNumber: String
) @auth(level: USER) {
certificate_update(
id: $id
data: {
name: $name
description: $description
expiry: $expiry
status: $status
fileUrl: $fileUrl
icon: $icon
staffId: $staffId
certificationType: $certificationType
issuer: $issuer
validationStatus: $validationStatus
certificateNumber: $certificateNumber
}
)
}
mutation DeleteCertificate($id: UUID!) @auth(level: USER) {
certificate_delete(id: $id)
}

72
backend/dataconnect/connector/certificate/queries.gql Normal file
View File

@@ -0,0 +1,72 @@
query listCertificates @auth(level: USER) {
certificates {
id
name
description
expiry
status
fileUrl
icon
staffId
certificationType
issuer
validationStatus
certificateNumber
createdAt
staff {
id
fullName
}
}
}
query getCertificateById($id: UUID!) @auth(level: USER) {
certificate(id: $id) {
id
name
description
expiry
status
fileUrl
icon
certificationType
issuer
staffId
validationStatus
certificateNumber
updatedAt
staff {
id
fullName
}
}
}
query listCertificatesByStaffId($staffId: UUID!) @auth(level: USER) {
certificates(where: { staffId: { eq: $staffId } }) {
id
name
description
expiry
status
fileUrl
icon
staffId
certificationType
issuer
validationStatus
certificateNumber
createdAt
staff {
id
fullName
}
}
}

43
backend/dataconnect/connector/clientFeedback/mutations.gql Normal file
View File

@@ -0,0 +1,43 @@
mutation createClientFeedback(
$businessId: UUID!
$vendorId: UUID!
$rating: Int
$comment: String
$date: Timestamp
$createdBy: String
) @auth(level: USER) {
clientFeedback_insert(
data: {
businessId: $businessId
vendorId: $vendorId
rating: $rating
comment: $comment
date: $date
}
)
}
mutation updateClientFeedback(
$id: UUID!
$businessId: UUID
$vendorId: UUID
$rating: Int
$comment: String
$date: Timestamp
$createdBy: String
) @auth(level: USER) {
clientFeedback_update(
id: $id
data: {
businessId: $businessId
vendorId: $vendorId
rating: $rating
comment: $comment
date: $date
}
)
}
mutation deleteClientFeedback($id: UUID!) @auth(level: USER) {
clientFeedback_delete(id: $id)
}

185
backend/dataconnect/connector/clientFeedback/queries.gql Normal file
View File

@@ -0,0 +1,185 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listClientFeedbacks(
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(offset: $offset, limit: $limit) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getClientFeedbackById($id: UUID!) @auth(level: USER) {
clientFeedback(id: $id) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS
# ----------------------------------------------------------
query listClientFeedbacksByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY VENDOR
# ----------------------------------------------------------
query listClientFeedbacksByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS + VENDOR (pair)
# ----------------------------------------------------------
query listClientFeedbacksByBusinessAndVendor(
$businessId: UUID!
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: {
businessId: { eq: $businessId }
vendorId: { eq: $vendorId }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# FILTER (rating + date range)
# NOTE: using Timestamp ops: ge/le
# ----------------------------------------------------------
query filterClientFeedbacks(
$businessId: UUID
$vendorId: UUID
$ratingMin: Int
$ratingMax: Int
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: {
businessId: { eq: $businessId }
vendorId: { eq: $vendorId }
rating: { ge: $ratingMin, le: $ratingMax }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# QUICK KPI: average rating for a vendor (client-side aggregate)
# You fetch rows; Flutter/web computes avg.
# ----------------------------------------------------------
query listClientFeedbackRatingsByVendorId(
$vendorId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
) @auth(level: USER) {
clientFeedbacks(
where: {
vendorId: { eq: $vendorId }
date: { ge: $dateFrom, le: $dateTo }
}
orderBy: { date: DESC }
) {
id
rating
comment
date
business { id businessName }
vendor { id companyName }
}
}

7
backend/dataconnect/connector/connector.yaml Normal file
View File

@@ -0,0 +1,7 @@
connectorId: example
generate:
dartSdk:
- outputDir: ../../mobile/staff/staff_app_mvp/lib/dataconnect_generated
package: dataconnect_generated/generated.dart
- outputDir: ../../mobile/client/client_app_mvp/lib/dataconnect_generated
package: dataconnect_generated/generated.dart

35
backend/dataconnect/connector/contact/mutations.gql Normal file
View File

@@ -0,0 +1,35 @@
mutation createEmergencyContact(
$name: String!
$phone: String!
$relationship: RelationshipType!
$staffId: UUID!
) @auth(level: USER) {
emergencyContact_insert(
data: {
name: $name
phone: $phone
relationship: $relationship
staffId: $staffId
}
)
}
mutation updateEmergencyContact(
$id: UUID!
$name: String
$phone: String
$relationship: RelationshipType
) @auth(level: USER) {
emergencyContact_update(
id: $id
data: {
name: $name
phone: $phone
relationship: $relationship
}
)
}
mutation deleteEmergencyContact($id: UUID!) @auth(level: USER) {
emergencyContact_delete(id: $id)
}

38
backend/dataconnect/connector/contact/queries.gql Normal file
View File

@@ -0,0 +1,38 @@
query listEmergencyContacts @auth(level: USER) {
emergencyContacts {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}
query getEmergencyContactById($id: UUID!) @auth(level: USER) {
emergencyContact(id: $id) {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}
query getEmergencyContactsByStaffId($staffId: UUID!) @auth(level: USER) {
emergencyContacts(where: { staffId: { eq: $staffId } }) {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}

69
backend/dataconnect/connector/conversation/mutations.gql Normal file
View File

@@ -0,0 +1,69 @@
mutation createConversation(
$subject: String
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$groupName: String
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_insert(
data: {
subject: $subject
status: $status
conversationType: $conversationType
isGroup: $isGroup
groupName: $groupName
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
mutation updateConversation(
$id: UUID!
$subject: String
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$groupName: String
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_update(
id: $id
data: {
subject: $subject
status: $status
conversationType: $conversationType
isGroup: $isGroup
groupName: $groupName
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
# ----------------------------------------------------------
# UPDATE LAST MESSAGE
# ----------------------------------------------------------
mutation updateConversationLastMessage(
$id: UUID!
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_update(
id: $id
data: {
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
mutation deleteConversation($id: UUID!) @auth(level: USER) {
conversation_delete(id: $id)
}

125
backend/dataconnect/connector/conversation/queries.gql Normal file
View File

@@ -0,0 +1,125 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listConversations(
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(offset: $offset, limit: $limit, orderBy: { updatedAt: DESC }) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getConversationById($id: UUID!) @auth(level: USER) {
conversation(id: $id) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# LIST BY TYPE (CLIENT_VENDOR / GROUP_STAFF)
# ----------------------------------------------------------
query listConversationsByType(
$conversationType: ConversationType!
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: { conversationType: { eq: $conversationType } }
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# LIST BY STATUS (ACTIVE)
# ----------------------------------------------------------
query listConversationsByStatus(
$status: ConversationStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# FILTER (dashboard/debug)
# Supports searching by multiple optional fields
# ----------------------------------------------------------
query filterConversations(
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$lastMessageAfter: Timestamp
$lastMessageBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: {
status: { eq: $status }
conversationType: { eq: $conversationType }
isGroup: { eq: $isGroup }
lastMessageAt: { ge: $lastMessageAfter, le: $lastMessageBefore }
}
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}

53
backend/dataconnect/connector/course/mutations.gql Normal file
View File

@@ -0,0 +1,53 @@
mutation createCourse(
$title: String
$description: String
$thumbnailUrl: String
$durationMinutes: Int
$xpReward: Int
$categoryId: UUID!
$levelRequired: String
$isCertification: Boolean
) @auth(level: USER) {
course_insert(
data: {
title: $title
description: $description
thumbnailUrl: $thumbnailUrl
durationMinutes: $durationMinutes
xpReward: $xpReward
categoryId: $categoryId
levelRequired: $levelRequired
isCertification: $isCertification
}
)
}
mutation updateCourse(
$id: UUID!
$title: String
$description: String
$thumbnailUrl: String
$durationMinutes: Int
$xpReward: Int
$categoryId: UUID!
$levelRequired: String
$isCertification: Boolean
) @auth(level: USER) {
course_update(
id: $id
data: {
title: $title
description: $description
thumbnailUrl: $thumbnailUrl
durationMinutes: $durationMinutes
xpReward: $xpReward
categoryId: $categoryId
levelRequired: $levelRequired
isCertification: $isCertification
}
)
}
mutation deleteCourse($id: UUID!) @auth(level: USER) {
course_delete(id: $id)
}

68
backend/dataconnect/connector/course/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
query listCourses @auth(level: USER) {
courses {
id
title
description
thumbnailUrl
durationMinutes
xpReward
categoryId
levelRequired
isCertification
createdAt
category{
id
label
}
}
}
query getCourseById($id: UUID!) @auth(level: USER) {
course(id: $id) {
id
title
description
thumbnailUrl
durationMinutes
xpReward
categoryId
levelRequired
isCertification
createdAt
category{
id
label
}
}
}
query filterCourses(
$categoryId: UUID
$isCertification: Boolean
$levelRequired: String
$completed: Boolean
) @auth(level: USER) {
courses(
where: {
categoryId: { eq: $categoryId }
isCertification: { eq: $isCertification }
levelRequired: { eq: $levelRequired }
}
) {
id
title
categoryId
levelRequired
isCertification
category{
id
label
}
}
}

37
backend/dataconnect/connector/customRateCard/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createCustomRateCard(
$name: String!,
$baseBook: String,
$discount: Float,
$isDefault: Boolean
) @auth(level: USER) {
customRateCard_insert(
data: {
name: $name,
baseBook: $baseBook,
discount: $discount,
isDefault: $isDefault
}
)
}
mutation updateCustomRateCard(
$id: UUID!,
$name: String,
$baseBook: String,
$discount: Float,
$isDefault: Boolean
) @auth(level: USER) {
customRateCard_update(
id: $id,
data: {
name: $name,
baseBook: $baseBook,
discount: $discount,
isDefault: $isDefault
}
)
}
mutation deleteCustomRateCard($id: UUID!) @auth(level: USER) {
customRateCard_delete(id: $id)
}

23
backend/dataconnect/connector/customRateCard/queries.gql Normal file
View File

@@ -0,0 +1,23 @@
query listCustomRateCards @auth(level: USER) {
customRateCards {
id
name
baseBook
discount
isDefault
createdAt
updatedAt
}
}
query getCustomRateCardById($id: UUID!) @auth(level: USER) {
customRateCard(id: $id) {
id
name
baseBook
discount
isDefault
createdAt
updatedAt
}
}

33
backend/dataconnect/connector/document/mutations.gql Normal file
View File

@@ -0,0 +1,33 @@
mutation createDocument(
$documentType: DocumentType!
$name: String!
$description: String
) @auth(level: USER) {
document_insert(
data: {
documentType: $documentType
name: $name
description: $description
}
)
}
mutation updateDocument(
$id: UUID!
$documentType: DocumentType
$name: String
$description: String
) @auth(level: USER) {
document_update(
id: $id
data: {
documentType: $documentType
name: $name
description: $description
}
)
}
mutation deleteDocument($id: UUID!) @auth(level: USER) {
document_delete(id: $id)
}

35
backend/dataconnect/connector/document/queries.gql Normal file
View File

@@ -0,0 +1,35 @@
query listDocuments @auth(level: USER) {
documents {
id
documentType
name
description
createdAt
}
}
query getDocumentById($id: UUID!) @auth(level: USER) {
document(id: $id) {
id
documentType
name
description
createdAt
}
}
query filterDocuments(
$documentType: DocumentType
) @auth(level: USER) {
documents(
where: {
documentType: { eq: $documentType }
}
) {
id
documentType
name
description
createdAt
}
}

29
backend/dataconnect/connector/faqData/mutations.gql Normal file
View File

@@ -0,0 +1,29 @@
mutation createFaqData(
$category: String!
$questions: [Any!]
) @auth(level: USER) {
faqData_insert(
data: {
category: $category
questions: $questions
}
)
}
mutation updateFaqData(
$id: UUID!
$category: String
$questions: [Any!]
) @auth(level: USER) {
faqData_update(
id: $id
data: {
category: $category
questions: $questions
}
)
}
mutation deleteFaqData($id: UUID!) @auth(level: USER) {
faqData_delete(id: $id)
}

29
backend/dataconnect/connector/faqData/queries.gql Normal file
View File

@@ -0,0 +1,29 @@
query listFaqDatas @auth(level: USER) {
faqDatas {
id
category
questions
createdAt
updatedAt
createdBy
}
}
query getFaqDataById($id: UUID!) @auth(level: USER) {
faqData(id: $id) {
id
category
questions
createdAt
updatedAt
createdBy
}
}
query filterFaqDatas($category: String) @auth(level: USER) {
faqDatas(where: { category: { eq: $category } }) {
id
category
questions
}
}

41
backend/dataconnect/connector/hub/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createHub(
$name: String!
$locationName: String
$address: String
$nfcTagId: String
$ownerId: UUID!
) @auth(level: USER) {
hub_insert(
data: {
name: $name
locationName: $locationName
address: $address
nfcTagId: $nfcTagId
ownerId: $ownerId
}
)
}
mutation updateHub(
$id: UUID!
$name: String
$locationName: String
$address: String
$nfcTagId: String
$ownerId: UUID
) @auth(level: USER) {
hub_update(
id: $id
data: {
name: $name
locationName: $locationName
address: $address
nfcTagId: $nfcTagId
ownerId: $ownerId
}
)
}
mutation deleteHub($id: UUID!) @auth(level: USER) {
hub_delete(id: $id)
}

62
backend/dataconnect/connector/hub/queries.gql Normal file
View File

@@ -0,0 +1,62 @@
query listHubs @auth(level: USER) {
hubs {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query getHubById($id: UUID!) @auth(level: USER) {
hub(id: $id) {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query getHubsByOwnerId($ownerId: UUID!) @auth(level: USER) {
hubs(where: { ownerId: { eq: $ownerId } }) {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query filterHubs(
$ownerId: UUID
$name: String
$nfcTagId: String
) @auth(level: USER) {
hubs(
where: {
ownerId: { eq: $ownerId }
name: { eq: $name }
nfcTagId: { eq: $nfcTagId }
}
) {
id
name
locationName
address
nfcTagId
ownerId
}
}

123
backend/dataconnect/connector/invoice/mutations.gql Normal file
View File

@@ -0,0 +1,123 @@
mutation createInvoice(
$status: InvoiceStatus!
$vendorId: UUID!
$businessId: UUID!
$orderId: UUID!
$paymentTerms: InovicePaymentTerms
$invoiceNumber: String!
$issueDate: Timestamp!
$dueDate: Timestamp!
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float!
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoice_insert(
data: {
status: $status
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation updateInvoice(
$id: UUID!
$status: InvoiceStatus
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTerms
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
$disputedItems: Any
$disputeReason: String
$disputeDetails: String
) @auth(level: USER) {
invoice_update(
id: $id
data: {
status: $status
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
disputedItems: $disputedItems
disputeReason: $disputeReason
disputeDetails: $disputeDetails
}
)
}
mutation deleteInvoice($id: UUID!) @auth(level: USER) {
invoice_delete(id: $id)
}

520
backend/dataconnect/connector/invoice/queries.gql Normal file
View File

@@ -0,0 +1,520 @@
# ------------------------------------------------------------
# LIST ALL INVOICES (admin/debug)
# ------------------------------------------------------------
query listInvoices(
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(offset: $offset, limit: $limit) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# GET INVOICE BY ID
# ------------------------------------------------------------
query getInvoiceById($id: UUID!) @auth(level: USER) {
invoice(id: $id) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY VENDOR
# ------------------------------------------------------------
query listInvoicesByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY BUSINESS
# ------------------------------------------------------------
query listInvoicesByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY ORDER
# ------------------------------------------------------------
query listInvoicesByOrderId(
$orderId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { orderId: { eq: $orderId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY STATUS
# ------------------------------------------------------------
query listInvoicesByStatus(
$status: InvoiceStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { dueDate: ASC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# FILTER INVOICES (multi filters)
# NOTE: Timestamp filters use ge/le (NOT gte/lte)
# ------------------------------------------------------------
query filterInvoices(
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$status: InvoiceStatus
$issueDateFrom: Timestamp
$issueDateTo: Timestamp
$dueDateFrom: Timestamp
$dueDateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: {
vendorId: { eq: $vendorId }
businessId: { eq: $businessId }
orderId: { eq: $orderId }
status: { eq: $status }
issueDate: { ge: $issueDateFrom, le: $issueDateTo }
dueDate: { ge: $dueDateFrom, le: $dueDateTo }
}
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# OVERDUE INVOICES (dueDate < now and not PAID)
# NOTE: request.time works in @default; for filters, pass $now from client
# ------------------------------------------------------------
query listOverdueInvoices(
$now: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: {
dueDate: { lt: $now }
status: { ne: PAID }
}
offset: $offset
limit: $limit
orderBy: { dueDate: ASC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}

115
backend/dataconnect/connector/invoiceTemplate/mutations.gql Normal file
View File

@@ -0,0 +1,115 @@
mutation createInvoiceTemplate(
$name: String!
$ownerId: UUID!
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTermsTemp
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoiceTemplate_insert(
data: {
name: $name
ownerId: $ownerId
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation updateInvoiceTemplate(
$id: UUID!
$name: String
$ownerId: UUID
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTermsTemp
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoiceTemplate_update(
id: $id
data: {
name: $name
ownerId: $ownerId
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation deleteInvoiceTemplate($id: UUID!) @auth(level: USER) {
invoiceTemplate_delete(id: $id)
}

325
backend/dataconnect/connector/invoiceTemplate/queries.gql Normal file
View File

@@ -0,0 +1,325 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listInvoiceTemplates(
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(offset: $offset, limit: $limit) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getInvoiceTemplateById($id: UUID!) @auth(level: USER) {
invoiceTemplate(id: $id) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY OWNER (my templates)
# ----------------------------------------------------------
query listInvoiceTemplatesByOwnerId(
$ownerId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { ownerId: { eq: $ownerId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY VENDOR (templates tied to a vendor)
# ----------------------------------------------------------
query listInvoiceTemplatesByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS (templates tied to a business)
# ----------------------------------------------------------
query listInvoiceTemplatesByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY ORDER (templates tied to a specific order)
# ----------------------------------------------------------
query listInvoiceTemplatesByOrderId(
$orderId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { orderId: { eq: $orderId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# SEARCH (by name) within an owner
# ----------------------------------------------------------
query searchInvoiceTemplatesByOwnerAndName(
$ownerId: UUID!
$name: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: {
ownerId: { eq: $ownerId }
name: { eq: $name }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}

37
backend/dataconnect/connector/level/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createLevel(
$name: String!
$xpRequired: Int!
$icon: String
$colors: Any
) @auth(level: USER) {
level_insert(
data: {
name: $name
xpRequired: $xpRequired
icon: $icon
colors: $colors
}
)
}
mutation updateLevel(
$id: UUID!
$name: String
$xpRequired: Int
$icon: String
$colors: Any
) @auth(level: USER) {
level_update(
id: $id
data: {
name: $name
xpRequired: $xpRequired
icon: $icon
colors: $colors
}
)
}
mutation deleteLevel($id: UUID!) @auth(level: USER) {
level_delete(id: $id)
}

44
backend/dataconnect/connector/level/queries.gql Normal file
View File

@@ -0,0 +1,44 @@
query listLevels @auth(level: USER) {
levels {
id
name
xpRequired
icon
colors
createdAt
updatedAt
createdBy
}
}
query getLevelById($id: UUID!) @auth(level: USER) {
level(id: $id) {
id
name
xpRequired
icon
colors
createdAt
updatedAt
createdBy
}
}
query filterLevels(
$name: String
$xpRequired: Int
) @auth(level: USER) {
levels(
where: {
name: { eq: $name }
xpRequired: { eq: $xpRequired }
}
) {
id
name
xpRequired
icon
colors
}
}

21
backend/dataconnect/connector/memberTask/mutations.gql Normal file
View File

@@ -0,0 +1,21 @@
mutation createMemberTask(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask_insert(
data: {
teamMemberId: $teamMemberId
taskId: $taskId
}
)
}
mutation deleteMemberTask(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask_delete(
key: { teamMemberId: $teamMemberId, taskId: $taskId }
)
}

77
backend/dataconnect/connector/memberTask/queries.gql Normal file
View File

@@ -0,0 +1,77 @@
query getMyTasks($teamMemberId: UUID!) @auth(level: USER) {
memberTasks(where: { teamMemberId: { eq: $teamMemberId } }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}
#before named getMemberTaskByIdKey
query getMemberTaskByIdKey(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask(key: { teamMemberId: $teamMemberId, taskId: $taskId }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}
query getMemberTasksByTaskId($taskId: UUID!) @auth(level: USER) {
memberTasks(where: { taskId: { eq: $taskId } }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}

37
backend/dataconnect/connector/message/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createMessage(
$conversationId: UUID!,
$senderId: String!,
$content: String!,
$isSystem: Boolean
) @auth(level: USER) {
message_insert(
data: {
conversationId: $conversationId,
senderId: $senderId,
content: $content,
isSystem: $isSystem
}
)
}
mutation updateMessage(
$id: UUID!,
$conversationId: UUID,
$senderId: String,
$content: String,
$isSystem: Boolean
) @auth(level: USER) {
message_update(
id: $id,
data: {
conversationId: $conversationId,
senderId: $senderId,
content: $content,
isSystem: $isSystem
}
)
}
mutation deleteMessage($id: UUID!) @auth(level: USER) {
message_delete(id: $id)
}

41
backend/dataconnect/connector/message/queries.gql Normal file
View File

@@ -0,0 +1,41 @@
query listMessages @auth(level: USER) {
messages {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}
query getMessageById($id: UUID!) @auth(level: USER) {
message(id: $id) {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}
query getMessagesByConversationId($conversationId: UUID!) @auth(level: USER) {
messages(where: { conversationId: { eq: $conversationId } }) {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}

98
backend/dataconnect/connector/order/mutations.gql Normal file
View File

@@ -0,0 +1,98 @@
mutation createOrder(
$vendorId: UUID!
$businessId: UUID!
$orderType: OrderType!
$location: String
$status: OrderStatus
$date: Timestamp
$startDate: Timestamp
$endDate: Timestamp
$duration: OrderDuration
$lunchBreak: Int
$total: Float
$eventName: String
$assignedStaff: Any
$shifts: Any
$requested: Int
$hub: String
$recurringDays: Any
$permanentStartDate: Timestamp
$permanentDays: Any
$notes: String
$detectedConflicts: Any
$poReference: String
) @auth(level: USER) {
order_insert(
data: {
vendorId: $vendorId
businessId: $businessId
orderType: $orderType
location: $location
status: $status
date: $date
startDate: $startDate
endDate: $endDate
duration: $duration
lunchBreak: $lunchBreak
total: $total
eventName: $eventName
assignedStaff: $assignedStaff
shifts: $shifts
requested: $requested
hub: $hub
recurringDays: $recurringDays
permanentDays: $permanentDays
notes: $notes
detectedConflicts: $detectedConflicts
poReference: $poReference
}
)
}
mutation updateOrder(
$id: UUID!
$vendorId: UUID
$businessId: UUID
$location: String
$status: OrderStatus
$startDate: Timestamp
$endDate: Timestamp
$total: Float
$eventName: String
$assignedStaff: Any
$shifts: Any
$requested: Int
$hub: String
$recurringDays: Any
$permanentDays: Any
$notes: String
$detectedConflicts: Any
$poReference: String
) @auth(level: USER) {
order_update(
id: $id
data: {
vendorId: $vendorId
businessId: $businessId
location: $location
status: $status
startDate: $startDate
endDate: $endDate
total: $total
eventName: $eventName
assignedStaff: $assignedStaff
shifts: $shifts
requested: $requested
hub: $hub
recurringDays: $recurringDays
permanentDays: $permanentDays
notes: $notes
detectedConflicts: $detectedConflicts
poReference: $poReference
}
)
}
mutation deleteOrder($id: UUID!) @auth(level: USER) {
order_delete(id: $id)
}

352
backend/dataconnect/connector/order/queries.gql Normal file
View File

@@ -0,0 +1,352 @@
# ------------------------------------------------------------
# LIST ALL ORDERS
# ------------------------------------------------------------
query listOrders(
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(offset: $offset, limit: $limit) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDER BY ID
# ------------------------------------------------------------
query getOrderById($id: UUID!) @auth(level: USER) {
order(id: $id) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY BUSINESS
# ------------------------------------------------------------
query getOrdersByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY VENDOR
# ------------------------------------------------------------
query getOrdersByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY STATUS
# ------------------------------------------------------------
query getOrdersByStatus(
$status: OrderStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY DATE RANGE
# ------------------------------------------------------------
query getOrdersByDateRange(
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: {
date: { ge: $start, le: $end }
}
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET RAPID ORDERS
# ------------------------------------------------------------
query getRapidOrders(
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { orderType: { eq: RAPID } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}

41
backend/dataconnect/connector/recentPayment/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createRecentPayment(
$workedTime: String
$status: RecentPaymentStatus
$staffId: UUID!
$applicationId: UUID!
$invoiceId: UUID!
) @auth(level: USER) {
recentPayment_insert(
data: {
workedTime: $workedTime
status: $status
staffId: $staffId
applicationId: $applicationId
invoiceId: $invoiceId
}
)
}
mutation updateRecentPayment(
$id: UUID!
$workedTime: String
$status: RecentPaymentStatus
$staffId: UUID
$applicationId: UUID
$invoiceId: UUID
) @auth(level: USER) {
recentPayment_update(
id: $id
data: {
workedTime: $workedTime
status: $status
staffId: $staffId
applicationId: $applicationId
invoiceId: $invoiceId
}
)
}
mutation deleteRecentPayment($id: UUID!) @auth(level: USER) {
recentPayment_delete(id: $id)
}

350
backend/dataconnect/connector/recentPayment/queries.gql Normal file
View File

@@ -0,0 +1,350 @@
# ------------------------------------------------------------
# LIST ALL (admin/debug)
# ------------------------------------------------------------
query listRecentPayments(
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(offset: $offset, limit: $limit) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
checkInTime
checkOutTime
shiftRole {
hours
totalValue
startTime
endTime
role {
name
costPerHour
}
shift {
title
date
location
locationAddress
description
}
}
}
invoice {
status
invoiceNumber
issueDate
business { id businessName }
vendor { id companyName }
order { id eventName }
}
}
}
# ------------------------------------------------------------
# GET BY ID
# ------------------------------------------------------------
query getRecentPaymentById($id: UUID!) @auth(level: USER) {
recentPayment(id: $id) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
checkInTime
checkOutTime
shiftRole {
hours
totalValue
startTime
endTime
role {
name
costPerHour
}
shift {
title
date
location
locationAddress
description
}
}
}
invoice {
status
invoiceNumber
issueDate
business { id businessName }
vendor { id companyName }
order { id eventName }
}
}
}
# ------------------------------------------------------------
# LIST BY STAFF (Staff view)
# ------------------------------------------------------------
query listRecentPaymentsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
status
shiftRole {
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
locationAddress
}
}
}
invoice {
id
invoiceNumber
status
issueDate
dueDate
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# LIST BY APPLICATION (debug / trace)
# ------------------------------------------------------------
query listRecentPaymentsByApplicationId(
$applicationId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { applicationId: { eq: $applicationId } }
offset: $offset
limit: $limit
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
status
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# LIST BY INVOICE (Vendor/Business can see all payments for invoice)
# ------------------------------------------------------------
query listRecentPaymentsByInvoiceId(
$invoiceId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { invoiceId: { eq: $invoiceId } }
offset: $offset
limit: $limit
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
staffId
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# FILTER BY STATUS (common)
# ------------------------------------------------------------
query listRecentPaymentsByStatus(
$status: RecentPaymentStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# BY BUSINESS (2-step)
# Step 2: pass invoiceIds (from query: listInvoicesByBusinessId)
# ------------------------------------------------------------
query listRecentPaymentsByInvoiceIds(
$invoiceIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { invoiceId: { in: $invoiceIds } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}

455
backend/dataconnect/connector/reports/queries.gql Normal file
View File

@@ -0,0 +1,455 @@
# ==========================================================
# Reports Connector - For MVP
# ==========================================================
# This file exposes SOURCE-DATA queries for all report screens.
# All aggregation (group by day/week, percentages, averages)
# is intentionally done on the client (Flutter).
#
# Entities used:
# - Shift
# - Application
# - Staff
# - Invoice
# - TimeSheet
#
# NOTE:
# Data Connect does NOT support custom root resolvers.
# These queries return raw rows from @table entities.
# ==========================================================
# ==========================================================
# 1) COVERAGE REPORT (Next 7 days)
# ==========================================================
# Coverage definition:
# - Needed: sum(Shift.workersNeeded) grouped by date
# - Confirmed: count(Application) where status IN (...)
#
# Client groups by Shift.date and calculates:
# coveragePercentage = confirmed / needed * 100
# ==========================================================
query listShiftsForCoverage(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
filled
status
}
}
#I comment here because I have an error en sdk
query listApplicationsForCoverage(
$shiftIds: [UUID!]!
#$statuses: [ApplicationStatus!]!
) @auth(level: USER) {
applications(
where: {
shiftId: { in: $shiftIds }
#status: { in: $statuses }
}
) {
id
shiftId
staffId
status
}
}
# ==========================================================
# 2) DAILY OPS REPORT (Single day)
# ==========================================================
# Metrics derived on client:
# - scheduledShifts = shifts.length
# - workersConfirmed = confirmedApps / totalNeeded
# - inProgressShifts = status == IN_PROGRESS
# - completedShifts = status == COMPLETED
# ==========================================================
query listShiftsForDailyOpsByBusiness(
$businessId: UUID!
$date: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { eq: $date }
}
orderBy: { startTime: ASC }
) {
id
title
location
startTime
endTime
workersNeeded
filled
status
}
}
query listShiftsForDailyOpsByVendor(
$vendorId: UUID!
$date: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { eq: $date }
}
orderBy: { startTime: ASC }
) {
id
title
location
startTime
endTime
workersNeeded
filled
status
}
}
query listApplicationsForDailyOps(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
checkInTime
checkOutTime
}
}
# ==========================================================
# 3) FORECAST REPORT (Next N weeks)
# ==========================================================
# Projected spend formula (client):
# projectedCost = workersNeeded * hours * hourlyRate
# ==========================================================
query listShiftsForForecastByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
hours
cost
status
}
}
query listShiftsForForecastByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
hours
cost
status
}
}
# ==========================================================
# 4) NO-SHOW REPORT (Historical range)
# ==========================================================
# Now fully supported because ApplicationStatus includes NO_SHOW.
#
# Metrics:
# - totalNoShows = count(status == NO_SHOW)
# - noShowRate = noShows / totalApplications
# - breakdown by staff
# ==========================================================
query listShiftsForNoShowRangeByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
) {
id
date
}
}
query listShiftsForNoShowRangeByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
}
) {
id
date
}
}
query listApplicationsForNoShowRange(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
}
}
query listStaffForNoShowReport(
$staffIds: [UUID!]!
) @auth(level: USER) {
staffs(where: { id: { in: $staffIds } }) {
id
fullName
noShowCount
reliabilityScore
}
}
# ==========================================================
# 5) SPEND REPORT (Financial)
# ==========================================================
# Uses Invoice as source of truth for money.
# Filter is now based on:
# - businessId (business dashboard)
# - vendorId (vendor dashboard)
# since Invoice no longer has ownerId.
# ==========================================================
query listInvoicesForSpendByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
businessId: { eq: $businessId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
query listInvoicesForSpendByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
vendorId: { eq: $vendorId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
# Optional: Spend by Order (if you need it)
query listInvoicesForSpendByOrder(
$orderId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
orderId: { eq: $orderId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
query listTimesheetsForSpend(
$startTime: Timestamp!
$endTime: Timestamp!
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
date: { ge: $startTime, le: $endTime }
}
}
) {
id
hours
totalValue
shift{
title
location
status
date
order{
business{
businessName
}
}
}
role{
costPerHour
}
}
}
# ==========================================================
# 6) PERFORMANCE REPORT (Historical KPIs)
# ==========================================================
# Metrics derivable:
# - fillRate
# - completionRate
# - onTimeRate
# - avgFillTimeHours (NOW POSSIBLE 🎉)
#
# avgFillTimeHours formula:
# (filledAt - createdAt) averaged across FILLED shifts
# ==========================================================
query listShiftsForPerformanceByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
filledAt: { isNull: false }
}
) {
id
workersNeeded
filled
status
createdAt
filledAt
}
}
query listShiftsForPerformanceByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
filledAt: { isNull: false }
}
) {
id
workersNeeded
filled
status
createdAt
filledAt
}
}
query listApplicationsForPerformance(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
checkInTime
checkOutTime
}
}
query listStaffForPerformance(
$staffIds: [UUID!]!
) @auth(level: USER) {
staffs(where: { id: { in: $staffIds } }) {
id
averageRating
onTimeRate
noShowCount
reliabilityScore
}
}

39
backend/dataconnect/connector/requiredDoc/mutations.gql Normal file
View File

@@ -0,0 +1,39 @@
mutation createRequiredDoc(
$name: String!
$description: String
$status: ReqDocumentStatus
$staffId: UUID!
$fileUrl: String
) @auth(level: USER) {
requiredDoc_insert(
data: {
name: $name
description: $description
status: $status
staffId: $staffId
fileUrl: $fileUrl
}
)
}
mutation updateRequiredDoc(
$id: UUID!
$name: String
$description: String
$status: ReqDocumentStatus
$fileUrl: String
) @auth(level: USER) {
requiredDoc_update(
id: $id
data: {
name: $name
description: $description
status: $status
fileUrl: $fileUrl
}
)
}
mutation deleteRequiredDoc($id: UUID!) @auth(level: USER) {
requiredDoc_delete(id: $id)
}

61
backend/dataconnect/connector/requiredDoc/queries.gql Normal file
View File

@@ -0,0 +1,61 @@
query listRequiredDocs @auth(level: USER) {
requiredDocs {
id
name
description
status
staffId
fileUrl
createdAt
updatedAt
createdBy
}
}
query getRequiredDocById($id: UUID!) @auth(level: USER) {
requiredDoc(id: $id) {
id
name
description
status
staffId
fileUrl
createdAt
updatedAt
createdBy
}
}
query getRequiredDocsByStaffId($staffId: UUID!) @auth(level: USER) {
requiredDocs(where: { staffId: { eq: $staffId } }) {
id
name
description
status
staffId
fileUrl
createdAt
updatedAt
createdBy
}
}
query filterRequiredDocs(
$staffId: UUID
$status: ReqDocumentStatus
$name: String
) @auth(level: USER) {
requiredDocs(
where: {
staffId: { eq: $staffId }
status: { eq: $status }
name: { eq: $name }
}
) {
id
name
status
staffId
fileUrl
}
}

36
backend/dataconnect/connector/role/mutations.gql Normal file
View File

@@ -0,0 +1,36 @@
mutation createRole(
$name: String!
$costPerHour: Float!
$vendorId: UUID!
$roleCategoryId: UUID!
) @auth(level: USER) {
role_insert(
data: {
name: $name
costPerHour: $costPerHour
vendorId: $vendorId
roleCategoryId: $roleCategoryId
}
)
}
mutation updateRole(
$id: UUID!
$name: String
$costPerHour: Float
$roleCategoryId: UUID!
) @auth(level: USER) {
role_update(
id: $id
data: {
name: $name
costPerHour: $costPerHour
roleCategoryId: $roleCategoryId
}
)
}
mutation deleteRole($id: UUID!) @auth(level: USER) {
role_delete(id: $id)
}

43
backend/dataconnect/connector/role/queries.gql Normal file
View File

@@ -0,0 +1,43 @@
query listRoles @auth(level: USER) {
roles {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query getRoleById($id: UUID!) @auth(level: USER) {
role(id: $id) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query listRolesByVendorId($vendorId: UUID!) @auth(level: USER) {
roles(where: { vendorId: { eq: $vendorId } }) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query listRolesByroleCategoryId($roleCategoryId: UUID!) @auth(level: USER) {
roles(where: { roleCategoryId: { eq: $roleCategoryId } }) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}

29
backend/dataconnect/connector/roleCategory/mutations.gql Normal file
View File

@@ -0,0 +1,29 @@
mutation createRoleCategory(
$roleName: String!,
$category: RoleCategoryType!
) @auth(level: USER) {
roleCategory_insert(
data: {
roleName: $roleName,
category: $category
}
)
}
mutation updateRoleCategory(
$id: UUID!,
$roleName: String,
$category: RoleCategoryType
) @auth(level: USER) {
roleCategory_update(
id: $id,
data: {
roleName: $roleName,
category: $category
}
)
}
mutation deleteRoleCategory($id: UUID!) @auth(level: USER) {
roleCategory_delete(id: $id)
}

27
backend/dataconnect/connector/roleCategory/queries.gql Normal file
View File

@@ -0,0 +1,27 @@
query listRoleCategories @auth(level: USER) {
roleCategories {
id
roleName
category
createdAt
updatedAt
}
}
query getRoleCategoryById($id: UUID!) @auth(level: USER) {
roleCategory(id: $id) {
id
roleName
category
createdAt
updatedAt
}
}
query getRoleCategoriesByCategory($category: RoleCategoryType!) @auth(level: USER) {
roleCategories(where: { category: { eq: $category } }) {
id
roleName
category
}
}

114
backend/dataconnect/connector/shift/mutations.gql Normal file
View File

@@ -0,0 +1,114 @@
mutation createShift(
$title: String!
$orderId: UUID!
$date: Timestamp
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$cost: Float
$location: String
$locationAddress: String
$latitude: Float
$longitude: Float
$description: String
$status: ShiftStatus
$workersNeeded: Int
$filled: Int
$filledAt: Timestamp
$managers: [Any!]
$durationDays: Int
$createdBy: String
) @auth(level: USER) {
shift_insert(
data: {
title: $title
orderId: $orderId
date: $date
startTime: $startTime
endTime: $endTime
hours: $hours
cost: $cost
location: $location
locationAddress: $locationAddress
latitude: $latitude
longitude: $longitude
description: $description
status: $status
workersNeeded: $workersNeeded
filled: $filled
filledAt: $filledAt
managers: $managers
durationDays: $durationDays
}
)
}
mutation updateShift(
$id: UUID!
$title: String
$orderId: UUID
$date: Timestamp
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$cost: Float
$location: String
$locationAddress: String
$latitude: Float
$longitude: Float
$description: String
$status: ShiftStatus
$workersNeeded: Int
$filled: Int
$filledAt: Timestamp
$managers: [Any!]
$durationDays: Int
) @auth(level: USER) {
shift_update(
id: $id
data: {
title: $title
orderId: $orderId
date: $date
startTime: $startTime
endTime: $endTime
hours: $hours
cost: $cost
location: $location
locationAddress: $locationAddress
latitude: $latitude
longitude: $longitude
description: $description
status: $status
workersNeeded: $workersNeeded
filled: $filled
filledAt: $filledAt
managers: $managers
durationDays: $durationDays
}
)
}
mutation deleteShift($id: UUID!) @auth(level: USER) {
shift_delete(id: $id)
}

282
backend/dataconnect/connector/shift/queries.gql Normal file
View File

@@ -0,0 +1,282 @@
# ------------------------------------------------------------
# LIST SHIFTS (paginated)
# ------------------------------------------------------------
query listShifts(
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(offset: $offset, limit: $limit) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# GET SHIFT BY ID
# ------------------------------------------------------------
query getShiftById($id: UUID!) @auth(level: USER) {
shift(id: $id) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# FILTER SHIFTS (by status/orderId/date range)
# NOTE: Timestamp filters use ge/le (not gte/lte)
# ------------------------------------------------------------
query filterShifts(
$status: ShiftStatus
$orderId: UUID
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
status: { eq: $status }
orderId: { eq: $orderId }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# BUSINESS: GET SHIFTS FOR A BUSINESS (via order.businessId)
# ------------------------------------------------------------
query getShiftsByBusinessId(
$businessId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# VENDOR: GET SHIFTS FOR A VENDOR (via order.vendorId)
# ------------------------------------------------------------
query getShiftsByVendorId(
$vendorId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}

65
backend/dataconnect/connector/shiftRole/mutations.gql Normal file
View File

@@ -0,0 +1,65 @@
mutation createShiftRole(
$shiftId: UUID!
$roleId: UUID!
$count: Int!
$assigned: Int
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$department: String
$uniform: String
$breakType: BreakDuration
$totalValue: Float
) @auth(level: USER) {
shiftRole_insert(
data: {
shiftId: $shiftId
roleId: $roleId
count: $count
assigned: $assigned
startTime: $startTime
endTime: $endTime
hours: $hours
department: $department
uniform: $uniform
breakType: $breakType
totalValue: $totalValue
}
)
}
mutation updateShiftRole(
$shiftId: UUID!
$roleId: UUID!
$count: Int
$assigned: Int
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$department: String
$uniform: String
$breakType: BreakDuration
$totalValue: Float
) @auth(level: USER) {
shiftRole_update(
key: { shiftId: $shiftId, roleId: $roleId }
data: {
count: $count
assigned: $assigned
startTime: $startTime
endTime: $endTime
hours: $hours
department: $department
uniform: $uniform
breakType: $breakType
totalValue: $totalValue
}
)
}
mutation deleteShiftRole(
$shiftId: UUID!
$roleId: UUID!
) @auth(level: USER) {
shiftRole_delete(key: { shiftId: $shiftId, roleId: $roleId })
}

227
backend/dataconnect/connector/shiftRole/queries.gql Normal file
View File

@@ -0,0 +1,227 @@
query getShiftRoleById(
$shiftId: UUID!
$roleId: UUID!
) @auth(level: USER) {
shiftRole(key: { shiftId: $shiftId, roleId: $roleId }) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByShiftId(
$shiftId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: { shiftId: { eq: $shiftId } }
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByRoleId(
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: { roleId: { eq: $roleId } }
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByShiftIdAndTimeRange(
$shiftId: UUID!
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shiftId: { eq: $shiftId }
startTime: { ge: $start }
endTime: { le: $end }
}
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}

184
backend/dataconnect/connector/staff/mutations.gql Normal file
View File

@@ -0,0 +1,184 @@
mutation CreateStaff(
$userId: String!
$fullName: String!
$level: String
$role: String
$phone: String
$email: String
$photoUrl: String
$totalShifts: Int
$averageRating: Float
$onTimeRate: Int
$noShowCount: Int
$cancellationCount: Int
$reliabilityScore: Int
$bio: String
#$skills: Any
$industries: Any
$preferredLocations: Any
$maxDistanceMiles: Int
$languages: Any
$itemsAttire: Any
$xp: Int
$badges: Any
$isRecommended: Boolean
$ownerId: UUID
$department: DepartmentType
$hubId: UUID
$manager: UUID
$english: EnglishProficiency
$backgroundCheckStatus: BackgroundCheckStatus
$employmentType: EmploymentType
$initial: String
$englishRequired: Boolean
$city: String
$addres: String
) @auth(level: USER) {
staff_insert(
data: {
userId: $userId
fullName: $fullName
level: $level
role: $role
phone: $phone
email: $email
photoUrl: $photoUrl
totalShifts: $totalShifts
averageRating: $averageRating
onTimeRate: $onTimeRate
noShowCount: $noShowCount
cancellationCount: $cancellationCount
reliabilityScore: $reliabilityScore
bio: $bio
#skills: $skills
industries: $industries
preferredLocations: $preferredLocations
maxDistanceMiles: $maxDistanceMiles
languages: $languages
itemsAttire: $itemsAttire
xp: $xp
badges: $badges
isRecommended: $isRecommended
ownerId: $ownerId
department: $department
hubId: $hubId
manager: $manager
english: $english
backgroundCheckStatus: $backgroundCheckStatus
employmentType: $employmentType
initial: $initial
englishRequired: $englishRequired
city: $city
addres: $addres
}
)
}
mutation UpdateStaff(
$id: UUID!
$userId: String
$fullName: String
$level: String
$role: String
$phone: String
$email: String
$photoUrl: String
$totalShifts: Int
$averageRating: Float
$onTimeRate: Int
$noShowCount: Int
$cancellationCount: Int
$reliabilityScore: Int
$bio: String
#$skills: Any
$industries: Any
$preferredLocations: Any
$maxDistanceMiles: Int
$languages: Any
$itemsAttire: Any
$xp: Int
$badges: Any
$isRecommended: Boolean
$ownerId: UUID
$department: DepartmentType
$hubId: UUID
$manager: UUID
$english: EnglishProficiency
$backgroundCheckStatus: BackgroundCheckStatus
$employmentType: EmploymentType
$initial: String
$englishRequired: Boolean
$city: String
$addres: String
) @auth(level: USER) {
staff_update(
id: $id
data: {
userId: $userId
fullName: $fullName
level: $level
role: $role
phone: $phone
email: $email
photoUrl: $photoUrl
totalShifts: $totalShifts
averageRating: $averageRating
onTimeRate: $onTimeRate
noShowCount: $noShowCount
cancellationCount: $cancellationCount
reliabilityScore: $reliabilityScore
bio: $bio
#skills: $skills
industries: $industries
preferredLocations: $preferredLocations
maxDistanceMiles: $maxDistanceMiles
languages: $languages
itemsAttire: $itemsAttire
xp: $xp
badges: $badges
isRecommended: $isRecommended
ownerId: $ownerId
department: $department
hubId: $hubId
manager: $manager
english: $english
backgroundCheckStatus: $backgroundCheckStatus
employmentType: $employmentType
initial: $initial
englishRequired: $englishRequired
city: $city
addres: $addres
}
)
}
mutation DeleteStaff($id: UUID!) @auth(level: USER) {
staff_delete(id: $id)
}

173
backend/dataconnect/connector/staff/queries.gql Normal file
View File

@@ -0,0 +1,173 @@
query listStaff @auth(level: USER) {
staffs {
id
userId
fullName
level
role
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
#skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query getStaffById($id: UUID!) @auth(level: USER) {
staff(id: $id) {
id
userId
fullName
role
level
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
#skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
updatedAt
createdBy
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query getStaffByUserId($userId: String!) @auth(level: USER) {
staffs(where: { userId: { eq: $userId } }) {
id
userId
fullName
level
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
#skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
updatedAt
createdBy
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query filterStaff(
$ownerId: UUID
$fullName: String
$level: String
$email: String
) @auth(level: USER) {
staffs(
where: {
ownerId: { eq: $ownerId }
fullName: { eq: $fullName }
level: { eq: $level }
email: { eq: $email }
}
) {
id
userId
fullName
level
phone
email
photoUrl
averageRating
reliabilityScore
totalShifts
ownerId
isRecommended
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}

44
backend/dataconnect/connector/staffAvailability/mutations.gql Normal file
View File

@@ -0,0 +1,44 @@
mutation createStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
$status: AvailabilityStatus
$notes: String
) @auth(level: USER) {
staffAvailability_insert(
data: {
staffId: $staffId
day: $day
slot: $slot
status: $status
notes: $notes
}
)
}
mutation updateStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
$status: AvailabilityStatus
$notes: String
) @auth(level: USER) {
staffAvailability_update(
key: { staffId: $staffId, day: $day, slot: $slot }
data: {
status: $status
notes: $notes
}
)
}
mutation deleteStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
) @auth(level: USER) {
staffAvailability_delete(
key: { staffId: $staffId, day: $day, slot: $slot }
)
}

87
backend/dataconnect/connector/staffAvailability/queries.gql Normal file
View File

@@ -0,0 +1,87 @@
query listStaffAvailabilities(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(offset: $offset, limit: $limit) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query listStaffAvailabilitiesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query getStaffAvailabilityByKey(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
) @auth(level: USER) {
staffAvailability(key: { staffId: $staffId, day: $day, slot: $slot }) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query listStaffAvailabilitiesByDay(
$day: DayOfWeek!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(
where: { day: { eq: $day } }
offset: $offset
limit: $limit
) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}

54
backend/dataconnect/connector/staffAvailabilityStats/mutations.gql Normal file
View File

@@ -0,0 +1,54 @@
mutation createStaffAvailabilityStats(
$staffId: UUID!
$needWorkIndex: Int
$utilizationPercentage: Int
$predictedAvailabilityScore: Int
$scheduledHoursThisPeriod: Int
$desiredHoursThisPeriod: Int
$lastShiftDate: Timestamp
$acceptanceRate: Int
) @auth(level: USER) {
staffAvailabilityStats_insert(
data: {
staffId: $staffId
needWorkIndex: $needWorkIndex
utilizationPercentage: $utilizationPercentage
predictedAvailabilityScore: $predictedAvailabilityScore
scheduledHoursThisPeriod: $scheduledHoursThisPeriod
desiredHoursThisPeriod: $desiredHoursThisPeriod
lastShiftDate: $lastShiftDate
acceptanceRate: $acceptanceRate
}
)
}
mutation updateStaffAvailabilityStats(
$staffId: UUID!
$needWorkIndex: Int
$utilizationPercentage: Int
$predictedAvailabilityScore: Int
$scheduledHoursThisPeriod: Int
$desiredHoursThisPeriod: Int
$lastShiftDate: Timestamp
$acceptanceRate: Int
) @auth(level: USER) {
staffAvailabilityStats_update(
key: { staffId: $staffId }
data: {
needWorkIndex: $needWorkIndex
utilizationPercentage: $utilizationPercentage
predictedAvailabilityScore: $predictedAvailabilityScore
scheduledHoursThisPeriod: $scheduledHoursThisPeriod
desiredHoursThisPeriod: $desiredHoursThisPeriod
lastShiftDate: $lastShiftDate
acceptanceRate: $acceptanceRate
}
)
}
mutation deleteStaffAvailabilityStats(
$staffId: UUID!
) @auth(level: USER) {
staffAvailabilityStats_delete(key: { staffId: $staffId })
}

109
backend/dataconnect/connector/staffAvailabilityStats/queries.gql Normal file
View File

@@ -0,0 +1,109 @@
# ==========================================================
# StaffAvailabilityStats - QUERIES
# ==========================================================
# Notes:
# - Entity key is composite: key: ["staffId"]
# - So the single-record lookup is: staffAvailabilityStats(key: { staffId: ... })
# - There is no Query.staffAvailabilityStat(id: ...) unless you defined id as the key.
# ==========================================================
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listStaffAvailabilityStats(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilityStatss(offset: $offset, limit: $limit) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}
# ----------------------------------------------------------
# GET BY KEY (staffId)
# ----------------------------------------------------------
query getStaffAvailabilityStatsByStaffId(
$staffId: UUID!
) @auth(level: USER) {
staffAvailabilityStats(key: { staffId: $staffId }) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}
# ----------------------------------------------------------
# FILTER (optional) - useful for dashboards
# NOTE: Data Connect filter ops are typically: eq, ne, gt, ge, lt, le, in, isNull
# ----------------------------------------------------------
query filterStaffAvailabilityStats(
$needWorkIndexMin: Int
$needWorkIndexMax: Int
$utilizationMin: Int
$utilizationMax: Int
$acceptanceRateMin: Int
$acceptanceRateMax: Int
$lastShiftAfter: Timestamp
$lastShiftBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilityStatss(
where: {
needWorkIndex: { ge: $needWorkIndexMin, le: $needWorkIndexMax }
utilizationPercentage: { ge: $utilizationMin, le: $utilizationMax }
acceptanceRate: { ge: $acceptanceRateMin, le: $acceptanceRateMax }
lastShiftDate: { ge: $lastShiftAfter, le: $lastShiftBefore }
}
offset: $offset
limit: $limit
) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}

47
backend/dataconnect/connector/staffCourse/mutations.gql Normal file
View File

@@ -0,0 +1,47 @@
# Mutations for StaffCourse
mutation createStaffCourse(
$staffId: UUID!
$courseId: UUID!
$progressPercent: Int
$completed: Boolean
$completedAt: Timestamp
$startedAt: Timestamp
$lastAccessedAt: Timestamp
) @auth(level: USER) {
staffCourse_insert(
data: {
staffId: $staffId
courseId: $courseId
progressPercent: $progressPercent
completed: $completed
completedAt: $completedAt
startedAt: $startedAt
lastAccessedAt: $lastAccessedAt
}
)
}
mutation updateStaffCourse(
$id: UUID!
$progressPercent: Int
$completed: Boolean
$completedAt: Timestamp
$startedAt: Timestamp
$lastAccessedAt: Timestamp
) @auth(level: USER) {
staffCourse_update(
id: $id
data: {
progressPercent: $progressPercent
completed: $completed
completedAt: $completedAt
startedAt: $startedAt
lastAccessedAt: $lastAccessedAt
}
)
}
mutation deleteStaffCourse($id: UUID!) @auth(level: USER) {
staffCourse_delete(id: $id)
}

85
backend/dataconnect/connector/staffCourse/queries.gql Normal file
View File

@@ -0,0 +1,85 @@
query getStaffCourseById($id: UUID!) @auth(level: USER) {
staffCourse(id: $id) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query listStaffCoursesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffCourses(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query listStaffCoursesByCourseId(
$courseId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffCourses(
where: { courseId: { eq: $courseId } }
offset: $offset
limit: $limit
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query getStaffCourseByStaffAndCourse(
$staffId: UUID!
$courseId: UUID!
) @auth(level: USER) {
staffCourses(
where: {
staffId: { eq: $staffId }
courseId: { eq: $courseId }
}
limit: 1
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}

43
backend/dataconnect/connector/staffDocument/mutations.gql Normal file
View File

@@ -0,0 +1,43 @@
mutation createStaffDocument(
$staffId: UUID!
$staffName: String!
$documentId: UUID!
$status: DocumentStatus!
$documentUrl: String
$expiryDate: Timestamp
) @auth(level: USER) {
staffDocument_insert(
data: {
staffId: $staffId
staffName: $staffName
documentId: $documentId
status: $status
documentUrl: $documentUrl
expiryDate: $expiryDate
}
)
}
mutation updateStaffDocument(
$staffId: UUID!
$documentId: UUID!
$status: DocumentStatus
$documentUrl: String
$expiryDate: Timestamp
) @auth(level: USER) {
staffDocument_update(
key: { staffId: $staffId, documentId: $documentId }
data: {
status: $status
documentUrl: $documentUrl
}
)
}
mutation deleteStaffDocument(
$staffId: UUID!
$documentId: UUID!
) @auth(level: USER) {
staffDocument_delete(key: { staffId: $staffId, documentId: $documentId })
}

100
backend/dataconnect/connector/staffDocument/queries.gql Normal file
View File

@@ -0,0 +1,100 @@
query getStaffDocumentByKey(
$staffId: UUID!
$documentId: UUID!
) @auth(level: USER) {
staffDocument(key: { staffId: $staffId, documentId: $documentId }) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
createdAt
updatedAt
document {
id
name
documentType
description
}
}
}
query listStaffDocumentsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
createdAt
updatedAt
document {
id
name
documentType
}
}
}
query listStaffDocumentsByDocumentType(
$documentType: DocumentType!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { document: { documentType: { eq: $documentType } } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
document {
id
name
documentType
}
}
}
query listStaffDocumentsByStatus(
$status: DocumentStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
document {
id
name
documentType
}
}
}

22
backend/dataconnect/connector/staffRole/mutations.gql Normal file
View File

@@ -0,0 +1,22 @@
mutation createStaffRole(
$staffId: UUID!
$roleId: UUID!
$roleType: RoleType
) @auth(level: USER) {
staffRole_insert(
data: {
staffId: $staffId
roleId: $roleId
roleType: $roleType
}
)
}
mutation deleteStaffRole(
$staffId: UUID!
$roleId: UUID!
) @auth(level: USER) {
staffRole_delete(
key: { staffId: $staffId, roleId: $roleId }
)
}

142
backend/dataconnect/connector/staffRole/queries.gql Normal file
View File

@@ -0,0 +1,142 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listStaffRoles(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(offset: $offset, limit: $limit) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# GET BY COMPOSITE KEY (staffId + roleId)
# ----------------------------------------------------------
query getStaffRoleByKey(
$staffId: UUID!
$roleId: UUID!
) @auth(level: USER) {
staffRole(key: { staffId: $staffId, roleId: $roleId }) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# LIST BY STAFF (most common)
# ----------------------------------------------------------
query listStaffRolesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# LIST BY ROLE (who has this skill)
# ----------------------------------------------------------
query listStaffRolesByRoleId(
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: { roleId: { eq: $roleId } }
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
}
}
# ----------------------------------------------------------
# FILTER (optional)
# Useful when you want both conditions without using key lookup
# ----------------------------------------------------------
query filterStaffRoles(
$staffId: UUID
$roleId: UUID
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: {
staffId: { eq: $staffId }
roleId: { eq: $roleId }
}
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
}
}

64
backend/dataconnect/connector/task/mutations.gql Normal file
View File

@@ -0,0 +1,64 @@
mutation createTask(
$taskName: String!
$description: String
$priority: TaskPriority!
$status: TaskStatus!
$dueDate: Timestamp
$progress: Int
$orderIndex: Int
$commentCount: Int
$attachmentCount: Int
$files: Any
$ownerId:UUID!
) @auth(level: USER) {
task_insert(
data: {
taskName: $taskName
description: $description
priority: $priority
status: $status
dueDate: $dueDate
progress: $progress
orderIndex: $orderIndex
commentCount: $commentCount
attachmentCount: $attachmentCount
files: $files
ownerId:$ownerId
}
)
}
mutation updateTask(
$id: UUID!
$taskName: String
$description: String
$priority: TaskPriority
$status: TaskStatus
$dueDate: Timestamp
$progress: Int
$assignedMembers: Any
$orderIndex: Int
$commentCount: Int
$attachmentCount: Int
$files: Any
) @auth(level: USER) {
task_update(
id: $id
data: {
taskName: $taskName
description: $description
priority: $priority
status: $status
dueDate: $dueDate
progress: $progress
orderIndex: $orderIndex
commentCount: $commentCount
attachmentCount: $attachmentCount
files: $files
}
)
}
mutation deleteTask($id: UUID!) @auth(level: USER) {
task_delete(id: $id)
}

83
backend/dataconnect/connector/task/queries.gql Normal file
View File

@@ -0,0 +1,83 @@
query listTasks @auth(level: USER) {
tasks {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query getTaskById($id: UUID!) @auth(level: USER) {
task(id: $id) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query getTasksByOwnerId($ownerId: UUID!) @auth(level: USER) {
tasks(where: { ownerId: { eq: $ownerId } }) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query filterTasks(
$status: TaskStatus
$priority: TaskPriority
) @auth(level: USER) {
tasks(
where: {
status: { eq: $status }
priority: { eq: $priority }
}
) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}

33
backend/dataconnect/connector/task_comment/mutations.gql Normal file
View File

@@ -0,0 +1,33 @@
mutation createTaskComment(
$taskId: UUID!
$teamMemberId: UUID!
$comment: String!
$isSystem: Boolean
) @auth(level: USER) {
taskComment_insert(
data: {
taskId: $taskId
teamMemberId: $teamMemberId
comment: $comment
isSystem: $isSystem
}
)
}
mutation updateTaskComment(
$id: UUID!
$comment: String
$isSystem: Boolean
) @auth(level: USER) {
taskComment_update(
id: $id
data: {
comment: $comment
isSystem: $isSystem
}
)
}
mutation deleteTaskComment($id: UUID!) @auth(level: USER) {
taskComment_delete(id: $id)
}

62
backend/dataconnect/connector/task_comment/queries.gql Normal file
View File

@@ -0,0 +1,62 @@
query listTaskComments @auth(level: USER) {
taskComments {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}
query getTaskCommentById($id: UUID!) @auth(level: USER) {
taskComment(id: $id) {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}
query getTaskCommentsByTaskId($taskId: UUID!) @auth(level: USER) {
taskComments(where: { taskId: { eq: $taskId } }) {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}

45
backend/dataconnect/connector/taxForm/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation createTaxForm(
$formType: TaxFormType!
$title: String!
$subtitle: String
$description: String
$status: TaxFormStatus
$staffId: UUID!
$formData: Any
) @auth(level: USER) {
taxForm_insert(
data: {
formType: $formType
title: $title
subtitle: $subtitle
description: $description
status: $status
staffId: $staffId
formData: $formData
}
)
}
mutation updateTaxForm(
$id: UUID!
$status: TaxFormStatus
$formData: Any
$title: String
$subtitle: String
$description: String
) @auth(level: USER) {
taxForm_update(
id: $id
data: {
status: $status
formData: $formData
title: $title
subtitle: $subtitle
description: $description
}
)
}
mutation deleteTaxForm($id: UUID!) @auth(level: USER) {
taxForm_delete(id: $id)
}

67
backend/dataconnect/connector/taxForm/queries.gql Normal file
View File

@@ -0,0 +1,67 @@
query listTaxForms @auth(level: USER) {
taxForms {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query getTaxFormById($id: UUID!) @auth(level: USER) {
taxForm(id: $id) {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query getTaxFormsBystaffId($staffId: UUID!) @auth(level: USER) {
taxForms(where: { staffId: { eq: $staffId } }) {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query filterTaxForms(
$formType: TaxFormType
$status: TaxFormStatus
$staffId: UUID
) @auth(level: USER) {
taxForms(
where: {
formType: { eq: $formType }
status: { eq: $status }
staffId: { eq: $staffId }
}
) {
id
formType
title
status
staffId
}
}

73
backend/dataconnect/connector/team/mutations.gql Normal file
View File

@@ -0,0 +1,73 @@
mutation createTeam(
$teamName: String!
$ownerId: String!
$ownerName: String!
$ownerRole: String!
$email: String
$companyLogo: String
$totalMembers: Int
$activeMembers: Int
$totalHubs: Int
$departments: Any
$favoriteStaffCount: Int
$blockedStaffCount: Int
$favoriteStaff: Any
$blockedStaff: Any
) @auth(level: USER) {
team_insert(
data: {
teamName: $teamName
ownerId: $ownerId
ownerName: $ownerName
ownerRole: $ownerRole
email: $email
companyLogo: $companyLogo
totalMembers: $totalMembers
activeMembers: $activeMembers
totalHubs: $totalHubs
departments: $departments
favoriteStaffCount: $favoriteStaffCount
blockedStaffCount: $blockedStaffCount
favoriteStaff: $favoriteStaff
blockedStaff: $blockedStaff
}
)
}
mutation updateTeam(
$id: UUID!
$teamName: String
$ownerName: String
$ownerRole: String
$companyLogo: String
$totalMembers: Int
$activeMembers: Int
$totalHubs: Int
$departments: Any
$favoriteStaffCount: Int
$blockedStaffCount: Int
$favoriteStaff: Any
$blockedStaff: Any
) @auth(level: USER) {
team_update(
id: $id
data: {
teamName: $teamName
ownerName: $ownerName
ownerRole: $ownerRole
companyLogo: $companyLogo
totalMembers: $totalMembers
activeMembers: $activeMembers
totalHubs: $totalHubs
departments: $departments
favoriteStaffCount: $favoriteStaffCount
blockedStaffCount: $blockedStaffCount
favoriteStaff: $favoriteStaff
blockedStaff: $blockedStaff
}
)
}
mutation deleteTeam($id: UUID!) @auth(level: USER) {
team_delete(id: $id)
}

68
backend/dataconnect/connector/team/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
query listTeams @auth(level: USER) {
teams {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}
query getTeamById($id: UUID!) @auth(level: USER) {
team(id: $id) {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}
query getTeamsByOwnerId($ownerId: String!) @auth(level: USER) {
teams(where: { ownerId: { eq: $ownerId } }) {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}

55
backend/dataconnect/connector/teamHub/mutations.gql Normal file
View File

@@ -0,0 +1,55 @@
mutation createTeamHub(
$teamId: UUID!
$hubName: String!
$address: String!
$city: String!
$state: String!
$zipCode: String!
$managerName: String!
$isActive: Boolean
$departments: Any
) @auth(level: USER) {
teamHub_insert(
data: {
teamId: $teamId
hubName: $hubName
address: $address
city: $city
state: $state
zipCode: $zipCode
managerName: $managerName
isActive: $isActive
departments: $departments
}
)
}
mutation updateTeamHub(
$id: UUID!
$hubName: String
$address: String
$city: String
$state: String
$zipCode: String
$managerName: String
$isActive: Boolean
$departments: Any
) @auth(level: USER) {
teamHub_update(
id: $id
data: {
hubName: $hubName
address: $address
city: $city
state: $state
zipCode: $zipCode
managerName: $managerName
isActive: $isActive
departments: $departments
}
)
}
mutation deleteTeamHub($id: UUID!) @auth(level: USER) {
teamHub_delete(id: $id)
}

53
backend/dataconnect/connector/teamHub/queries.gql Normal file
View File

@@ -0,0 +1,53 @@
query listTeamHubs @auth(level: USER) {
teamHubs {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}
query getTeamHubById($id: UUID!) @auth(level: USER) {
teamHub(id: $id) {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}
query getTeamHubsByTeamId($teamId: UUID!) @auth(level: USER) {
teamHubs(where: { teamId: { eq: $teamId } }) {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}

35
backend/dataconnect/connector/teamHudDeparment/mutations.gql Normal file
View File

@@ -0,0 +1,35 @@
mutation createTeamHudDepartment(
$name: String!
$costCenter: String
$teamHubId: UUID!
) @auth(level: USER) {
teamHudDepartment_insert(
data: {
name: $name
costCenter: $costCenter
teamHubId: $teamHubId
}
)
}
mutation updateTeamHudDepartment(
$id: UUID!
$name: String
$costCenter: String
$teamHubId: UUID
) @auth(level: USER) {
teamHudDepartment_update(
id: $id
data: {
name: $name
costCenter: $costCenter
teamHubId: $teamHubId
}
)
}
mutation deleteTeamHudDepartment($id: UUID!) @auth(level: USER) {
teamHudDepartment_delete(id: $id)
}

68
backend/dataconnect/connector/teamHudDeparment/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listTeamHudDepartments(
$offset: Int
$limit: Int
) @auth(level: USER) {
teamHudDepartments(offset: $offset, limit: $limit) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getTeamHudDepartmentById($id: UUID!) @auth(level: USER) {
teamHudDepartment(id: $id) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}
# ----------------------------------------------------------
# LIST BY TEAM HUB ID
# ----------------------------------------------------------
query listTeamHudDepartmentsByTeamHubId(
$teamHubId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
teamHudDepartments(
where: { teamHubId: { eq: $teamHubId } }
offset: $offset
limit: $limit
) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}

92
backend/dataconnect/connector/teamMember/mutations.gql Normal file
View File

@@ -0,0 +1,92 @@
mutation createTeamMember(
$teamId: UUID!
$role: TeamMemberRole!
$title: String
$department: String
$teamHubId: UUID
$isActive: Boolean
$userId: String!
$inviteStatus: TeamMemberInviteStatus
) @auth(level: USER) {
teamMember_insert(
data: {
teamId: $teamId
role: $role
title: $title
department: $department
teamHubId: $teamHubId
isActive: $isActive
userId: $userId
inviteStatus: $inviteStatus
}
)
}
mutation updateTeamMember(
$id: UUID!
$role: TeamMemberRole
$title: String
$department: String
$teamHubId: UUID
$isActive: Boolean
$inviteStatus: TeamMemberInviteStatus
) @auth(level: USER) {
teamMember_update(
id: $id
data: {
role: $role
title: $title
department: $department
teamHubId: $teamHubId
isActive: $isActive
inviteStatus: $inviteStatus
}
)
}
mutation updateTeamMemberInviteStatus(
$id: UUID!
$inviteStatus: TeamMemberInviteStatus!
) @auth(level: USER) {
teamMember_update(
id: $id
data: {
inviteStatus: $inviteStatus
}
)
}
mutation acceptInviteByCode(
$inviteCode: UUID!
) @auth(level: USER) {
teamMember_updateMany(
where: {
inviteCode: { eq: $inviteCode }
inviteStatus: { eq: PENDING }
}
data: {
inviteStatus: ACCEPTED
isActive: true
}
)
}
mutation cancelInviteByCode(
$inviteCode: UUID!
) @auth(level: USER) {
teamMember_updateMany(
where: {
inviteCode: { eq: $inviteCode }
inviteStatus: { eq: PENDING }
}
data: {
inviteStatus: CANCELLED
isActive: false
}
)
}
mutation deleteTeamMember($id: UUID!) @auth(level: USER) {
teamMember_delete(id: $id)
}

66
backend/dataconnect/connector/teamMember/queries.gql Normal file
View File

@@ -0,0 +1,66 @@
query listTeamMembers @auth(level: USER) {
teamMembers {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}
query getTeamMemberById($id: UUID!) @auth(level: USER) {
teamMember(id: $id) {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}
query getTeamMembersByTeamId($teamId: UUID!) @auth(level: USER) {
teamMembers(where: { teamId: { eq: $teamId } }) {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}

45
backend/dataconnect/connector/user/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation CreateUser(
$id: String!, # Firebase UID
$email: String,
$fullName: String,
$role: UserBaseRole!,
$userRole: String,
$photoUrl: String
) @auth(level: USER) {
user_insert(
data: {
id: $id
email: $email
fullName: $fullName
role: $role
userRole: $userRole
photoUrl: $photoUrl
}
)
}
mutation UpdateUser(
$id: String!,
$email: String,
$fullName: String,
$role: UserBaseRole,
$userRole: String,
$photoUrl: String
) @auth(level: USER) {
user_update(
id: $id,
data: {
email: $email
fullName: $fullName
role: $role
userRole: $userRole
photoUrl: $photoUrl
}
)
}
mutation DeleteUser(
$id: String!
) @auth(level: USER) {
user_delete(id: $id)
}

48
backend/dataconnect/connector/user/queries.gql Normal file
View File

@@ -0,0 +1,48 @@
query listUsers @auth(level: USER) {
users {
id
email
fullName
role
userRole
photoUrl
createdDate
updatedDate
}
}
query getUserById(
$id: String!
) @auth(level: USER) {
user(id: $id) {
id
email
fullName
role
userRole
photoUrl
}
}
query filterUsers(
$id: String,
$email: String,
$role: UserBaseRole,
$userRole: String
) @auth(level: USER) {
users(
where: {
id: { eq: $id }
email: { eq: $email }
role: { eq: $role }
userRole: { eq: $userRole }
}
) {
id
email
fullName
role
userRole
photoUrl
}
}

74
backend/dataconnect/connector/userConversation/mutations.gql Normal file
View File

@@ -0,0 +1,74 @@
mutation createUserConversation(
$conversationId: UUID!
$userId: String!
$unreadCount: Int
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_insert(
data: {
conversationId: $conversationId
userId: $userId
unreadCount: $unreadCount
lastReadAt: $lastReadAt
}
)
}
mutation updateUserConversation(
$conversationId: UUID!
$userId: String!
$unreadCount: Int
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: {
unreadCount: $unreadCount
lastReadAt: $lastReadAt
}
)
}
# ----------------------------------------------------------
# MARK AS READ (sets unreadCount=0 + lastReadAt=now)
# Note: request.time is valid in schema defaults; in mutations
# you can pass Timestamp from client. If you want "now" server-side,
# you'd typically pass null and have logic elsewhere.
# ----------------------------------------------------------
mutation markConversationAsRead(
$conversationId: UUID!
$userId: String!
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: {
unreadCount: 0
lastReadAt: $lastReadAt
}
)
}
# ----------------------------------------------------------
# INCREMENT UNREAD (common after sending message)
# ----------------------------------------------------------
mutation incrementUnreadForUser(
$conversationId: UUID!
$userId: String!
$unreadCount: Int!
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: { unreadCount: $unreadCount }
)
}
mutation deleteUserConversation(
$conversationId: UUID!
$userId: String!
) @auth(level: USER) {
userConversation_delete(
key: { conversationId: $conversationId, userId: $userId }
)
}

230
backend/dataconnect/connector/userConversation/queries.gql Normal file
View File

@@ -0,0 +1,230 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listUserConversations(
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(offset: $offset, limit: $limit) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# GET BY KEY (conversationId + userId)
# ----------------------------------------------------------
query getUserConversationByKey(
$conversationId: UUID!
$userId: String!
) @auth(level: USER) {
userConversation(key: { conversationId: $conversationId, userId: $userId }) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# LIST BY USER (My inbox) ✅
# Order by most recent activity (Conversation.lastMessageAt)
# NOTE: If your DC version doesn't allow orderBy on nested fields,
# just orderBy createdAt/updatedAt on user_conversations.
# ----------------------------------------------------------
query listUserConversationsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: { userId: { eq: $userId } }
offset: $offset
limit: $limit
# If supported:
# orderBy: { conversation: { lastMessageAt: DESC } }
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
updatedAt
createdBy
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# LIST UNREAD BY USER (badge, notifications)
# ----------------------------------------------------------
query listUnreadUserConversationsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: {
userId: { eq: $userId }
unreadCount: { gt: 0 }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
}
}
}
# ----------------------------------------------------------
# LIST BY CONVERSATION (participants view)
# ----------------------------------------------------------
query listUserConversationsByConversationId(
$conversationId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: { conversationId: { eq: $conversationId } }
offset: $offset
limit: $limit
orderBy: { createdAt: ASC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# FILTER (dashboard/debug)
# ----------------------------------------------------------
query filterUserConversations(
$userId: String
$conversationId: UUID
$unreadMin: Int
$unreadMax: Int
$lastReadAfter: Timestamp
$lastReadBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: {
userId: { eq: $userId }
conversationId: { eq: $conversationId }
unreadCount: { ge: $unreadMin, le: $unreadMax }
lastReadAt: { ge: $lastReadAfter, le: $lastReadBefore }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user { id fullName photoUrl }
}
}

99
backend/dataconnect/connector/vendor/mutations.gql vendored Normal file
View File

@@ -0,0 +1,99 @@
mutation createVendor(
$userId: String!
$companyName: String!
$email: String
$phone: String
$photoUrl: String
$address: String
$billingAddress: String
$timezone: String
$legalName: String
$doingBusinessAs: String
$region: String
$state: String
$city: String
$serviceSpecialty: String
$approvalStatus: ApprovalStatus
$isActive: Boolean
$markup: Float
$fee: Float
$csat: Float
$tier: VendorTier
) @auth(level: USER) {
vendor_insert(
data: {
userId: $userId
companyName: $companyName
email: $email
phone: $phone
photoUrl: $photoUrl
address: $address
billingAddress: $billingAddress
timezone: $timezone
legalName: $legalName
doingBusinessAs: $doingBusinessAs
region: $region
state: $state
city: $city
serviceSpecialty: $serviceSpecialty
approvalStatus: $approvalStatus
isActive: $isActive
markup: $markup
fee: $fee
csat: $csat
tier: $tier
}
)
}
mutation updateVendor(
$id: UUID!
$companyName: String
$email: String
$phone: String
$photoUrl: String
$address: String
$billingAddress: String
$timezone: String
$legalName: String
$doingBusinessAs: String
$region: String
$state: String
$city: String
$serviceSpecialty: String
$approvalStatus: ApprovalStatus
$isActive: Boolean
$markup: Float
$fee: Float
$csat: Float
$tier: VendorTier
) @auth(level: USER) {
vendor_update(
id: $id
data: {
companyName: $companyName
email: $email
phone: $phone
photoUrl: $photoUrl
address: $address
billingAddress: $billingAddress
timezone: $timezone
legalName: $legalName
doingBusinessAs: $doingBusinessAs
region: $region
state: $state
city: $city
serviceSpecialty: $serviceSpecialty
approvalStatus: $approvalStatus
isActive: $isActive
markup: $markup
fee: $fee
csat: $csat
tier: $tier
}
)
}
mutation deleteVendor($id: UUID!) @auth(level: USER) {
vendor_delete(id: $id)
}

86
backend/dataconnect/connector/vendor/queries.gql vendored Normal file
View File

@@ -0,0 +1,86 @@
query getVendorById($id: UUID!) @auth(level: USER) {
vendor(id: $id) {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}
query getVendorByUserId($userId: String!) @auth(level: USER) {
vendors(where: { userId: { eq: $userId } }) {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}
query listVendors @auth(level: USER) {
vendors {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}

48
backend/dataconnect/connector/vendorBenefitPlan/mutations.gql Normal file
View File

@@ -0,0 +1,48 @@
mutation createVendorBenefitPlan(
$vendorId: UUID!
$title: String!
$description: String
$requestLabel: String
$total: Int
$isActive: Boolean
$createdBy: String
) @auth(level: USER) {
vendorBenefitPlan_insert(
data: {
vendorId: $vendorId
title: $title
description: $description
requestLabel: $requestLabel
total: $total
isActive: $isActive
}
)
}
mutation updateVendorBenefitPlan(
$id: UUID!
$vendorId: UUID
$title: String
$description: String
$requestLabel: String
$total: Int
$isActive: Boolean
$createdBy: String
) @auth(level: USER) {
vendorBenefitPlan_update(
id: $id
data: {
vendorId: $vendorId
title: $title
description: $description
requestLabel: $requestLabel
total: $total
isActive: $isActive
}
)
}
mutation deleteVendorBenefitPlan($id: UUID!) @auth(level: USER) {
vendorBenefitPlan_delete(id: $id)
}

149
backend/dataconnect/connector/vendorBenefitPlan/queries.gql Normal file
View File

@@ -0,0 +1,149 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listVendorBenefitPlans(
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getVendorBenefitPlanById($id: UUID!) @auth(level: USER) {
vendorBenefitPlan(id: $id) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR
# ----------------------------------------------------------
query listVendorBenefitPlansByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# LIST ACTIVE PLANS BY VENDOR
# ----------------------------------------------------------
query listActiveVendorBenefitPlansByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: {
vendorId: { eq: $vendorId }
isActive: { eq: true }
}
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# FILTER (vendorId + title + isActive)
# - Useful for "does this plan already exist?"
# ----------------------------------------------------------
query filterVendorBenefitPlans(
$vendorId: UUID
$title: String
$isActive: Boolean
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: {
vendorId: { eq: $vendorId }
title: { eq: $title }
isActive: { eq: $isActive }
}
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}

57
backend/dataconnect/connector/vendorRate/mutations.gql Normal file
View File

@@ -0,0 +1,57 @@
mutation createVendorRate(
$vendorId: UUID!,
$roleName: String,
$category: CategoryType,
$clientRate: Float,
$employeeWage: Float,
$markupPercentage: Float,
$vendorFeePercentage: Float,
$isActive: Boolean,
$notes: String
) @auth(level: USER) {
vendorRate_insert(
data: {
vendorId: $vendorId,
roleName: $roleName,
category: $category,
clientRate: $clientRate,
employeeWage: $employeeWage,
markupPercentage: $markupPercentage,
vendorFeePercentage: $vendorFeePercentage,
isActive: $isActive,
notes: $notes,
}
)
}
mutation updateVendorRate(
$id: UUID!,
$vendorId: UUID,
$roleName: String,
$category: CategoryType,
$clientRate: Float,
$employeeWage: Float,
$markupPercentage: Float,
$vendorFeePercentage: Float,
$isActive: Boolean,
$notes: String,
) @auth(level: USER) {
vendorRate_update(
id: $id,
data: {
vendorId: $vendorId,
roleName: $roleName,
category: $category,
clientRate: $clientRate,
employeeWage: $employeeWage,
markupPercentage: $markupPercentage,
vendorFeePercentage: $vendorFeePercentage,
isActive: $isActive,
notes: $notes,
}
)
}
mutation deleteVendorRate($id: UUID!) @auth(level: USER) {
vendorRate_delete(id: $id)
}

42
backend/dataconnect/connector/vendorRate/queries.gql Normal file
View File

@@ -0,0 +1,42 @@
query listVendorRates @auth(level: USER) {
vendorRates {
id
vendorId
roleName
category
clientRate
employeeWage
markupPercentage
vendorFeePercentage
isActive
notes
createdAt
vendor{
companyName
region
}
}
}
query getVendorRateById($id: UUID!) @auth(level: USER) {
vendorRate(id: $id) {
id
vendorId
roleName
category
clientRate
employeeWage
markupPercentage
vendorFeePercentage
isActive
notes
createdAt
vendor{
companyName
region
}
}
}

41
backend/dataconnect/connector/workForce/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createWorkforce(
$vendorId: UUID!
$staffId: UUID!
$workforceNumber: String!
$employmentType: WorkforceEmploymentType
) @auth(level: USER) {
workforce_insert(
data: {
vendorId: $vendorId
staffId: $staffId
workforceNumber: $workforceNumber
employmentType: $employmentType
status: ACTIVE
}
)
}
mutation updateWorkforce(
$id: UUID!
$workforceNumber: String
$employmentType: WorkforceEmploymentType
$status: WorkforceStatus
) @auth(level: USER) {
workforce_update(
id: $id
data: {
workforceNumber: $workforceNumber
employmentType: $employmentType
status: $status
}
)
}
mutation deactivateWorkforce(
$id: UUID!
) @auth(level: USER) {
workforce_update(
id: $id
data: { status: INACTIVE }
)
}

116
backend/dataconnect/connector/workForce/queries.gql Normal file
View File

@@ -0,0 +1,116 @@
# ------------------------------------------------------------
# GET Workforce by ID
# ------------------------------------------------------------
query getWorkforceById($id: UUID!) @auth(level: USER) {
workforce(id: $id) {
id
vendorId
staffId
workforceNumber
employmentType
status
createdAt
updatedAt
staff { id fullName }
vendor { id companyName }
}
}
# ------------------------------------------------------------
# GET Workforce by Vendor + Staff (was "by key")
# ------------------------------------------------------------
query getWorkforceByVendorAndStaff(
$vendorId: UUID!
$staffId: UUID!
) @auth(level: USER) {
workforces(
where: {
vendorId: { eq: $vendorId }
staffId: { eq: $staffId }
}
limit: 1
) {
id
vendorId
staffId
workforceNumber
employmentType
status
createdAt
updatedAt
staff { id fullName }
vendor { id companyName }
}
}
# ------------------------------------------------------------
# LIST Workforce by Vendor
# ------------------------------------------------------------
query listWorkforceByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
workforces(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
staffId
workforceNumber
employmentType
status
createdAt
staff { id fullName }
}
}
# ------------------------------------------------------------
# LIST Workforce by Staff
# ------------------------------------------------------------
query listWorkforceByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
workforces(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
vendorId
workforceNumber
employmentType
status
createdAt
updatedAt
vendor { id companyName }
}
}
# ------------------------------------------------------------
# CHECK workforceNumber uniqueness within a Vendor (optional)
# ------------------------------------------------------------
query getWorkforceByVendorAndNumber(
$vendorId: UUID!
$workforceNumber: String!
) @auth(level: USER) {
workforces(
where: {
vendorId: { eq: $vendorId }
workforceNumber: { eq: $workforceNumber }
}
limit: 1
) {
id
staffId
workforceNumber
status
}
}

13
backend/dataconnect/dataconnect.yaml Normal file
View File

@@ -0,0 +1,13 @@
specVersion: "v1"
serviceId: "krow-workforce-db"
location: "us-central1"
schema:
source: "./schema"
datasource:
postgresql:
database: "krow_db"
cloudSql:
instanceId: "krow-sql"
# schemaValidation: "STRICT" # STRICT mode makes Postgres schema match Data Connect exactly.
# schemaValidation: "COMPATIBLE" # COMPATIBLE mode makes Postgres schema compatible with Data Connect.
connectorDirs: ["./connector"]

32
backend/dataconnect/schema/ShiftRole.gql Normal file
View File

@@ -0,0 +1,32 @@
enum BreakDuration {
MIN_15
MIN_30
NO_BREAK
}
#this is position, timesheet and schedule in staff app
type ShiftRole @table(name: "shift_roles", key: ["shiftId", "roleId"]) {
id: UUID! @default(expr: "uuidV4()")
shiftId: UUID!
shift: Shift! @ref(fields: "shiftId", references: "id")
roleId: UUID!
role: Role! @ref(fields: "roleId", references: "id")
# demand / requirements
count: Int!
assigned: Int @default(expr: "0")
startTime: Timestamp
endTime: Timestamp
hours: Float
department: String
uniform: String
breakType: BreakDuration
totalValue: Float
createdAt: Timestamp @default(expr: "request.time")
updatedAt: Timestamp @default(expr: "request.time")
}

Some files were not shown because too many files have changed in this diff Show More