mirror of
https://github.com/sky-systems/sky_phone.git
synced 2026-08-29 00:01:29 +00:00
Leon.Schmidt
a12e43b624
The generic mutable-table blank template persisted incomplete company definitions before runtime domain validation. Seed valid company defaults, validate before SQL writes, and repair legacy blank entries.
3129 lines
123 KiB
Lua
3129 lines
123 KiB
Lua
Bridge.Database.AfterMigration("sky_phone", function()
|
|
SkyPhoneCompanies = {}
|
|
|
|
local definitions = {}
|
|
local definition_ids = {}
|
|
local definitions_by_job = {}
|
|
local service_lines_by_number = {}
|
|
local call_availability = {}
|
|
local round_robin_positions = {}
|
|
local member_tokens = {}
|
|
local terminal_statuses = {
|
|
completed = true,
|
|
cancelled = true,
|
|
}
|
|
local status_transitions = {
|
|
new = { cancelled = true },
|
|
assigned = { in_progress = true, cancelled = true },
|
|
in_progress = { waiting_customer = true, completed = true, cancelled = true },
|
|
waiting_customer = { in_progress = true, cancelled = true },
|
|
}
|
|
|
|
local function uuid()
|
|
local rows = Bridge.Database.Query("SELECT UUID() AS `id`", {})
|
|
if not rows[1] or type(rows[1].id) ~= "string" then
|
|
error("[sky_phone] Database did not generate a Companies UUID.")
|
|
end
|
|
return rows[1].id
|
|
end
|
|
|
|
local function trim(value)
|
|
if type(value) ~= "string" then
|
|
return nil
|
|
end
|
|
return value:match("^%s*(.-)%s*$")
|
|
end
|
|
|
|
local function valid_text(value, maximum, allow_empty)
|
|
local text = trim(value)
|
|
if not text or text:find("%z") then
|
|
return nil
|
|
end
|
|
local length = utf8.len(text)
|
|
if not length or length > maximum or (not allow_empty and length == 0) then
|
|
return nil
|
|
end
|
|
return text
|
|
end
|
|
|
|
local function valid_integer(value, minimum, maximum)
|
|
local number = tonumber(value)
|
|
if not number or number ~= number or number < minimum or number > maximum
|
|
or number ~= math.floor(number)
|
|
then
|
|
return nil
|
|
end
|
|
return number
|
|
end
|
|
|
|
local function valid_uuid(value)
|
|
return type(value) == "string"
|
|
and value:match("^%x%x%x%x%x%x%x%x%-%x%x%x%x%-%x%x%x%x%-%x%x%x%x%-%x%x%x%x%x%x%x%x%x%x%x%x$") ~= nil
|
|
end
|
|
|
|
local function valid_service_id(value)
|
|
return type(value) == "string"
|
|
and #value >= 1
|
|
and #value <= 64
|
|
and value:match("^[%w_-]+$") ~= nil
|
|
end
|
|
|
|
local function valid_array(value, maximum)
|
|
if type(value) ~= "table" or #value > maximum then
|
|
return false
|
|
end
|
|
local count = 0
|
|
for key in pairs(value) do
|
|
if type(key) ~= "number" or key < 1 or key ~= math.floor(key) or key > #value then
|
|
return false
|
|
end
|
|
count = count + 1
|
|
end
|
|
return count == #value
|
|
end
|
|
|
|
local function iso_time(value)
|
|
local seconds = tonumber(value)
|
|
if not seconds or seconds <= 0 then
|
|
return nil
|
|
end
|
|
return os.date("!%Y-%m-%dT%H:%M:%SZ", seconds)
|
|
end
|
|
|
|
local function days_from_civil(year, month, day)
|
|
year = year - (month <= 2 and 1 or 0)
|
|
local era = math.floor(year / 400)
|
|
local year_of_era = year - era * 400
|
|
local adjusted_month = month + (month > 2 and -3 or 9)
|
|
local day_of_year = math.floor((153 * adjusted_month + 2) / 5) + day - 1
|
|
local day_of_era = year_of_era * 365 + math.floor(year_of_era / 4)
|
|
- math.floor(year_of_era / 100) + day_of_year
|
|
return era * 146097 + day_of_era - 719468
|
|
end
|
|
|
|
local function utc_epoch(year, month, day, hour, minute, second)
|
|
if year < 1970 or year > 2100 or month < 1 or month > 12
|
|
or day < 1 or hour < 0 or hour > 23 or minute < 0 or minute > 59
|
|
or second < 0 or second > 59
|
|
then
|
|
return nil
|
|
end
|
|
local month_lengths = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
|
|
if year % 400 == 0 or (year % 4 == 0 and year % 100 ~= 0) then
|
|
month_lengths[2] = 29
|
|
end
|
|
if day > month_lengths[month] then
|
|
return nil
|
|
end
|
|
return days_from_civil(year, month, day) * 86400 + hour * 3600 + minute * 60 + second
|
|
end
|
|
|
|
local function parse_expiry(value, maximum_seconds)
|
|
if value == nil or value == "" then
|
|
return nil
|
|
end
|
|
if type(value) ~= "string" or #value > 40 then
|
|
return false
|
|
end
|
|
local year, month, day, hour, minute, second = value:match(
|
|
"^(%d%d%d%d)%-(%d%d)%-(%d%d)T(%d%d):(%d%d):(%d%d)Z$"
|
|
)
|
|
if not year then
|
|
year, month, day, hour, minute, second = value:match(
|
|
"^(%d%d%d%d)%-(%d%d)%-(%d%d)T(%d%d):(%d%d):(%d%d)%.%d+Z$"
|
|
)
|
|
end
|
|
if not year then
|
|
return false
|
|
end
|
|
local epoch = utc_epoch(
|
|
tonumber(year),
|
|
tonumber(month),
|
|
tonumber(day),
|
|
tonumber(hour),
|
|
tonumber(minute),
|
|
tonumber(second)
|
|
)
|
|
local now = os.time()
|
|
if not epoch or epoch <= now or epoch - now > maximum_seconds then
|
|
return false
|
|
end
|
|
return epoch
|
|
end
|
|
|
|
local function permission_grade(definition, permission)
|
|
local grade = definition.Permissions and tonumber(definition.Permissions[permission])
|
|
return grade and math.max(0, math.floor(grade)) or nil
|
|
end
|
|
|
|
local function validate_configuration(configuration)
|
|
local company_config = configuration.Companies
|
|
local validated_definitions = {}
|
|
local validated_definition_ids = {}
|
|
local validated_definitions_by_job = {}
|
|
local validated_service_lines_by_number = {}
|
|
|
|
if type(company_config) ~= "table" or type(company_config.Definitions) ~= "table" then
|
|
return nil, "[sky_phone] Config.Companies.Definitions must be configured."
|
|
end
|
|
if type(company_config.Enabled) ~= "boolean" then
|
|
return nil, "[sky_phone] Config.Companies.Enabled must be a boolean."
|
|
end
|
|
for _, field in ipairs({
|
|
{ "PageSize", 1000 },
|
|
{ "MaximumPageSize", 1000 },
|
|
{ "MaximumOpenRequestsPerSim", 1000 },
|
|
{ "MaximumServices", 255 },
|
|
{ "MaximumRequestMedia", 255 },
|
|
{ "SubjectMaxLength", 120 },
|
|
{ "RequestBodyMaxLength", 2000 },
|
|
{ "MessageMaxLength", 2000 },
|
|
{ "ProfileDescriptionMaxLength", 1000 },
|
|
{ "DistrictMaxLength", 80 },
|
|
{ "AddressMaxLength", 160 },
|
|
{ "ServiceTitleMaxLength", 80 },
|
|
{ "ServiceDescriptionMaxLength", 500 },
|
|
{ "ServicePriceMaxLength", 80 },
|
|
{ "AnnouncementTitleMaxLength", 120 },
|
|
{ "AnnouncementBodyMaxLength", 1000 },
|
|
{ "AvailabilityMaximumSeconds", 31536000 },
|
|
{ "AnnouncementMaximumSeconds", 31536000 },
|
|
{ "RetentionDays", 36500 },
|
|
}) do
|
|
if not valid_integer(company_config[field[1]], 1, field[2]) then
|
|
return nil, ("[sky_phone] Config.Companies.%s is outside its supported range."):format(field[1])
|
|
end
|
|
end
|
|
if company_config.PageSize > company_config.MaximumPageSize then
|
|
return nil, "[sky_phone] Companies PageSize cannot exceed MaximumPageSize."
|
|
end
|
|
if type(company_config.RateLimits) ~= "table" then
|
|
return nil, "[sky_phone] Config.Companies.RateLimits must be configured."
|
|
end
|
|
for _, name in ipairs({ "Read", "Search", "CreateRequest", "Message", "RequestAction", "Profile", "CallAvailability" }) do
|
|
if not valid_integer(company_config.RateLimits[name], 1, 100000) then
|
|
return nil, ("[sky_phone] Companies rate limit '%s' is invalid."):format(name)
|
|
end
|
|
end
|
|
if type(company_config.CallRouting) ~= "table"
|
|
or not valid_integer(company_config.CallRouting.MaxAttempts, 1, 20)
|
|
or not valid_integer(company_config.CallRouting.RingSeconds, 1, 120)
|
|
then
|
|
return nil, "[sky_phone] Config.Companies.CallRouting is invalid."
|
|
end
|
|
local configured_statuses = {
|
|
new = true,
|
|
assigned = true,
|
|
in_progress = true,
|
|
waiting_customer = true,
|
|
completed = true,
|
|
cancelled = true,
|
|
}
|
|
if type(company_config.Statuses) ~= "table" then
|
|
return nil, "[sky_phone] Config.Companies.Statuses must be configured."
|
|
end
|
|
for status in pairs(configured_statuses) do
|
|
if company_config.Statuses[status] ~= true then
|
|
return nil, ("[sky_phone] Companies status '%s' must be enabled."):format(status)
|
|
end
|
|
end
|
|
for status, enabled in pairs(company_config.Statuses) do
|
|
if not configured_statuses[status] or enabled ~= true then
|
|
return nil, ("[sky_phone] Companies status '%s' is unsupported."):format(tostring(status))
|
|
end
|
|
end
|
|
if type(company_config.AvailabilityStatuses) ~= "table" then
|
|
return nil, "[sky_phone] Config.Companies.AvailabilityStatuses must be configured."
|
|
end
|
|
local configured_availability = { available = true, busy = true, closed = true }
|
|
for _, status in ipairs({ "available", "busy", "closed" }) do
|
|
if company_config.AvailabilityStatuses[status] ~= true then
|
|
return nil, ("[sky_phone] Companies availability status '%s' must be enabled."):format(status)
|
|
end
|
|
end
|
|
for status, enabled in pairs(company_config.AvailabilityStatuses) do
|
|
if not configured_availability[status] or enabled ~= true then
|
|
return nil, ("[sky_phone] Companies availability status '%s' is unsupported."):format(tostring(status))
|
|
end
|
|
end
|
|
if not valid_array(company_config.Categories, 100) then
|
|
return nil, "[sky_phone] Config.Companies.Categories must be a bounded array."
|
|
end
|
|
local category_ids = {}
|
|
local configured_service_ids = {}
|
|
for _, category_id in ipairs(company_config.Categories) do
|
|
if type(category_id) ~= "string" or #category_id > 64
|
|
or not category_id:match("^[a-z0-9_-]+$") or category_ids[category_id]
|
|
then
|
|
return nil, "[sky_phone] Companies contains an invalid category ID."
|
|
end
|
|
category_ids[category_id] = true
|
|
end
|
|
|
|
for company_id, definition in pairs(company_config.Definitions) do
|
|
if type(company_id) ~= "string" or #company_id > 64 or not company_id:match("^[a-z0-9_-]+$")
|
|
or type(definition) ~= "table"
|
|
or type(definition.Job) ~= "string" or #definition.Job > 64
|
|
or not definition.Job:match("^[%w_-]+$")
|
|
or not valid_text(definition.Name, 120, false)
|
|
or not category_ids[definition.Category]
|
|
then
|
|
return nil, ("[sky_phone] Company definition '%s' is invalid."):format(tostring(company_id))
|
|
end
|
|
local description = valid_text(definition.Description or "", company_config.ProfileDescriptionMaxLength, true)
|
|
local district = valid_text(definition.District or "", company_config.DistrictMaxLength, true)
|
|
local location_label = valid_text(
|
|
definition.LocationLabel or definition.Address or "",
|
|
company_config.DistrictMaxLength,
|
|
true
|
|
)
|
|
local address = valid_text(definition.Address or "", company_config.AddressMaxLength, true)
|
|
local logo_url = valid_text(definition.LogoUrl, 2048, false)
|
|
if not description or not district or not location_label or not address
|
|
or type(definition.Public) ~= "boolean" or type(definition.Emergency) ~= "boolean"
|
|
or type(definition.Verified) ~= "boolean" or type(definition.AcceptsRequests) ~= "boolean"
|
|
or not company_config.AvailabilityStatuses[definition.DefaultAvailability]
|
|
or not valid_text(definition.Icon, 64, false)
|
|
or not logo_url or not logo_url:match("^https://[^%s]+$")
|
|
then
|
|
return nil, ("[sky_phone] Company definition '%s' has invalid public profile defaults."):format(company_id)
|
|
end
|
|
definition.Name = trim(definition.Name)
|
|
definition.Description = description
|
|
definition.District = district
|
|
definition.LocationLabel = location_label
|
|
definition.Address = address
|
|
definition.LogoUrl = logo_url
|
|
if definition.Location ~= nil then
|
|
local location_type = type(definition.Location)
|
|
if location_type ~= "table" and location_type ~= "vector3" then
|
|
return nil, ("[sky_phone] Company definition '%s' has invalid location coordinates."):format(company_id)
|
|
end
|
|
local x = tonumber(definition.Location.x)
|
|
local y = tonumber(definition.Location.y)
|
|
local z = tonumber(definition.Location.z)
|
|
if not x or not y or not z or x ~= x or y ~= y or z ~= z
|
|
or math.abs(x) > 10000 or math.abs(y) > 10000 or math.abs(z) > 2000
|
|
then
|
|
return nil, ("[sky_phone] Company definition '%s' has invalid location coordinates."):format(company_id)
|
|
end
|
|
end
|
|
if validated_definitions_by_job[definition.Job] then
|
|
return nil, ("[sky_phone] Framework job '%s' is assigned to more than one company."):format(definition.Job)
|
|
end
|
|
local line = definition.ServiceLine
|
|
if type(line) ~= "table" then
|
|
return nil, ("[sky_phone] Company '%s' has no service line configuration."):format(company_id)
|
|
end
|
|
local number = SkyPhoneSimNumber.NormalizeService(line.Number, configuration.Sim.NumberLength)
|
|
if not number then
|
|
return nil, ("[sky_phone] Company '%s' has an invalid service number."):format(company_id)
|
|
end
|
|
if validated_service_lines_by_number[number] then
|
|
return nil, ("[sky_phone] Service number '%s' is assigned more than once."):format(number)
|
|
end
|
|
if type(line.AutoContact) ~= "boolean" or type(line.CanCall) ~= "boolean"
|
|
or type(line.CanMessage) ~= "boolean"
|
|
or not valid_integer(line.MinimumGrade, 0, 10000)
|
|
then
|
|
return nil, ("[sky_phone] Company '%s' has invalid service line flags or grade."):format(company_id)
|
|
end
|
|
if line.AutoContact and not definition.Public then
|
|
return nil, ("[sky_phone] Private company '%s' cannot create a public system contact."):format(company_id)
|
|
end
|
|
if line.Routing ~= "round_robin" then
|
|
return nil, ("[sky_phone] Company '%s' uses unsupported call routing '%s'."):format(
|
|
company_id,
|
|
tostring(line.Routing)
|
|
)
|
|
end
|
|
if line.CanMessage then
|
|
return nil, ("[sky_phone] Company '%s' enables messaging without a virtual service-line message router."):format(
|
|
company_id
|
|
)
|
|
end
|
|
line.Number = number
|
|
validated_definitions[company_id] = definition
|
|
validated_definition_ids[#validated_definition_ids + 1] = company_id
|
|
validated_definitions_by_job[definition.Job] = company_id
|
|
validated_service_lines_by_number[number] = company_id
|
|
for _, permission in ipairs({ "WorkQueue", "Availability", "Assign", "Profile", "Hours", "Services", "Announcement" }) do
|
|
if not definition.Permissions or not valid_integer(definition.Permissions[permission], 0, 10000) then
|
|
return nil, ("[sky_phone] Company '%s' has no valid '%s' grade."):format(company_id, permission)
|
|
end
|
|
end
|
|
local default_services = definition.Services
|
|
if default_services == nil then
|
|
default_services = {}
|
|
definition.Services = default_services
|
|
end
|
|
if not valid_array(default_services, company_config.MaximumServices) then
|
|
return nil, ("[sky_phone] Company '%s' has an invalid default service list."):format(company_id)
|
|
end
|
|
for _, service in ipairs(default_services) do
|
|
if type(service) ~= "table" then
|
|
return nil, ("[sky_phone] Company '%s' has an invalid default service."):format(company_id)
|
|
end
|
|
local title = valid_text(service.Title, company_config.ServiceTitleMaxLength, false)
|
|
local service_description = valid_text(
|
|
service.Description or "",
|
|
company_config.ServiceDescriptionMaxLength,
|
|
true
|
|
)
|
|
local price = valid_text(service.Price or "", company_config.ServicePriceMaxLength, true)
|
|
if not valid_service_id(service.Id) or not title or not service_description or not price
|
|
or type(service.RequestsEnabled) ~= "boolean"
|
|
then
|
|
return nil, ("[sky_phone] Company '%s' has an invalid default service."):format(company_id)
|
|
end
|
|
service.Title = title
|
|
service.Description = service_description
|
|
service.Price = price
|
|
if configured_service_ids[service.Id] then
|
|
return nil, ("[sky_phone] Default company service ID '%s' is configured more than once."):format(service.Id)
|
|
end
|
|
configured_service_ids[service.Id] = true
|
|
end
|
|
end
|
|
|
|
table.sort(validated_definition_ids, function(left, right)
|
|
local left_name = validated_definitions[left].Name:lower()
|
|
local right_name = validated_definitions[right].Name:lower()
|
|
return left_name == right_name and left < right or left_name < right_name
|
|
end)
|
|
return {
|
|
definition_ids = validated_definition_ids,
|
|
definitions = validated_definitions,
|
|
definitions_by_job = validated_definitions_by_job,
|
|
service_lines_by_number = validated_service_lines_by_number,
|
|
}
|
|
end
|
|
|
|
function SkyPhoneCompanies.ValidateConfiguration(configuration)
|
|
local validated, validation_error = validate_configuration(configuration)
|
|
if not validated then
|
|
return false, validation_error
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function seed_companies()
|
|
if #definition_ids > 0 then
|
|
local placeholders = {}
|
|
local numbers = {}
|
|
for index, company_id in ipairs(definition_ids) do
|
|
placeholders[index] = "?"
|
|
numbers[index] = definitions[company_id].ServiceLine.Number
|
|
end
|
|
local collisions = Bridge.Database.Query(([[
|
|
SELECT `phone_number` FROM `sky_phone_sims`
|
|
WHERE `phone_number` IN (%s)
|
|
LIMIT 1
|
|
]]):format(table.concat(placeholders, ", ")), numbers)
|
|
if collisions[1] then
|
|
error(("[sky_phone] Company service number '%s' collides with an existing SIM."):format(
|
|
tostring(collisions[1].phone_number)
|
|
))
|
|
end
|
|
end
|
|
|
|
for _, company_id in ipairs(definition_ids) do
|
|
local definition = definitions[company_id]
|
|
local location = definition.Location
|
|
if location then
|
|
Bridge.Database.Query([[
|
|
INSERT IGNORE INTO `sky_phone_company_profiles`
|
|
(`company_id`, `description`, `district`, `location_label`, `address`,
|
|
`location_x`, `location_y`, `location_z`, `availability`, `accepts_requests`)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
]], {
|
|
company_id,
|
|
definition.Description or "",
|
|
definition.District or "",
|
|
definition.LocationLabel or definition.Address or "",
|
|
definition.Address or "",
|
|
location.x,
|
|
location.y,
|
|
location.z,
|
|
definition.DefaultAvailability or "closed",
|
|
definition.AcceptsRequests and 1 or 0,
|
|
})
|
|
else
|
|
Bridge.Database.Query([[
|
|
INSERT IGNORE INTO `sky_phone_company_profiles`
|
|
(`company_id`, `description`, `district`, `location_label`, `address`,
|
|
`availability`, `accepts_requests`)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
]], {
|
|
company_id,
|
|
definition.Description or "",
|
|
definition.District or "",
|
|
definition.LocationLabel or definition.Address or "",
|
|
definition.Address or "",
|
|
definition.DefaultAvailability or "closed",
|
|
definition.AcceptsRequests and 1 or 0,
|
|
})
|
|
end
|
|
for index, service in ipairs(definition.Services or {}) do
|
|
Bridge.Database.Query([[
|
|
INSERT IGNORE INTO `sky_phone_company_services`
|
|
(`id`, `company_id`, `title`, `description`, `price_text`, `requests_enabled`, `active`, `sort_order`)
|
|
VALUES (?, ?, ?, ?, ?, ?, 1, ?)
|
|
]], {
|
|
service.Id,
|
|
company_id,
|
|
service.Title,
|
|
service.Description or "",
|
|
service.Price or "",
|
|
service.RequestsEnabled and 1 or 0,
|
|
index,
|
|
})
|
|
local seeded = Bridge.Database.Query(
|
|
"SELECT `company_id` FROM `sky_phone_company_services` WHERE `id` = ? LIMIT 1",
|
|
{ service.Id }
|
|
)
|
|
if not seeded[1] or seeded[1].company_id ~= company_id then
|
|
error(("[sky_phone] Default service ID '%s' collides with another company."):format(service.Id))
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
local function migrate_requestable_emergency_companies()
|
|
local migration_name = "sky-phone:companies:requestable-emergency:v1"
|
|
local completed = Bridge.Database.Query(
|
|
"SELECT 1 FROM `sky_phone_migrations` WHERE `name` = ? LIMIT 1",
|
|
{ migration_name }
|
|
)
|
|
if completed[1] then
|
|
return
|
|
end
|
|
|
|
local statements = {}
|
|
local migrated_companies = {}
|
|
for _, company_id in ipairs(definition_ids) do
|
|
local definition = definitions[company_id]
|
|
if definition.Emergency and definition.AcceptsRequests then
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `accepts_requests` = 1, `revision` = `revision` + 1
|
|
WHERE `company_id` = ? AND `accepts_requests` = 0
|
|
]],
|
|
params = { company_id },
|
|
}
|
|
migrated_companies[#migrated_companies + 1] = company_id
|
|
end
|
|
end
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT IGNORE INTO `sky_phone_migrations` (`name`, `source`, `stats`)
|
|
VALUES (?, ?, ?)
|
|
]],
|
|
params = {
|
|
migration_name,
|
|
"sky-phone",
|
|
json.encode({ companies = migrated_companies }),
|
|
},
|
|
}
|
|
if not Bridge.Database.Transaction(statements) then
|
|
error("[sky_phone] Could not migrate requestable emergency company profiles.")
|
|
end
|
|
end
|
|
|
|
local function tombstone_removed_companies()
|
|
local profiles = Bridge.Database.Query([[
|
|
SELECT DISTINCT profile.`company_id`
|
|
FROM `sky_phone_company_profiles` profile
|
|
INNER JOIN `sky_phone_company_requests` request ON request.`company_id` = profile.`company_id`
|
|
WHERE request.`status` NOT IN ('completed', 'cancelled')
|
|
]], {})
|
|
for _, profile in ipairs(profiles) do
|
|
if not definitions[profile.company_id] then
|
|
local mutation_token = uuid()
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `status` = 'cancelled', `revision` = `revision` + 1,
|
|
`customer_unread` = `customer_unread` + 1,
|
|
`cancelled_at` = CURRENT_TIMESTAMP, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `status` NOT IN ('completed', 'cancelled')
|
|
]],
|
|
params = { mutation_token, profile.company_id },
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `to_status`, `detail`)
|
|
SELECT UUID(), `id`, 'cancelled', 'system', 'cancelled', 'company_removed'
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = { profile.company_id, mutation_token },
|
|
},
|
|
}) then
|
|
error(("[sky_phone] Could not tombstone removed company '%s'."):format(
|
|
tostring(profile.company_id)
|
|
))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function service_line_payload(company_id)
|
|
local definition = definitions[company_id]
|
|
if not Config.Companies.Enabled or not definition then
|
|
return nil
|
|
end
|
|
local line = definition.ServiceLine
|
|
return {
|
|
companyId = company_id,
|
|
number = line.Number,
|
|
name = definition.Name,
|
|
canCall = line.CanCall == true,
|
|
canMessage = line.CanMessage == true,
|
|
autoContact = line.AutoContact == true,
|
|
routing = line.Routing,
|
|
icon = definition.Icon,
|
|
}
|
|
end
|
|
|
|
function SkyPhoneCompanies.GetServiceLine(number)
|
|
local normalized = SkyPhoneSimNumber.NormalizeService(number, Config.Sim.NumberLength)
|
|
return normalized and service_line_payload(service_lines_by_number[normalized]) or nil
|
|
end
|
|
|
|
function SkyPhoneCompanies.GetServiceLineForCompany(company_id)
|
|
return type(company_id) == "string" and service_line_payload(company_id) or nil
|
|
end
|
|
|
|
function SkyPhoneCompanies.IsServiceNumber(number)
|
|
local normalized = SkyPhoneSimNumber.NormalizeService(number, Config.Sim.NumberLength)
|
|
return normalized ~= nil and service_lines_by_number[normalized] ~= nil
|
|
end
|
|
|
|
function SkyPhoneCompanies.IsSystemContactNumber(number)
|
|
if not Config.Companies.Enabled then
|
|
return false
|
|
end
|
|
local normalized = SkyPhoneSimNumber.NormalizeService(number, Config.Sim.NumberLength)
|
|
local company_id = normalized and service_lines_by_number[normalized] or nil
|
|
local definition = company_id and definitions[company_id] or nil
|
|
return definition ~= nil and definition.Public == true and definition.ServiceLine.AutoContact == true
|
|
end
|
|
|
|
function SkyPhoneCompanies.GetSystemContacts()
|
|
local contacts = {}
|
|
if not Config.Companies.Enabled then
|
|
return contacts
|
|
end
|
|
for _, company_id in ipairs(definition_ids) do
|
|
local definition = definitions[company_id]
|
|
local line = definition.ServiceLine
|
|
if definition.Public and line.AutoContact then
|
|
contacts[#contacts + 1] = {
|
|
id = "company:" .. company_id,
|
|
companyId = company_id,
|
|
name = definition.Name,
|
|
organization = definition.Name,
|
|
phone_number = line.Number,
|
|
avatar_url = definition.LogoUrl,
|
|
source = "company",
|
|
readonly = true,
|
|
canCall = line.CanCall == true,
|
|
canMessage = line.CanMessage == true,
|
|
verified = definition.Verified == true,
|
|
}
|
|
end
|
|
end
|
|
return contacts
|
|
end
|
|
|
|
function SkyPhoneCompanies.ClearCallAvailability(source)
|
|
call_availability[tonumber(source) or source] = nil
|
|
end
|
|
|
|
local function current_device(source, registered_required)
|
|
local session, error_response = SkyPhone.RequireSession(source)
|
|
if not session then
|
|
return nil, error_response
|
|
end
|
|
local device = SkyPhone.LoadDevice(session.imei)
|
|
if not device then
|
|
return nil, { success = false, error = "request_failed" }
|
|
end
|
|
if not device.sim_id then
|
|
return nil, { success = false, error = "no_sim" }
|
|
end
|
|
if registered_required and (device.sim_type ~= "registered" or not device.registered_at) then
|
|
return nil, { success = false, error = "anonymous_sim" }
|
|
end
|
|
return device
|
|
end
|
|
|
|
local function membership(source)
|
|
local job = Bridge.Framework.GetJob(source)
|
|
local company_id = definitions_by_job[job.name]
|
|
if not company_id then
|
|
return nil
|
|
end
|
|
return {
|
|
company_id = company_id,
|
|
definition = definitions[company_id],
|
|
grade = tonumber(job.grade) or 0,
|
|
grade_label = job.gradeLabel or job.label or "",
|
|
}
|
|
end
|
|
|
|
local function require_permission(source, permission)
|
|
local member = membership(source)
|
|
if not member then
|
|
return nil, { success = false, error = "not_authorized" }
|
|
end
|
|
local minimum = permission_grade(member.definition, permission)
|
|
if not minimum or member.grade < minimum then
|
|
return nil, { success = false, error = "not_authorized" }
|
|
end
|
|
local identifier = Bridge.Framework.GetIdentifier(source)
|
|
if type(identifier) ~= "string" or identifier == "" then
|
|
return nil, { success = false, error = "not_authorized" }
|
|
end
|
|
member.identifier = identifier
|
|
return member
|
|
end
|
|
|
|
local function call_member(source)
|
|
local member = membership(source)
|
|
if not member then
|
|
return nil
|
|
end
|
|
local minimum = tonumber(member.definition.ServiceLine.MinimumGrade) or 0
|
|
if member.grade < minimum then
|
|
return nil
|
|
end
|
|
return member
|
|
end
|
|
|
|
function SkyPhoneCompanies.CanAnswerCompanyCall(source, company_id, imei, sim_id)
|
|
source = tonumber(source)
|
|
if not Config.Companies.Enabled or not source or type(company_id) ~= "string"
|
|
or type(imei) ~= "string" or type(sim_id) ~= "string"
|
|
then
|
|
return false
|
|
end
|
|
local readiness = call_availability[source]
|
|
local member = readiness and call_member(source) or nil
|
|
return member ~= nil
|
|
and member.company_id == company_id
|
|
and member.definition.ServiceLine.CanCall == true
|
|
and readiness.company_id == company_id
|
|
and readiness.imei == imei
|
|
and readiness.sim_id == sim_id
|
|
end
|
|
|
|
function SkyPhoneCompanies.CanPlaceCompanyCall(source, company_id)
|
|
source = tonumber(source)
|
|
if not Config.Companies.Enabled or not source or type(company_id) ~= "string" then
|
|
return false
|
|
end
|
|
local member = call_member(source)
|
|
return member ~= nil and member.company_id == company_id
|
|
and member.definition.ServiceLine.CanCall == true
|
|
end
|
|
|
|
function SkyPhoneCompanies.GetCallTargets(company_id)
|
|
local targets = {}
|
|
local definition = definitions[company_id]
|
|
if not Config.Companies.Enabled or not definition or not definition.ServiceLine.CanCall then
|
|
return targets
|
|
end
|
|
local online = {}
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
online[tonumber(player_source) or player_source] = true
|
|
end
|
|
for source, readiness in pairs(call_availability) do
|
|
local member = online[source] and call_member(source) or nil
|
|
local device = member and SkyPhone.LoadDevice(readiness.imei) or nil
|
|
local device_slots = device and SkyPhone.FindDeviceSlots(source, readiness.imei) or {}
|
|
local readiness_valid = member and device and device_slots[1]
|
|
and member.company_id == readiness.company_id
|
|
and device.sim_id == readiness.sim_id
|
|
and device.sim_type == "registered"
|
|
and device.registered_at ~= nil
|
|
if not readiness_valid then
|
|
call_availability[source] = nil
|
|
elseif readiness.company_id == company_id then
|
|
targets[#targets + 1] = {
|
|
source = source,
|
|
simId = device.sim_id,
|
|
phoneNumber = device.phone_number,
|
|
imei = device.imei,
|
|
deviceName = device.device_name,
|
|
}
|
|
end
|
|
end
|
|
table.sort(targets, function(left, right)
|
|
return left.source < right.source
|
|
end)
|
|
if #targets < 2 then
|
|
return targets
|
|
end
|
|
local start = (round_robin_positions[company_id] or 0) % #targets + 1
|
|
local ordered = {}
|
|
for offset = 0, #targets - 1 do
|
|
ordered[#ordered + 1] = targets[(start + offset - 1) % #targets + 1]
|
|
end
|
|
round_robin_positions[company_id] = start
|
|
return ordered
|
|
end
|
|
|
|
local function profile_row(company_id)
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT p.`company_id`, p.`description`, p.`district`, p.`location_label`, p.`address`,
|
|
p.`location_x`, p.`location_y`, p.`location_z`, p.`availability`,
|
|
UNIX_TIMESTAMP(p.`availability_updated_at`) AS `availability_updated_at_unix`,
|
|
UNIX_TIMESTAMP(p.`availability_expires_at`) AS `availability_expires_at_unix`,
|
|
p.`logo_media_id`, p.`cover_media_id`, p.`accepts_requests`, p.`revision`,
|
|
UNIX_TIMESTAMP(p.`updated_at`) AS `updated_at_unix`,
|
|
logo.`url` AS `logo_url`, cover.`url` AS `cover_url`
|
|
FROM `sky_phone_company_profiles` p
|
|
LEFT JOIN `sky_phone_media` logo ON logo.`id` = p.`logo_media_id`
|
|
LEFT JOIN `sky_phone_media` cover ON cover.`id` = p.`cover_media_id`
|
|
WHERE p.`company_id` = ?
|
|
LIMIT 1
|
|
]], { company_id })
|
|
return rows[1]
|
|
end
|
|
|
|
local function company_services(company_id, include_inactive)
|
|
local condition = include_inactive and " AND `archived` = 0"
|
|
or " AND `archived` = 0 AND `active` = 1"
|
|
local rows = Bridge.Database.Query(([[
|
|
SELECT `id`, `title`, `description`, `price_text`, `requests_enabled`, `active`
|
|
FROM `sky_phone_company_services`
|
|
WHERE `company_id` = ?%s
|
|
ORDER BY `sort_order`, `title`, `id`
|
|
]]):format(condition), { company_id })
|
|
local services = {}
|
|
for _, row in ipairs(rows) do
|
|
services[#services + 1] = {
|
|
id = row.id,
|
|
title = row.title,
|
|
description = row.description,
|
|
priceText = row.price_text ~= "" and row.price_text or nil,
|
|
acceptsRequests = tonumber(row.requests_enabled) == 1,
|
|
active = tonumber(row.active) == 1,
|
|
}
|
|
end
|
|
return services
|
|
end
|
|
|
|
local function company_hours(company_id)
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `weekday`, `is_closed`, `opens_at`, `closes_at`
|
|
FROM `sky_phone_company_hours`
|
|
WHERE `company_id` = ?
|
|
ORDER BY `weekday`
|
|
]], { company_id })
|
|
local hours = {}
|
|
for _, row in ipairs(rows) do
|
|
hours[#hours + 1] = {
|
|
day = tonumber(row.weekday),
|
|
isClosed = tonumber(row.is_closed) == 1,
|
|
opensAt = row.opens_at,
|
|
closesAt = row.closes_at,
|
|
}
|
|
end
|
|
return hours
|
|
end
|
|
|
|
local function current_announcement(company_id)
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `body`, UNIX_TIMESTAMP(`expires_at`) AS `expires_at_unix`,
|
|
UNIX_TIMESTAMP(`created_at`) AS `created_at_unix`
|
|
FROM `sky_phone_company_announcements`
|
|
WHERE `company_id` = ? AND `active` = 1
|
|
AND (`expires_at` IS NULL OR `expires_at` > CURRENT_TIMESTAMP)
|
|
ORDER BY `created_at` DESC
|
|
LIMIT 1
|
|
]], { company_id })
|
|
local row = rows[1]
|
|
return row and {
|
|
body = row.body,
|
|
expiresAt = iso_time(row.expires_at_unix),
|
|
publishedAt = iso_time(row.created_at_unix),
|
|
} or nil
|
|
end
|
|
|
|
local function company_payload(company_id, include_inactive_services)
|
|
local definition = definitions[company_id]
|
|
local row = definition and profile_row(company_id) or nil
|
|
if not definition or not row then
|
|
return nil
|
|
end
|
|
local services = company_services(company_id, include_inactive_services)
|
|
local availability = row.availability
|
|
local availability_expires = tonumber(row.availability_expires_at_unix)
|
|
if availability_expires and availability_expires <= os.time() then
|
|
availability = definition.DefaultAvailability or "closed"
|
|
end
|
|
local location = nil
|
|
local x = tonumber(row.location_x)
|
|
local y = tonumber(row.location_y)
|
|
local z = tonumber(row.location_z)
|
|
if x and y and z then
|
|
location = {
|
|
address = row.address,
|
|
district = row.district,
|
|
label = row.location_label,
|
|
coords = { x = x, y = y, z = z },
|
|
}
|
|
end
|
|
local line = definition.ServiceLine
|
|
return {
|
|
id = company_id,
|
|
name = definition.Name,
|
|
categoryId = definition.Category,
|
|
categoryName = definition.Category,
|
|
verified = definition.Verified == true,
|
|
description = row.description,
|
|
availability = availability,
|
|
availabilityUpdatedAt = iso_time(row.availability_updated_at_unix)
|
|
or iso_time(row.updated_at_unix),
|
|
acceptsRequests = tonumber(row.accepts_requests) == 1,
|
|
phoneNumber = line and line.Number or nil,
|
|
canCall = line and line.CanCall == true or false,
|
|
canMessage = line and line.CanMessage == true or false,
|
|
location = location,
|
|
logoUrl = row.logo_url or definition.LogoUrl,
|
|
coverUrl = row.cover_url,
|
|
serviceSummary = services[1] and services[1].title or "",
|
|
announcement = current_announcement(company_id),
|
|
services = services,
|
|
hours = company_hours(company_id),
|
|
revision = tonumber(row.revision) or 1,
|
|
updatedAtUnix = tonumber(row.updated_at_unix) or 0,
|
|
}
|
|
end
|
|
|
|
local function public_company(company_id)
|
|
local definition = definitions[company_id]
|
|
if not definition or not definition.Public then
|
|
return nil
|
|
end
|
|
return company_payload(company_id, false)
|
|
end
|
|
|
|
local function category_payloads()
|
|
local categories = {}
|
|
for _, category_id in ipairs(Config.Companies.Categories or {}) do
|
|
categories[#categories + 1] = { id = category_id, name = category_id }
|
|
end
|
|
return categories
|
|
end
|
|
|
|
local function allow_read(source, operation)
|
|
if not Config.Companies.Enabled then
|
|
return nil, { success = false, error = "service_unavailable" }
|
|
end
|
|
local limit = Config.Companies.RateLimits[operation] or Config.Companies.RateLimits.Read
|
|
if not SkyPhone.AllowOperation(source, "companies_" .. operation:lower(), limit, 60) then
|
|
return nil, { success = false, error = "rate_limited" }
|
|
end
|
|
local session, error_response = SkyPhone.RequireSession(source)
|
|
if not session then
|
|
return nil, error_response
|
|
end
|
|
return session
|
|
end
|
|
|
|
local function cleanup_retained_data()
|
|
local cutoff = os.time() - Config.Companies.RetentionDays * 86400
|
|
local success = Bridge.Database.Transaction({
|
|
{
|
|
query = [[
|
|
DELETE FROM `sky_phone_company_requests`
|
|
WHERE `status` IN ('completed', 'cancelled')
|
|
AND COALESCE(`completed_at`, `cancelled_at`, `updated_at`) < FROM_UNIXTIME(?)
|
|
]],
|
|
params = { cutoff },
|
|
},
|
|
{
|
|
query = [[
|
|
DELETE FROM `sky_phone_company_audit`
|
|
WHERE `created_at` < FROM_UNIXTIME(?)
|
|
]],
|
|
params = { cutoff },
|
|
},
|
|
{
|
|
query = [[
|
|
DELETE FROM `sky_phone_company_announcements`
|
|
WHERE (`active` = 0 OR `expires_at` <= CURRENT_TIMESTAMP)
|
|
AND `created_at` < FROM_UNIXTIME(?)
|
|
]],
|
|
params = { cutoff },
|
|
},
|
|
})
|
|
if not success then
|
|
Bridge.Debug("error", "[sky_phone] Companies retention cleanup failed.")
|
|
end
|
|
end
|
|
|
|
local function refresh_runtime_configuration()
|
|
local validated, validation_error = validate_configuration(Config)
|
|
if not validated then
|
|
error(validation_error)
|
|
end
|
|
definitions = validated.definitions
|
|
definition_ids = validated.definition_ids
|
|
definitions_by_job = validated.definitions_by_job
|
|
service_lines_by_number = validated.service_lines_by_number
|
|
seed_companies()
|
|
migrate_requestable_emergency_companies()
|
|
tombstone_removed_companies()
|
|
end
|
|
|
|
refresh_runtime_configuration()
|
|
|
|
AddEventHandler("sky_phone:configurator:serverUpdated", function()
|
|
refresh_runtime_configuration()
|
|
end)
|
|
|
|
cleanup_retained_data()
|
|
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(24 * 60 * 60 * 1000)
|
|
cleanup_retained_data()
|
|
end
|
|
end)
|
|
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(1000)
|
|
local online = {}
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
online[tonumber(player_source) or player_source] = true
|
|
end
|
|
for source, readiness in pairs(call_availability) do
|
|
local member = online[source] and call_member(source) or nil
|
|
if not member or member.company_id ~= readiness.company_id
|
|
or member.definition.ServiceLine.CanCall ~= true
|
|
then
|
|
call_availability[source] = nil
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
local function company_summary(company)
|
|
return {
|
|
id = company.id,
|
|
name = company.name,
|
|
categoryId = company.categoryId,
|
|
categoryName = company.categoryName,
|
|
verified = company.verified,
|
|
description = company.description,
|
|
availability = company.availability,
|
|
availabilityUpdatedAt = company.availabilityUpdatedAt,
|
|
acceptsRequests = company.acceptsRequests,
|
|
phoneNumber = company.phoneNumber,
|
|
canCall = company.canCall,
|
|
canMessage = company.canMessage,
|
|
location = company.location,
|
|
logoUrl = company.logoUrl,
|
|
serviceSummary = company.serviceSummary,
|
|
announcement = company.announcement,
|
|
}
|
|
end
|
|
|
|
local function search_score(company, search)
|
|
if search == "" then
|
|
return 0
|
|
end
|
|
local name = company.name:lower()
|
|
if name:sub(1, #search) == search then
|
|
return 4
|
|
end
|
|
if name:find(search, 1, true) then
|
|
return 3
|
|
end
|
|
local values = {
|
|
company.categoryId,
|
|
company.description,
|
|
company.location and company.location.district or "",
|
|
company.location and company.location.address or "",
|
|
company.serviceSummary,
|
|
}
|
|
for _, value in ipairs(values) do
|
|
if tostring(value):lower():find(search, 1, true) then
|
|
return 1
|
|
end
|
|
end
|
|
for _, service in ipairs(company.services) do
|
|
if service.title:lower():find(search, 1, true)
|
|
or service.description:lower():find(search, 1, true)
|
|
then
|
|
return 1
|
|
end
|
|
end
|
|
return -1
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:list", function(source, data)
|
|
local session, error_response = allow_read(source, "Search")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
data = type(data) == "table" and data or {}
|
|
local search = valid_text(data.search or "", 80, true)
|
|
if not search then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
search = search:lower()
|
|
local category_id = data.categoryId
|
|
if category_id ~= nil then
|
|
local category_valid = false
|
|
for _, configured in ipairs(Config.Companies.Categories or {}) do
|
|
if category_id == configured then
|
|
category_valid = true
|
|
break
|
|
end
|
|
end
|
|
if not category_valid then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
end
|
|
local availability = data.availability
|
|
if availability ~= nil and not Config.Companies.AvailabilityStatuses[availability] then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
if data.acceptsRequests ~= nil and type(data.acceptsRequests) ~= "boolean" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
if data.hasLocation ~= nil and type(data.hasLocation) ~= "boolean" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local sort = data.sort or "relevance"
|
|
if sort ~= "relevance" and sort ~= "name" and sort ~= "updated" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local cursor = data.cursor == nil and 0 or valid_integer(data.cursor, 0, 100000)
|
|
if not cursor then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
|
|
local matches = {}
|
|
for _, company_id in ipairs(definition_ids) do
|
|
local company = public_company(company_id)
|
|
if company then
|
|
local score = search_score(company, search)
|
|
if score >= 0
|
|
and (not category_id or company.categoryId == category_id)
|
|
and (not availability or company.availability == availability)
|
|
and (data.acceptsRequests ~= true or company.acceptsRequests)
|
|
and (data.hasLocation ~= true or company.location ~= nil)
|
|
then
|
|
matches[#matches + 1] = { company = company, score = score }
|
|
end
|
|
end
|
|
end
|
|
table.sort(matches, function(left, right)
|
|
if sort == "updated" and left.company.updatedAtUnix ~= right.company.updatedAtUnix then
|
|
return left.company.updatedAtUnix > right.company.updatedAtUnix
|
|
end
|
|
if sort == "relevance" and left.score ~= right.score then
|
|
return left.score > right.score
|
|
end
|
|
local left_name = left.company.name:lower()
|
|
local right_name = right.company.name:lower()
|
|
return left_name == right_name and left.company.id < right.company.id or left_name < right_name
|
|
end)
|
|
|
|
local companies = {}
|
|
local page_size = math.min(Config.Companies.PageSize, Config.Companies.MaximumPageSize)
|
|
local last_index = math.min(#matches, cursor + page_size)
|
|
for index = cursor + 1, last_index do
|
|
companies[#companies + 1] = company_summary(matches[index].company)
|
|
end
|
|
return {
|
|
success = true,
|
|
data = {
|
|
companies = companies,
|
|
categories = category_payloads(),
|
|
nextCursor = last_index < #matches and tostring(last_index) or nil,
|
|
},
|
|
}
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:get", function(source, data)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local company_id = type(data) == "table" and data.companyId or nil
|
|
local company = type(company_id) == "string" and public_company(company_id) or nil
|
|
if not company then
|
|
return { success = false, error = "company_not_found" }
|
|
end
|
|
company.updatedAtUnix = nil
|
|
return { success = true, data = { company = company } }
|
|
end)
|
|
|
|
local function decode_request_cursor(value)
|
|
if value == nil then
|
|
return nil, nil
|
|
end
|
|
if type(value) ~= "string" or #value > 64 then
|
|
return false, false
|
|
end
|
|
local timestamp, request_id = value:match("^(%d+):(.+)$")
|
|
timestamp = valid_integer(timestamp, 1, 4102444800)
|
|
if not timestamp or not valid_uuid(request_id) then
|
|
return false, false
|
|
end
|
|
return timestamp, request_id
|
|
end
|
|
|
|
local function encode_request_cursor(row)
|
|
return ("%s:%s"):format(tostring(math.floor(tonumber(row.updated_at_unix) or 0)), row.id)
|
|
end
|
|
|
|
local function request_row(request_id)
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT r.`id`, r.`company_id`, r.`service_id`, r.`customer_sim_id`, r.`subject`, r.`description`,
|
|
r.`status`, r.`assigned_identifier`, r.`customer_unread`,
|
|
r.`company_activity_revision`, r.`revision`,
|
|
UNIX_TIMESTAMP(r.`created_at`) AS `created_at_unix`,
|
|
UNIX_TIMESTAMP(r.`updated_at`) AS `updated_at_unix`, service.`title` AS `service_title`,
|
|
logo.`url` AS `company_logo_url`
|
|
FROM `sky_phone_company_requests` r
|
|
LEFT JOIN `sky_phone_company_services` service ON service.`id` = r.`service_id`
|
|
LEFT JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = r.`company_id`
|
|
LEFT JOIN `sky_phone_media` logo ON logo.`id` = profile.`logo_media_id`
|
|
WHERE r.`id` = ?
|
|
LIMIT 1
|
|
]], { request_id })
|
|
return rows[1]
|
|
end
|
|
|
|
local function request_summary(row, audience, identifier)
|
|
local definition = definitions[row.company_id]
|
|
local assigned_label = nil
|
|
if row.assigned_identifier then
|
|
assigned_label = identifier and row.assigned_identifier == identifier and "you" or "assigned"
|
|
end
|
|
local unread_count
|
|
if audience == "customer" then
|
|
unread_count = tonumber(row.customer_unread) or 0
|
|
else
|
|
local relevant = not terminal_statuses[row.status]
|
|
and (row.status == "new" or row.assigned_identifier == identifier)
|
|
unread_count = relevant and math.max(
|
|
0,
|
|
(tonumber(row.company_activity_revision) or 1)
|
|
- (tonumber(row.company_read_revision) or 0)
|
|
) or 0
|
|
end
|
|
return {
|
|
id = row.id,
|
|
companyId = row.company_id,
|
|
companyName = definition and definition.Name or row.company_id,
|
|
companyLogoUrl = row.company_logo_url,
|
|
serviceId = row.service_id,
|
|
serviceName = row.service_title,
|
|
subject = row.subject,
|
|
status = row.status,
|
|
assignedLabel = assigned_label,
|
|
unreadCount = unread_count,
|
|
createdAt = iso_time(row.created_at_unix),
|
|
updatedAt = iso_time(row.updated_at_unix),
|
|
}
|
|
end
|
|
|
|
local function request_access(source, request_id)
|
|
local session, error_response = SkyPhone.RequireSession(source)
|
|
if not session then
|
|
return nil, error_response
|
|
end
|
|
local row = request_row(request_id)
|
|
if not row then
|
|
return nil, { success = false, error = "request_not_found" }
|
|
end
|
|
local device = SkyPhone.LoadDevice(session.imei)
|
|
if not device then
|
|
return nil, { success = false, error = "request_failed" }
|
|
end
|
|
if device.sim_id and device.sim_id == row.customer_sim_id
|
|
and device.sim_type == "registered" and device.registered_at
|
|
then
|
|
return { audience = "customer", row = row, device = device }
|
|
end
|
|
local member = membership(source)
|
|
if not member or member.company_id ~= row.company_id
|
|
or member.grade < permission_grade(member.definition, "WorkQueue")
|
|
then
|
|
return nil, { success = false, error = "request_not_found" }
|
|
end
|
|
local identifier = Bridge.Framework.GetIdentifier(source)
|
|
if type(identifier) ~= "string" or identifier == "" then
|
|
return nil, { success = false, error = "not_authorized" }
|
|
end
|
|
member.identifier = identifier
|
|
return { audience = "company", row = row, device = device, member = member }
|
|
end
|
|
|
|
local function can_handle_request(access)
|
|
if access.audience ~= "company" then
|
|
return false
|
|
end
|
|
return access.row.assigned_identifier == access.member.identifier
|
|
or access.member.grade >= permission_grade(access.member.definition, "Assign")
|
|
end
|
|
|
|
local function request_actions(access)
|
|
local row = access.row
|
|
local definition = definitions[row.company_id]
|
|
local active = not terminal_statuses[row.status]
|
|
if access.audience == "customer" then
|
|
return {
|
|
allowedStatuses = {},
|
|
canAssign = false,
|
|
canCall = definition ~= nil and definition.ServiceLine.CanCall == true,
|
|
canCancel = active,
|
|
canClaim = false,
|
|
canReply = active,
|
|
}
|
|
end
|
|
local handler = can_handle_request(access)
|
|
local allowed = {}
|
|
if handler then
|
|
for _, status in ipairs({ "in_progress", "waiting_customer", "completed", "cancelled" }) do
|
|
if status_transitions[row.status] and status_transitions[row.status][status] then
|
|
allowed[#allowed + 1] = status
|
|
end
|
|
end
|
|
end
|
|
return {
|
|
allowedStatuses = allowed,
|
|
canAssign = active and access.member.grade >= permission_grade(access.member.definition, "Assign"),
|
|
canCall = active
|
|
and access.member.definition.ServiceLine.CanCall == true
|
|
and access.member.grade >= (tonumber(access.member.definition.ServiceLine.MinimumGrade) or 0),
|
|
canCancel = active and handler,
|
|
canClaim = row.status == "new" and not row.assigned_identifier,
|
|
canReply = active and handler,
|
|
}
|
|
end
|
|
|
|
local function request_detail(access)
|
|
local row = request_row(access.row.id)
|
|
if not row then
|
|
return nil
|
|
end
|
|
access.row = row
|
|
if access.audience == "customer" then
|
|
Bridge.Database.Query(
|
|
"UPDATE `sky_phone_company_requests` SET `customer_unread` = 0, `updated_at` = `updated_at` WHERE `id` = ?",
|
|
{ row.id }
|
|
)
|
|
row.customer_unread = 0
|
|
else
|
|
Bridge.Database.Query([[
|
|
INSERT INTO `sky_phone_company_request_reads`
|
|
(`request_id`, `reader_identifier`, `read_revision`)
|
|
VALUES (?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
`read_revision` = GREATEST(`read_revision`, VALUES(`read_revision`)),
|
|
`updated_at` = CURRENT_TIMESTAMP
|
|
]], { row.id, access.member.identifier, row.company_activity_revision })
|
|
row.company_read_revision = row.company_activity_revision
|
|
end
|
|
local messages = Bridge.Database.Query([[
|
|
SELECT `id`, `sender_type`, `sender_identifier`, `sender_sim_id`, `body`,
|
|
UNIX_TIMESTAMP(`created_at`) AS `created_at_unix`
|
|
FROM `sky_phone_company_request_messages`
|
|
WHERE `request_id` = ?
|
|
ORDER BY `created_at`, `id`
|
|
]], { row.id })
|
|
local message_payloads = {}
|
|
for _, message in ipairs(messages) do
|
|
local mine = access.audience == "customer"
|
|
and message.sender_type == "customer" and message.sender_sim_id == row.customer_sim_id
|
|
or access.audience == "company"
|
|
and message.sender_type == "company" and message.sender_identifier == access.member.identifier
|
|
message_payloads[#message_payloads + 1] = {
|
|
id = message.id,
|
|
author = message.sender_type,
|
|
authorLabel = mine and "you" or message.sender_type,
|
|
body = message.body,
|
|
createdAt = iso_time(message.created_at_unix),
|
|
isMine = mine,
|
|
}
|
|
end
|
|
local events = Bridge.Database.Query([[
|
|
SELECT `id`, `event_type`, `to_status`, UNIX_TIMESTAMP(`created_at`) AS `created_at_unix`
|
|
FROM `sky_phone_company_request_events`
|
|
WHERE `request_id` = ?
|
|
ORDER BY `created_at`, `id`
|
|
]], { row.id })
|
|
local event_payloads = {}
|
|
for _, event in ipairs(events) do
|
|
local event_type = event.event_type
|
|
if event_type == "status" then
|
|
event_type = event.to_status == "completed" and "completed" or "status_changed"
|
|
end
|
|
event_payloads[#event_payloads + 1] = {
|
|
id = event.id,
|
|
type = event_type,
|
|
status = event.to_status,
|
|
createdAt = iso_time(event.created_at_unix),
|
|
}
|
|
end
|
|
local media_rows = Bridge.Database.Query([[
|
|
SELECT media.`id`, media.`url`
|
|
FROM `sky_phone_company_request_media` request_media
|
|
INNER JOIN `sky_phone_media` media ON media.`id` = request_media.`media_id`
|
|
WHERE request_media.`request_id` = ?
|
|
ORDER BY request_media.`sort_order`
|
|
]], { row.id })
|
|
local payload = request_summary(
|
|
row,
|
|
access.audience,
|
|
access.member and access.member.identifier or nil
|
|
)
|
|
payload.description = row.description
|
|
payload.revision = tonumber(row.revision) or 1
|
|
local definition = definitions[row.company_id]
|
|
payload.phoneNumber = definition and definition.ServiceLine.Number or nil
|
|
payload.messages = message_payloads
|
|
payload.events = event_payloads
|
|
payload.media = media_rows
|
|
payload.actions = request_actions(access)
|
|
return payload
|
|
end
|
|
|
|
local function list_request_rows(query, parameters, audience, identifier)
|
|
local rows = Bridge.Database.Query(query, parameters)
|
|
local has_more = #rows > Config.Companies.PageSize
|
|
if has_more then
|
|
rows[#rows] = nil
|
|
end
|
|
local requests = {}
|
|
for _, row in ipairs(rows) do
|
|
requests[#requests + 1] = request_summary(row, audience, identifier)
|
|
end
|
|
return requests, has_more and encode_request_cursor(rows[#rows]) or nil
|
|
end
|
|
|
|
local request_list_select = [[
|
|
SELECT r.`id`, r.`company_id`, r.`service_id`, r.`customer_sim_id`, r.`subject`, r.`status`,
|
|
r.`assigned_identifier`, r.`customer_unread`, r.`company_activity_revision`, r.`revision`,
|
|
UNIX_TIMESTAMP(r.`created_at`) AS `created_at_unix`,
|
|
UNIX_TIMESTAMP(r.`updated_at`) AS `updated_at_unix`, service.`title` AS `service_title`,
|
|
logo.`url` AS `company_logo_url`, NULL AS `company_read_revision`
|
|
FROM `sky_phone_company_requests` r
|
|
LEFT JOIN `sky_phone_company_services` service ON service.`id` = r.`service_id`
|
|
LEFT JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = r.`company_id`
|
|
LEFT JOIN `sky_phone_media` logo ON logo.`id` = profile.`logo_media_id`
|
|
]]
|
|
|
|
local company_request_list_select = [[
|
|
SELECT r.`id`, r.`company_id`, r.`service_id`, r.`customer_sim_id`, r.`subject`, r.`status`,
|
|
r.`assigned_identifier`, r.`customer_unread`, r.`company_activity_revision`, r.`revision`,
|
|
UNIX_TIMESTAMP(r.`created_at`) AS `created_at_unix`,
|
|
UNIX_TIMESTAMP(r.`updated_at`) AS `updated_at_unix`, service.`title` AS `service_title`,
|
|
logo.`url` AS `company_logo_url`, company_read.`read_revision` AS `company_read_revision`
|
|
FROM `sky_phone_company_requests` r
|
|
LEFT JOIN `sky_phone_company_services` service ON service.`id` = r.`service_id`
|
|
LEFT JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = r.`company_id`
|
|
LEFT JOIN `sky_phone_media` logo ON logo.`id` = profile.`logo_media_id`
|
|
LEFT JOIN `sky_phone_company_request_reads` company_read
|
|
ON company_read.`request_id` = r.`id` AND company_read.`reader_identifier` = ?
|
|
]]
|
|
|
|
local function context_request_rows(company_id, identifier, own)
|
|
local condition = own
|
|
and " AND r.`assigned_identifier` = ? AND r.`status` NOT IN ('completed', 'cancelled')"
|
|
or ""
|
|
local parameters = { identifier, company_id }
|
|
if own then
|
|
parameters[#parameters + 1] = identifier
|
|
end
|
|
parameters[#parameters + 1] = 4
|
|
local rows = Bridge.Database.Query(company_request_list_select .. ([=[
|
|
WHERE r.`company_id` = ?%s
|
|
ORDER BY r.`updated_at` DESC, r.`id` DESC
|
|
LIMIT ?
|
|
]=]):format(condition), parameters)
|
|
local requests = {}
|
|
for _, row in ipairs(rows) do
|
|
requests[#requests + 1] = request_summary(row, "company", identifier)
|
|
end
|
|
return requests
|
|
end
|
|
|
|
local function work_context(source)
|
|
local member = membership(source)
|
|
if not member or member.grade < permission_grade(member.definition, "WorkQueue") then
|
|
return {
|
|
authorized = false,
|
|
callAvailable = false,
|
|
company = nil,
|
|
metrics = { assigned = 0, completedToday = 0, new = 0, waiting = 0 },
|
|
ownRequests = {},
|
|
recentRequests = {},
|
|
permissions = {
|
|
canAssign = false,
|
|
canManageAnnouncement = false,
|
|
canManageHours = false,
|
|
canManageProfile = false,
|
|
canManageServices = false,
|
|
canSetAvailability = false,
|
|
canTakeCalls = false,
|
|
},
|
|
role = nil,
|
|
unreadCount = 0,
|
|
}
|
|
end
|
|
local identifier = Bridge.Framework.GetIdentifier(source)
|
|
if type(identifier) ~= "string" or identifier == "" then
|
|
return nil
|
|
end
|
|
member.identifier = identifier
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT
|
|
COALESCE(SUM(request.`status` = 'new'), 0) AS `new_count`,
|
|
COALESCE(SUM(request.`assigned_identifier` = ?
|
|
AND request.`status` NOT IN ('completed', 'cancelled')), 0) AS `assigned_count`,
|
|
COALESCE(SUM(request.`status` = 'waiting_customer'), 0) AS `waiting_count`,
|
|
COALESCE(SUM(request.`status` = 'completed'
|
|
AND DATE(request.`completed_at`) = CURRENT_DATE), 0) AS `completed_today`,
|
|
COALESCE(SUM(CASE
|
|
WHEN request.`status` NOT IN ('completed', 'cancelled')
|
|
AND (request.`status` = 'new' OR request.`assigned_identifier` = ?)
|
|
AND COALESCE(company_read.`read_revision`, 0) < request.`company_activity_revision`
|
|
THEN request.`company_activity_revision` - COALESCE(company_read.`read_revision`, 0)
|
|
ELSE 0
|
|
END), 0) AS `unread_count`
|
|
FROM `sky_phone_company_requests` request
|
|
LEFT JOIN `sky_phone_company_request_reads` company_read
|
|
ON company_read.`request_id` = request.`id` AND company_read.`reader_identifier` = ?
|
|
WHERE request.`company_id` = ?
|
|
]], { identifier, identifier, identifier, member.company_id })
|
|
local metrics = rows[1] or {}
|
|
local permissions = {
|
|
canAssign = member.grade >= permission_grade(member.definition, "Assign"),
|
|
canManageAnnouncement = member.grade >= permission_grade(member.definition, "Announcement"),
|
|
canManageHours = member.grade >= permission_grade(member.definition, "Hours"),
|
|
canManageProfile = member.grade >= permission_grade(member.definition, "Profile"),
|
|
canManageServices = member.grade >= permission_grade(member.definition, "Services"),
|
|
canSetAvailability = member.grade >= permission_grade(member.definition, "Availability"),
|
|
canTakeCalls = member.definition.ServiceLine.CanCall == true
|
|
and member.grade >= (tonumber(member.definition.ServiceLine.MinimumGrade) or 0),
|
|
}
|
|
local manager = permissions.canAssign or permissions.canManageAnnouncement
|
|
or permissions.canManageHours or permissions.canManageProfile or permissions.canManageServices
|
|
local readiness = call_availability[source]
|
|
local company = company_payload(member.company_id, true)
|
|
company.updatedAtUnix = nil
|
|
return {
|
|
authorized = true,
|
|
callAvailable = permissions.canTakeCalls and readiness ~= nil
|
|
and readiness.company_id == member.company_id,
|
|
company = company,
|
|
metrics = {
|
|
new = tonumber(metrics.new_count) or 0,
|
|
assigned = tonumber(metrics.assigned_count) or 0,
|
|
waiting = tonumber(metrics.waiting_count) or 0,
|
|
completedToday = tonumber(metrics.completed_today) or 0,
|
|
},
|
|
ownRequests = context_request_rows(member.company_id, identifier, true),
|
|
recentRequests = context_request_rows(member.company_id, identifier, false),
|
|
permissions = permissions,
|
|
role = manager and "manager" or "employee",
|
|
unreadCount = tonumber(metrics.unread_count) or 0,
|
|
}
|
|
end
|
|
|
|
local function notify_sim(sim_id, event_name, payload)
|
|
local devices = Bridge.Database.Query([[
|
|
SELECT d.`imei`, d.`device_name`, settings.`payload` AS `settings`
|
|
FROM `sky_phone_devices` d
|
|
LEFT JOIN `sky_phone_device_data` settings
|
|
ON settings.`device_imei` = d.`imei` AND settings.`namespace` = 'settings'
|
|
WHERE d.`sim_id` = ?
|
|
]], { sim_id })
|
|
for _, device in ipairs(devices) do
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
local target = tonumber(player_source) or player_source
|
|
if SkyPhone.FindDeviceSlots(target, device.imei)[1] then
|
|
local event_payload = {}
|
|
for key, value in pairs(payload) do
|
|
event_payload[key] = value
|
|
end
|
|
event_payload.device = {
|
|
imei = device.imei,
|
|
name = device.device_name,
|
|
settings = device.settings,
|
|
}
|
|
TriggerClientEvent(event_name, target, event_payload)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function notify_source(source, event_name, payload)
|
|
local session = SkyPhone.RequireSession(source)
|
|
if not session then
|
|
return
|
|
end
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT d.`device_name`, settings.`payload` AS `settings`
|
|
FROM `sky_phone_devices` d
|
|
LEFT JOIN `sky_phone_device_data` settings
|
|
ON settings.`device_imei` = d.`imei` AND settings.`namespace` = 'settings'
|
|
WHERE d.`imei` = ?
|
|
LIMIT 1
|
|
]], { session.imei })
|
|
if not rows[1] then
|
|
return
|
|
end
|
|
local event_payload = {}
|
|
for key, value in pairs(payload) do
|
|
event_payload[key] = value
|
|
end
|
|
event_payload.device = {
|
|
imei = session.imei,
|
|
name = rows[1].device_name,
|
|
settings = rows[1].settings,
|
|
}
|
|
TriggerClientEvent(event_name, source, event_payload)
|
|
end
|
|
|
|
local function notify_company(company_id, event_name, payload, excluded_source)
|
|
local definition = definitions[company_id]
|
|
if not definition then
|
|
return
|
|
end
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
local target = tonumber(player_source) or player_source
|
|
if target ~= excluded_source then
|
|
local job = Bridge.Framework.GetJob(target)
|
|
if job.name == definition.Job and (tonumber(job.grade) or 0) >= permission_grade(definition, "WorkQueue") then
|
|
notify_source(target, event_name, payload)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function notify_identifier(identifier, company_id, event_name, payload)
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
local target = tonumber(player_source) or player_source
|
|
local member = membership(target)
|
|
if member and member.company_id == company_id
|
|
and member.grade >= permission_grade(member.definition, "WorkQueue")
|
|
and Bridge.Framework.GetIdentifier(target) == identifier
|
|
then
|
|
notify_source(target, event_name, payload)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function emit_public_change(company_id)
|
|
local definition = definitions[company_id]
|
|
if not definition then
|
|
return
|
|
end
|
|
notify_company(company_id, "sky_phone:companies:changed", {
|
|
area = "work",
|
|
companyId = company_id,
|
|
})
|
|
if not definition.Public then
|
|
return
|
|
end
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
notify_source(tonumber(player_source) or player_source, "sky_phone:companies:changed", {
|
|
area = "directory",
|
|
companyId = company_id,
|
|
})
|
|
end
|
|
end
|
|
|
|
local function emit_request_change(row, customer, company, excluded_source)
|
|
local payload = {
|
|
area = customer and "customer" or "work",
|
|
companyId = row.company_id,
|
|
requestId = row.id,
|
|
}
|
|
if customer then
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:changed", payload)
|
|
end
|
|
if company then
|
|
payload = {
|
|
area = "work",
|
|
companyId = row.company_id,
|
|
requestId = row.id,
|
|
}
|
|
notify_company(row.company_id, "sky_phone:companies:changed", payload, excluded_source)
|
|
end
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:my-requests", function(source, data)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local device, device_error = current_device(source, true)
|
|
if not device then
|
|
return device_error
|
|
end
|
|
data = type(data) == "table" and data or {}
|
|
local list = data.list or "open"
|
|
if list ~= "open" and list ~= "closed" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local cursor_time, cursor_id = decode_request_cursor(data.cursor)
|
|
if cursor_time == false then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local status_condition = list == "open"
|
|
and "r.`status` NOT IN ('completed', 'cancelled')"
|
|
or "r.`status` IN ('completed', 'cancelled')"
|
|
local cursor_condition = ""
|
|
local parameters = { device.sim_id }
|
|
if cursor_time then
|
|
cursor_condition = [[
|
|
AND (r.`updated_at` < FROM_UNIXTIME(?)
|
|
OR (r.`updated_at` = FROM_UNIXTIME(?) AND r.`id` < ?))
|
|
]]
|
|
parameters[#parameters + 1] = cursor_time
|
|
parameters[#parameters + 1] = cursor_time
|
|
parameters[#parameters + 1] = cursor_id
|
|
end
|
|
parameters[#parameters + 1] = Config.Companies.PageSize + 1
|
|
local requests, next_cursor = list_request_rows(request_list_select .. ([=[
|
|
WHERE r.`customer_sim_id` = ? AND %s %s
|
|
ORDER BY r.`updated_at` DESC, r.`id` DESC
|
|
LIMIT ?
|
|
]=]):format(status_condition, cursor_condition), parameters, "customer")
|
|
local unread_rows = Bridge.Database.Query([[
|
|
SELECT COALESCE(SUM(`customer_unread`), 0) AS `unread_count`
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `customer_sim_id` = ?
|
|
]], { device.sim_id })
|
|
return {
|
|
success = true,
|
|
data = {
|
|
requests = requests,
|
|
nextCursor = next_cursor,
|
|
unreadCount = tonumber(unread_rows[1] and unread_rows[1].unread_count) or 0,
|
|
},
|
|
}
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:get-request", function(source, data)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
if not valid_uuid(request_id) then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return access_error
|
|
end
|
|
local request = request_detail(access)
|
|
if not request then
|
|
return { success = false, error = "request_not_found" }
|
|
end
|
|
return { success = true, data = { request = request } }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:work-context", function(source)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local context = work_context(source)
|
|
if not context then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
return { success = true, data = { context = context } }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:work-queue", function(source, data)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local member, member_error = require_permission(source, "WorkQueue")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
data = type(data) == "table" and data or {}
|
|
local filter = data.filter or "new"
|
|
local filters = {
|
|
new = "r.`status` = 'new'",
|
|
assigned = "r.`assigned_identifier` = ? AND r.`status` NOT IN ('completed', 'cancelled')",
|
|
in_progress = "r.`status` = 'in_progress'",
|
|
waiting_customer = "r.`status` = 'waiting_customer'",
|
|
completed = "r.`status` = 'completed'",
|
|
}
|
|
if not filters[filter] then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local cursor_time, cursor_id = decode_request_cursor(data.cursor)
|
|
if cursor_time == false then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local parameters = { member.identifier, member.company_id }
|
|
if filter == "assigned" then
|
|
parameters[#parameters + 1] = member.identifier
|
|
end
|
|
local cursor_condition = ""
|
|
if cursor_time then
|
|
cursor_condition = [[
|
|
AND (r.`updated_at` < FROM_UNIXTIME(?)
|
|
OR (r.`updated_at` = FROM_UNIXTIME(?) AND r.`id` < ?))
|
|
]]
|
|
parameters[#parameters + 1] = cursor_time
|
|
parameters[#parameters + 1] = cursor_time
|
|
parameters[#parameters + 1] = cursor_id
|
|
end
|
|
parameters[#parameters + 1] = Config.Companies.PageSize + 1
|
|
local requests, next_cursor = list_request_rows(company_request_list_select .. ([=[
|
|
WHERE r.`company_id` = ? AND %s %s
|
|
ORDER BY r.`updated_at` DESC, r.`id` DESC
|
|
LIMIT ?
|
|
]=]):format(filters[filter], cursor_condition), parameters, "company", member.identifier)
|
|
return { success = true, data = { requests = requests, nextCursor = next_cursor } }
|
|
end)
|
|
|
|
local function member_token(target, company_id, identifier)
|
|
local entry = member_tokens[target]
|
|
if not entry or entry.company_id ~= company_id or entry.identifier ~= identifier
|
|
or os.time() - entry.created_at > 300
|
|
then
|
|
entry = {
|
|
token = uuid(),
|
|
company_id = company_id,
|
|
identifier = identifier,
|
|
created_at = os.time(),
|
|
}
|
|
member_tokens[target] = entry
|
|
end
|
|
return entry.token
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:list-members", function(source)
|
|
local session, error_response = allow_read(source, "Read")
|
|
if not session then
|
|
return error_response
|
|
end
|
|
local member, member_error = require_permission(source, "Assign")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local members = {}
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
local target = tonumber(player_source) or player_source
|
|
local target_member = membership(target)
|
|
local target_identifier = target_member and Bridge.Framework.GetIdentifier(target) or nil
|
|
if target_member and target_member.company_id == member.company_id
|
|
and target_member.grade >= permission_grade(target_member.definition, "WorkQueue")
|
|
and type(target_identifier) == "string" and target_identifier ~= ""
|
|
then
|
|
local first_name = trim(Bridge.Framework.GetFirstname(target) or "") or ""
|
|
local last_name = trim(Bridge.Framework.GetLastname(target) or "") or ""
|
|
local name = trim(first_name .. " " .. last_name)
|
|
members[#members + 1] = {
|
|
id = member_token(target, member.company_id, target_identifier),
|
|
name = name,
|
|
online = true,
|
|
role = target_member.grade_label,
|
|
}
|
|
end
|
|
end
|
|
table.sort(members, function(left, right)
|
|
return left.name:lower() < right.name:lower()
|
|
end)
|
|
return { success = true, data = { members = members } }
|
|
end)
|
|
|
|
local function allow_mutation(source, operation, limit_name)
|
|
if not Config.Companies.Enabled then
|
|
return false, { success = false, error = "service_unavailable" }
|
|
end
|
|
local limit = Config.Companies.RateLimits[limit_name]
|
|
if not SkyPhone.AllowOperation(source, "companies_" .. operation, limit, 60) then
|
|
return false, { success = false, error = "rate_limited" }
|
|
end
|
|
local session, error_response = SkyPhone.RequireSession(source)
|
|
if not session then
|
|
return false, error_response
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function mutation_request_payload(source, request_id)
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return nil, access_error
|
|
end
|
|
local request = request_detail(access)
|
|
if not request then
|
|
return nil, { success = false, error = "request_not_found" }
|
|
end
|
|
local data = { request = request }
|
|
if access.audience == "company" then
|
|
data.context = work_context(source)
|
|
end
|
|
return data
|
|
end
|
|
|
|
local function notification_payload(kind, area, row)
|
|
return {
|
|
kind = kind,
|
|
area = area,
|
|
companyId = row.company_id,
|
|
requestId = row.id,
|
|
}
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:create-request", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "create_request", "CreateRequest")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local device, device_error = current_device(source, true)
|
|
if not device then
|
|
return device_error
|
|
end
|
|
if type(data) ~= "table" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local company_id = data.companyId
|
|
local definition = type(company_id) == "string" and definitions[company_id] or nil
|
|
if not definition or not definition.Public then
|
|
return { success = false, error = "company_not_found" }
|
|
end
|
|
local subject = valid_text(data.subject, Config.Companies.SubjectMaxLength, false)
|
|
local description = valid_text(data.description, Config.Companies.RequestBodyMaxLength, false)
|
|
if not subject or not description or not valid_service_id(data.serviceId) then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local profiles = Bridge.Database.Query(
|
|
"SELECT `accepts_requests` FROM `sky_phone_company_profiles` WHERE `company_id` = ? LIMIT 1",
|
|
{ company_id }
|
|
)
|
|
if not profiles[1] or tonumber(profiles[1].accepts_requests) ~= 1 then
|
|
return { success = false, error = "invalid_service" }
|
|
end
|
|
local services = Bridge.Database.Query([[
|
|
SELECT `id` FROM `sky_phone_company_services`
|
|
WHERE `id` = ? AND `company_id` = ? AND `archived` = 0
|
|
AND `active` = 1 AND `requests_enabled` = 1
|
|
LIMIT 1
|
|
]], { data.serviceId, company_id })
|
|
if not services[1] then
|
|
return { success = false, error = "invalid_service" }
|
|
end
|
|
local media_ids = data.mediaIds
|
|
if media_ids == nil then
|
|
media_ids = {}
|
|
end
|
|
if not valid_array(media_ids, Config.Companies.MaximumRequestMedia) then
|
|
return { success = false, error = "invalid_media" }
|
|
end
|
|
local media_seen = {}
|
|
local normalized_media = {}
|
|
for _, media_id in ipairs(media_ids) do
|
|
local normalized = valid_integer(media_id, 1, 9007199254740991)
|
|
if not normalized or media_seen[normalized]
|
|
or not SkyPhoneMedia.ResolveOwnedMedia(source, normalized, "photo")
|
|
then
|
|
return { success = false, error = "invalid_media" }
|
|
end
|
|
media_seen[normalized] = true
|
|
normalized_media[#normalized_media + 1] = normalized
|
|
end
|
|
local counts = Bridge.Database.Query([[
|
|
SELECT COUNT(*) AS `count`
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `customer_sim_id` = ? AND `status` NOT IN ('completed', 'cancelled')
|
|
]], { device.sim_id })
|
|
if (tonumber(counts[1] and counts[1].count) or 0) >= Config.Companies.MaximumOpenRequestsPerSim then
|
|
return { success = false, error = "too_many_open_requests" }
|
|
end
|
|
local request_id = uuid()
|
|
local event_id = uuid()
|
|
local statements = {
|
|
{
|
|
query = "UPDATE `sky_phone_sims` SET `updated_at` = `updated_at` WHERE `id` = ?",
|
|
params = { device.sim_id },
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_requests`
|
|
(`id`, `company_id`, `service_id`, `customer_sim_id`, `subject`, `description`)
|
|
SELECT ?, profile.`company_id`, service.`id`, sim.`id`, ?, ?
|
|
FROM `sky_phone_sims` sim
|
|
INNER JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = ?
|
|
INNER JOIN `sky_phone_company_services` service
|
|
ON service.`id` = ? AND service.`company_id` = profile.`company_id`
|
|
WHERE sim.`id` = ? AND profile.`accepts_requests` = 1
|
|
AND service.`archived` = 0 AND service.`active` = 1
|
|
AND service.`requests_enabled` = 1 AND (
|
|
SELECT COUNT(*) FROM `sky_phone_company_requests`
|
|
WHERE `customer_sim_id` = ? AND `status` NOT IN ('completed', 'cancelled')
|
|
) < ?
|
|
]],
|
|
params = {
|
|
request_id,
|
|
subject,
|
|
description,
|
|
company_id,
|
|
data.serviceId,
|
|
device.sim_id,
|
|
device.sim_id,
|
|
Config.Companies.MaximumOpenRequestsPerSim,
|
|
},
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `to_status`)
|
|
SELECT ?, `id`, 'created', 'customer', 'new'
|
|
FROM `sky_phone_company_requests` WHERE `id` = ?
|
|
]],
|
|
params = { event_id, request_id },
|
|
},
|
|
}
|
|
for index, media_id in ipairs(normalized_media) do
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_media` (`request_id`, `media_id`, `sort_order`)
|
|
SELECT `id`, ?, ? FROM `sky_phone_company_requests` WHERE `id` = ?
|
|
]],
|
|
params = { media_id, index, request_id },
|
|
}
|
|
end
|
|
if not Bridge.Database.Transaction(statements) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local row = request_row(request_id)
|
|
if not row then
|
|
local available = Bridge.Database.Query([[
|
|
SELECT service.`id`
|
|
FROM `sky_phone_company_profiles` profile
|
|
INNER JOIN `sky_phone_company_services` service ON service.`company_id` = profile.`company_id`
|
|
WHERE profile.`company_id` = ? AND profile.`accepts_requests` = 1
|
|
AND service.`id` = ? AND service.`archived` = 0
|
|
AND service.`active` = 1 AND service.`requests_enabled` = 1
|
|
LIMIT 1
|
|
]], { company_id, data.serviceId })
|
|
if not available[1] then
|
|
return { success = false, error = "invalid_service" }
|
|
end
|
|
return { success = false, error = "too_many_open_requests" }
|
|
end
|
|
emit_request_change(row, true, true, source)
|
|
notify_company(company_id, "sky_phone:companies:notification", notification_payload(
|
|
"newRequest",
|
|
"work",
|
|
row
|
|
), source)
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:cancel-request", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "cancel_request", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
if not valid_uuid(request_id) or not revision then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return access_error
|
|
end
|
|
if terminal_statuses[access.row.status]
|
|
or (access.audience == "company" and not can_handle_request(access))
|
|
then
|
|
return { success = false, error = "invalid_status" }
|
|
end
|
|
local actor_type = access.audience
|
|
local customer_unread_update = actor_type == "company"
|
|
and ", `customer_unread` = `customer_unread` + 1" or ""
|
|
local mutation_token = uuid()
|
|
local event_id = uuid()
|
|
local event_query
|
|
local event_params
|
|
if actor_type == "customer" then
|
|
event_query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, 'cancelled', 'customer', ?, 'cancelled'
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]]
|
|
event_params = { event_id, access.row.status, request_id, revision + 1, mutation_token }
|
|
else
|
|
event_query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `actor_identifier`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, 'cancelled', 'company', ?, ?, 'cancelled'
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]]
|
|
event_params = {
|
|
event_id,
|
|
access.member.identifier,
|
|
access.row.status,
|
|
request_id,
|
|
revision + 1,
|
|
mutation_token,
|
|
}
|
|
end
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = (([[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `status` = 'cancelled', `revision` = `revision` + 1,
|
|
`cancelled_at` = CURRENT_TIMESTAMP, `mutation_token` = ?%s
|
|
WHERE `id` = ? AND `revision` = ? AND `status` = ?
|
|
]])):format(customer_unread_update),
|
|
params = { mutation_token, request_id, revision, access.row.status },
|
|
},
|
|
{ query = event_query, params = event_params },
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local committed = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_request_events` WHERE `id` = ? LIMIT 1",
|
|
{ event_id }
|
|
)
|
|
if not committed[1] then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
local row = request_row(request_id)
|
|
emit_request_change(row, true, true, source)
|
|
if actor_type == "customer" then
|
|
notify_company(row.company_id, "sky_phone:companies:notification", notification_payload(
|
|
"requestUpdated",
|
|
"work",
|
|
row
|
|
), source)
|
|
else
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:notification", notification_payload(
|
|
"requestUpdated",
|
|
"customer",
|
|
row
|
|
))
|
|
end
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:send-message", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "send_message", "Message")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local body = type(data) == "table" and valid_text(data.body, Config.Companies.MessageMaxLength, false) or nil
|
|
if not valid_uuid(request_id) or not revision or not body then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return access_error
|
|
end
|
|
if terminal_statuses[access.row.status]
|
|
or (access.audience == "company" and not can_handle_request(access))
|
|
then
|
|
return { success = false, error = "invalid_status" }
|
|
end
|
|
local message_id = uuid()
|
|
local mutation_token = uuid()
|
|
local new_status = access.audience == "customer" and access.row.status == "waiting_customer"
|
|
and "in_progress" or access.row.status
|
|
local audience_unread_update = access.audience == "customer"
|
|
and ", `company_activity_revision` = `company_activity_revision` + 1"
|
|
or ", `customer_unread` = `customer_unread` + 1"
|
|
local statements = {
|
|
{
|
|
query = ([[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `status` = ?, `revision` = `revision` + 1, `mutation_token` = ?%s
|
|
WHERE `id` = ? AND `revision` = ? AND `status` = ?
|
|
AND `status` NOT IN ('completed', 'cancelled')
|
|
]]):format(audience_unread_update),
|
|
params = { new_status, mutation_token, request_id, revision, access.row.status },
|
|
},
|
|
}
|
|
if access.audience == "customer" then
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_messages`
|
|
(`id`, `request_id`, `sender_type`, `sender_sim_id`, `body`)
|
|
SELECT ?, `id`, 'customer', ?, ? FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = { message_id, access.row.customer_sim_id, body, request_id, revision + 1, mutation_token },
|
|
}
|
|
else
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_messages`
|
|
(`id`, `request_id`, `sender_type`, `sender_identifier`, `body`)
|
|
SELECT ?, `id`, 'company', ?, ? FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = { message_id, access.member.identifier, body, request_id, revision + 1, mutation_token },
|
|
}
|
|
end
|
|
if new_status ~= access.row.status then
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, 'status', 'customer', ?, ? FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = { uuid(), access.row.status, new_status, request_id, revision + 1, mutation_token },
|
|
}
|
|
end
|
|
if not Bridge.Database.Transaction(statements) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local inserted = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_request_messages` WHERE `id` = ? LIMIT 1",
|
|
{ message_id }
|
|
)
|
|
if not inserted[1] then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
local row = request_row(request_id)
|
|
emit_request_change(row, true, true, source)
|
|
if access.audience == "customer" then
|
|
local notification = notification_payload("newMessage", "work", row)
|
|
if row.assigned_identifier then
|
|
notify_identifier(
|
|
row.assigned_identifier,
|
|
row.company_id,
|
|
"sky_phone:companies:notification",
|
|
notification
|
|
)
|
|
end
|
|
else
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:notification", notification_payload(
|
|
"newMessage",
|
|
"customer",
|
|
row
|
|
))
|
|
end
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:claim-request", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "claim_request", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "WorkQueue")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
if not valid_uuid(request_id) or not revision then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local mutation_token = uuid()
|
|
local event_id = uuid()
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `assigned_identifier` = ?, `status` = 'assigned', `revision` = `revision` + 1,
|
|
`customer_unread` = `customer_unread` + 1, `mutation_token` = ?
|
|
WHERE `id` = ? AND `company_id` = ? AND `revision` = ?
|
|
AND `status` = 'new' AND `assigned_identifier` IS NULL
|
|
]],
|
|
params = { member.identifier, mutation_token, request_id, member.company_id, revision },
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `actor_identifier`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, 'assigned', 'company', ?, 'new', 'assigned'
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = { event_id, member.identifier, request_id, revision + 1, mutation_token },
|
|
},
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local committed = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_request_events` WHERE `id` = ? LIMIT 1",
|
|
{ event_id }
|
|
)
|
|
if not committed[1] then
|
|
local current = Bridge.Database.Query([[
|
|
SELECT `id` FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `company_id` = ?
|
|
LIMIT 1
|
|
]], { request_id, member.company_id })
|
|
return { success = false, error = current[1] and "revision_conflict" or "request_not_found" }
|
|
end
|
|
local row = request_row(request_id)
|
|
emit_request_change(row, true, true, source)
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:notification", notification_payload(
|
|
"assigned",
|
|
"customer",
|
|
row
|
|
))
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
local function resolve_member(member_id, company_id)
|
|
if not valid_uuid(member_id) then
|
|
return nil
|
|
end
|
|
local online = {}
|
|
for _, player_source in ipairs(Bridge.Framework.GetPlayers()) do
|
|
online[tonumber(player_source) or player_source] = true
|
|
end
|
|
for target, token in pairs(member_tokens) do
|
|
if token.token == member_id and token.company_id == company_id and online[target]
|
|
and os.time() - token.created_at <= 300
|
|
then
|
|
local target_member = membership(target)
|
|
if not target_member or target_member.company_id ~= company_id
|
|
or target_member.grade < permission_grade(target_member.definition, "WorkQueue")
|
|
then
|
|
return nil
|
|
end
|
|
local identifier = Bridge.Framework.GetIdentifier(target)
|
|
if type(identifier) ~= "string" or identifier == "" or identifier ~= token.identifier then
|
|
return nil
|
|
end
|
|
return { source = target, identifier = identifier }
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:assign-request", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "assign_request", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Assign")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local target = type(data) == "table" and resolve_member(data.memberId, member.company_id) or nil
|
|
if not valid_uuid(request_id) or not revision or not target then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local row = request_row(request_id)
|
|
if not row or row.company_id ~= member.company_id then
|
|
return { success = false, error = "request_not_found" }
|
|
end
|
|
if terminal_statuses[row.status] then
|
|
return { success = false, error = "invalid_status" }
|
|
end
|
|
if row.assigned_identifier == target.identifier then
|
|
return { success = false, error = "invalid_status" }
|
|
end
|
|
local next_status = row.status == "new" and "assigned" or row.status
|
|
local mutation_token = uuid()
|
|
local event_id = uuid()
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `assigned_identifier` = ?, `status` = ?, `revision` = `revision` + 1,
|
|
`customer_unread` = `customer_unread` + 1,
|
|
`company_activity_revision` = `company_activity_revision` + 1,
|
|
`mutation_token` = ?
|
|
WHERE `id` = ? AND `company_id` = ? AND `revision` = ? AND `status` = ?
|
|
AND `status` NOT IN ('completed', 'cancelled')
|
|
]],
|
|
params = {
|
|
target.identifier,
|
|
next_status,
|
|
mutation_token,
|
|
request_id,
|
|
member.company_id,
|
|
revision,
|
|
row.status,
|
|
},
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `actor_identifier`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, 'assigned', 'company', ?, ?, ?
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = {
|
|
event_id,
|
|
member.identifier,
|
|
row.status,
|
|
next_status,
|
|
request_id,
|
|
revision + 1,
|
|
mutation_token,
|
|
},
|
|
},
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local committed = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_request_events` WHERE `id` = ? LIMIT 1",
|
|
{ event_id }
|
|
)
|
|
if not committed[1] then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
row = request_row(request_id)
|
|
emit_request_change(row, true, true, source)
|
|
notify_identifier(
|
|
target.identifier,
|
|
row.company_id,
|
|
"sky_phone:companies:notification",
|
|
notification_payload("assigned", "work", row)
|
|
)
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:notification", notification_payload(
|
|
"assigned",
|
|
"customer",
|
|
row
|
|
))
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:update-request-status", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "update_request_status", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local status = type(data) == "table" and data.status or nil
|
|
if not valid_uuid(request_id) or not revision or not Config.Companies.Statuses[status] then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return access_error
|
|
end
|
|
if access.audience ~= "company" or not can_handle_request(access) then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
if not status_transitions[access.row.status] or not status_transitions[access.row.status][status] then
|
|
return { success = false, error = "invalid_status" }
|
|
end
|
|
local mutation_token = uuid()
|
|
local event_id = uuid()
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_requests`
|
|
SET `status` = ?, `revision` = `revision` + 1, `customer_unread` = `customer_unread` + 1,
|
|
`completed_at` = CASE WHEN ? = 'completed' THEN CURRENT_TIMESTAMP ELSE `completed_at` END,
|
|
`cancelled_at` = CASE WHEN ? = 'cancelled' THEN CURRENT_TIMESTAMP ELSE `cancelled_at` END,
|
|
`mutation_token` = ?
|
|
WHERE `id` = ? AND `company_id` = ? AND `revision` = ? AND `status` = ?
|
|
]],
|
|
params = {
|
|
status,
|
|
status,
|
|
status,
|
|
mutation_token,
|
|
request_id,
|
|
access.row.company_id,
|
|
revision,
|
|
access.row.status,
|
|
},
|
|
},
|
|
{
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_request_events`
|
|
(`id`, `request_id`, `event_type`, `actor_type`, `actor_identifier`, `from_status`, `to_status`)
|
|
SELECT ?, `id`, ?, 'company', ?, ?, ?
|
|
FROM `sky_phone_company_requests`
|
|
WHERE `id` = ? AND `revision` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = {
|
|
event_id,
|
|
status == "cancelled" and "cancelled" or "status",
|
|
access.member.identifier,
|
|
access.row.status,
|
|
status,
|
|
request_id,
|
|
revision + 1,
|
|
mutation_token,
|
|
},
|
|
},
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
local committed = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_request_events` WHERE `id` = ? LIMIT 1",
|
|
{ event_id }
|
|
)
|
|
if not committed[1] then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
local row = request_row(request_id)
|
|
emit_request_change(row, true, true, source)
|
|
notify_sim(row.customer_sim_id, "sky_phone:companies:notification", notification_payload(
|
|
"requestUpdated",
|
|
"customer",
|
|
row
|
|
))
|
|
local payload, payload_error = mutation_request_payload(source, request_id)
|
|
if not payload then
|
|
return payload_error
|
|
end
|
|
return { success = true, data = payload }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:call-customer", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "call_customer", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local request_id = type(data) == "table" and data.requestId or nil
|
|
if not valid_uuid(request_id) then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local access, access_error = request_access(source, request_id)
|
|
if not access then
|
|
return access_error
|
|
end
|
|
if access.audience ~= "company" or not can_handle_request(access) or terminal_statuses[access.row.status] then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
if not SkyPhoneCompanies.CanPlaceCompanyCall(source, access.row.company_id) then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT sim.`phone_number`
|
|
FROM `sky_phone_company_requests` request
|
|
INNER JOIN `sky_phone_sims` sim ON sim.`id` = request.`customer_sim_id`
|
|
WHERE request.`id` = ? AND request.`company_id` = ?
|
|
LIMIT 1
|
|
]], { request_id, access.row.company_id })
|
|
if not rows[1] then
|
|
return { success = false, error = "call_unavailable" }
|
|
end
|
|
local result = SkyPhoneCalls.StartCompanyCall(source, access.row.company_id, rows[1].phone_number)
|
|
if not result.success and (result.error == "recipient_unavailable" or result.error == "company_unavailable") then
|
|
return { success = false, error = "call_unavailable" }
|
|
end
|
|
return result
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:dial-service-line", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "dial_service_line", "RequestAction")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local phone_number = type(data) == "table" and data.phoneNumber or nil
|
|
if type(phone_number) ~= "string" or phone_number == "" then
|
|
return { success = false, error = "invalid_number" }
|
|
end
|
|
local member = call_member(source)
|
|
if not member or member.definition.ServiceLine.CanCall ~= true then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
return SkyPhoneCalls.StartCompanyCall(source, member.company_id, phone_number)
|
|
end)
|
|
|
|
local function company_mutation_payload(source, company_id)
|
|
local company = company_payload(company_id, true)
|
|
if not company then
|
|
return nil
|
|
end
|
|
company.updatedAtUnix = nil
|
|
return { company = company, context = work_context(source) }
|
|
end
|
|
|
|
local function audit_statement(company_id, identifier, action, target_type, target_id, mutation_token, audit_id)
|
|
return {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_audit`
|
|
(`id`, `company_id`, `actor_identifier`, `action`, `target_type`, `target_id`, `metadata`)
|
|
SELECT ?, `company_id`, ?, ?, ?, ?, ?
|
|
FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]],
|
|
params = {
|
|
audit_id,
|
|
identifier,
|
|
action,
|
|
target_type,
|
|
target_id,
|
|
json.encode({ revisionChecked = true }),
|
|
company_id,
|
|
mutation_token,
|
|
},
|
|
}
|
|
end
|
|
|
|
local function audit_committed(audit_id)
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `id` FROM `sky_phone_company_audit`
|
|
WHERE `id` = ?
|
|
LIMIT 1
|
|
]], { audit_id })
|
|
return rows[1] ~= nil
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:update-availability", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "update_availability", "Profile")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Availability")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local availability = type(data) == "table" and data.availability or nil
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
if not Config.Companies.AvailabilityStatuses[availability] or not revision then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local expiry = parse_expiry(data.expiresAt, Config.Companies.AvailabilityMaximumSeconds)
|
|
if expiry == false then
|
|
return { success = false, error = "invalid_expiration" }
|
|
end
|
|
local mutation_token = uuid()
|
|
local audit_id = uuid()
|
|
local update_query
|
|
local update_params
|
|
if expiry then
|
|
update_query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `availability` = ?, `availability_updated_by` = ?,
|
|
`availability_updated_at` = CURRENT_TIMESTAMP,
|
|
`availability_expires_at` = FROM_UNIXTIME(?),
|
|
`revision` = `revision` + 1, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `revision` = ?
|
|
]]
|
|
update_params = { availability, member.identifier, expiry, mutation_token, member.company_id, revision }
|
|
else
|
|
update_query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `availability` = ?, `availability_updated_by` = ?,
|
|
`availability_updated_at` = CURRENT_TIMESTAMP, `availability_expires_at` = NULL,
|
|
`revision` = `revision` + 1, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `revision` = ?
|
|
]]
|
|
update_params = { availability, member.identifier, mutation_token, member.company_id, revision }
|
|
end
|
|
if not Bridge.Database.Transaction({
|
|
{ query = update_query, params = update_params },
|
|
audit_statement(
|
|
member.company_id,
|
|
member.identifier,
|
|
"update_availability",
|
|
"profile",
|
|
member.company_id,
|
|
mutation_token,
|
|
audit_id
|
|
),
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
if not audit_committed(audit_id) then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
emit_public_change(member.company_id)
|
|
return { success = true, data = company_mutation_payload(source, member.company_id) }
|
|
end)
|
|
|
|
local function media_id_for_profile(source, value)
|
|
local media_id = valid_integer(value, 1, 9007199254740991)
|
|
if not media_id or not SkyPhoneMedia.ResolveOwnedMedia(source, media_id, "photo") then
|
|
return nil
|
|
end
|
|
return media_id
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:update-profile", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "update_profile", "Profile")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Profile")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
if type(data) ~= "table" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local revision = valid_integer(data.revision, 1, 4294967295)
|
|
local description = valid_text(data.description, Config.Companies.ProfileDescriptionMaxLength, true)
|
|
local district = valid_text(data.district, Config.Companies.DistrictMaxLength, true)
|
|
local location_label = valid_text(data.locationLabel or "", Config.Companies.DistrictMaxLength, true)
|
|
local address = valid_text(data.address, Config.Companies.AddressMaxLength, true)
|
|
if not revision or not description or not district or not location_label or not address
|
|
or type(data.acceptsRequests) ~= "boolean"
|
|
then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
if data.phoneNumber ~= nil then
|
|
local number = SkyPhoneSimNumber.NormalizeService(data.phoneNumber, Config.Sim.NumberLength)
|
|
if number ~= member.definition.ServiceLine.Number then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
end
|
|
local set_parts = {
|
|
"`description` = ?",
|
|
"`district` = ?",
|
|
"`location_label` = ?",
|
|
"`address` = ?",
|
|
"`accepts_requests` = ?",
|
|
}
|
|
local parameters = { description, district, location_label, address, data.acceptsRequests and 1 or 0 }
|
|
if data.coords ~= nil then
|
|
if type(data.coords) ~= "table" then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local x = tonumber(data.coords.x)
|
|
local y = tonumber(data.coords.y)
|
|
local z = tonumber(data.coords.z)
|
|
if not x or not y or not z or x ~= x or y ~= y or z ~= z
|
|
or math.abs(x) > 10000 or math.abs(y) > 10000 or math.abs(z) > 2000
|
|
then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
set_parts[#set_parts + 1] = "`location_x` = ?"
|
|
set_parts[#set_parts + 1] = "`location_y` = ?"
|
|
set_parts[#set_parts + 1] = "`location_z` = ?"
|
|
parameters[#parameters + 1] = x
|
|
parameters[#parameters + 1] = y
|
|
parameters[#parameters + 1] = z
|
|
end
|
|
for _, media_field in ipairs({
|
|
{ input = "logoMediaId", column = "logo_media_id" },
|
|
{ input = "coverMediaId", column = "cover_media_id" },
|
|
}) do
|
|
if data[media_field.input] ~= nil then
|
|
local media_id = media_id_for_profile(source, data[media_field.input])
|
|
if not media_id then
|
|
return { success = false, error = "invalid_media" }
|
|
end
|
|
set_parts[#set_parts + 1] = ("`%s` = ?"):format(media_field.column)
|
|
parameters[#parameters + 1] = media_id
|
|
end
|
|
end
|
|
local mutation_token = uuid()
|
|
local audit_id = uuid()
|
|
set_parts[#set_parts + 1] = "`revision` = `revision` + 1"
|
|
set_parts[#set_parts + 1] = "`mutation_token` = ?"
|
|
parameters[#parameters + 1] = mutation_token
|
|
parameters[#parameters + 1] = member.company_id
|
|
parameters[#parameters + 1] = revision
|
|
if not Bridge.Database.Transaction({
|
|
{
|
|
query = ("UPDATE `sky_phone_company_profiles` SET %s WHERE `company_id` = ? AND `revision` = ?")
|
|
:format(table.concat(set_parts, ", ")),
|
|
params = parameters,
|
|
},
|
|
audit_statement(
|
|
member.company_id,
|
|
member.identifier,
|
|
"update_profile",
|
|
"profile",
|
|
member.company_id,
|
|
mutation_token,
|
|
audit_id
|
|
),
|
|
}) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
if not audit_committed(audit_id) then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
emit_public_change(member.company_id)
|
|
return { success = true, data = company_mutation_payload(source, member.company_id) }
|
|
end)
|
|
|
|
local function valid_clock(value)
|
|
if type(value) ~= "string" then
|
|
return false
|
|
end
|
|
local hour, minute = value:match("^(%d%d):(%d%d)$")
|
|
hour = tonumber(hour)
|
|
minute = tonumber(minute)
|
|
return hour and minute and hour <= 23 and minute <= 59
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:update-hours", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "update_hours", "Profile")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Hours")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local hours = type(data) == "table" and data.hours or nil
|
|
if not revision or not valid_array(hours, 7) then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local seen_days = {}
|
|
for _, entry in ipairs(hours) do
|
|
local day = type(entry) == "table" and valid_integer(entry.day, 0, 6) or nil
|
|
if not day or seen_days[day] or type(entry.isClosed) ~= "boolean"
|
|
or (not entry.isClosed and (not valid_clock(entry.opensAt) or not valid_clock(entry.closesAt)
|
|
or entry.opensAt == entry.closesAt))
|
|
then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
seen_days[day] = true
|
|
end
|
|
local mutation_token = uuid()
|
|
local audit_id = uuid()
|
|
local statements = {
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `revision` = `revision` + 1, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `revision` = ?
|
|
]],
|
|
params = { mutation_token, member.company_id, revision },
|
|
},
|
|
{
|
|
query = [[
|
|
DELETE hours FROM `sky_phone_company_hours` hours
|
|
INNER JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = hours.`company_id`
|
|
WHERE hours.`company_id` = ? AND profile.`mutation_token` = ?
|
|
]],
|
|
params = { member.company_id, mutation_token },
|
|
},
|
|
}
|
|
for _, entry in ipairs(hours) do
|
|
local query
|
|
local params
|
|
if entry.isClosed then
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_hours` (`company_id`, `weekday`, `is_closed`)
|
|
SELECT `company_id`, ?, 1 FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]]
|
|
params = { entry.day, member.company_id, mutation_token }
|
|
else
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_hours`
|
|
(`company_id`, `weekday`, `is_closed`, `opens_at`, `closes_at`)
|
|
SELECT `company_id`, ?, 0, ?, ? FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]]
|
|
params = { entry.day, entry.opensAt, entry.closesAt, member.company_id, mutation_token }
|
|
end
|
|
statements[#statements + 1] = { query = query, params = params }
|
|
end
|
|
statements[#statements + 1] = audit_statement(
|
|
member.company_id,
|
|
member.identifier,
|
|
"update_hours",
|
|
"hours",
|
|
member.company_id,
|
|
mutation_token,
|
|
audit_id
|
|
)
|
|
if not Bridge.Database.Transaction(statements) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
if not audit_committed(audit_id) then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
emit_public_change(member.company_id)
|
|
return { success = true, data = company_mutation_payload(source, member.company_id) }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:update-services", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "update_services", "Profile")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Services")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local services = type(data) == "table" and data.services or nil
|
|
if not revision or not valid_array(services, Config.Companies.MaximumServices) then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local existing_rows = Bridge.Database.Query(
|
|
"SELECT `id` FROM `sky_phone_company_services` WHERE `company_id` = ? AND `archived` = 0",
|
|
{ member.company_id }
|
|
)
|
|
local existing = {}
|
|
for _, row in ipairs(existing_rows) do
|
|
existing[row.id] = true
|
|
end
|
|
local normalized = {}
|
|
local seen = {}
|
|
for index, service in ipairs(services) do
|
|
if type(service) ~= "table" or type(service.active) ~= "boolean"
|
|
or type(service.acceptsRequests) ~= "boolean"
|
|
then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local title = valid_text(service.title, Config.Companies.ServiceTitleMaxLength, false)
|
|
local description = valid_text(
|
|
service.description or "",
|
|
Config.Companies.ServiceDescriptionMaxLength,
|
|
true
|
|
)
|
|
local price = service.priceText == nil and ""
|
|
or valid_text(service.priceText, Config.Companies.ServicePriceMaxLength, true)
|
|
if not title or not description or not price then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local service_id = valid_service_id(service.id) and existing[service.id] and service.id or uuid()
|
|
if seen[service_id] then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
seen[service_id] = true
|
|
normalized[#normalized + 1] = {
|
|
id = service_id,
|
|
title = title,
|
|
description = description,
|
|
price = price,
|
|
accepts_requests = service.acceptsRequests,
|
|
active = service.active,
|
|
sort_order = index,
|
|
}
|
|
end
|
|
local mutation_token = uuid()
|
|
local audit_id = uuid()
|
|
local statements = {
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `revision` = `revision` + 1, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `revision` = ?
|
|
]],
|
|
params = { mutation_token, member.company_id, revision },
|
|
},
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_services` service
|
|
INNER JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = service.`company_id`
|
|
SET service.`active` = 0, service.`requests_enabled` = 0, service.`archived` = 1
|
|
WHERE service.`company_id` = ? AND profile.`mutation_token` = ?
|
|
]],
|
|
params = { member.company_id, mutation_token },
|
|
},
|
|
}
|
|
for _, service in ipairs(normalized) do
|
|
statements[#statements + 1] = {
|
|
query = [[
|
|
INSERT INTO `sky_phone_company_services`
|
|
(`id`, `company_id`, `title`, `description`, `price_text`, `requests_enabled`, `active`, `sort_order`)
|
|
SELECT ?, `company_id`, ?, ?, ?, ?, ?, ? FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
ON DUPLICATE KEY UPDATE
|
|
`title` = VALUES(`title`), `description` = VALUES(`description`),
|
|
`price_text` = VALUES(`price_text`), `requests_enabled` = VALUES(`requests_enabled`),
|
|
`active` = VALUES(`active`), `archived` = 0, `sort_order` = VALUES(`sort_order`)
|
|
]],
|
|
params = {
|
|
service.id,
|
|
service.title,
|
|
service.description,
|
|
service.price,
|
|
service.accepts_requests and 1 or 0,
|
|
service.active and 1 or 0,
|
|
service.sort_order,
|
|
member.company_id,
|
|
mutation_token,
|
|
},
|
|
}
|
|
end
|
|
statements[#statements + 1] = audit_statement(
|
|
member.company_id,
|
|
member.identifier,
|
|
"update_services",
|
|
"services",
|
|
member.company_id,
|
|
mutation_token,
|
|
audit_id
|
|
)
|
|
if not Bridge.Database.Transaction(statements) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
if not audit_committed(audit_id) then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
emit_public_change(member.company_id)
|
|
return { success = true, data = company_mutation_payload(source, member.company_id) }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:publish-announcement", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "publish_announcement", "Profile")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
local member, member_error = require_permission(source, "Announcement")
|
|
if not member then
|
|
return member_error
|
|
end
|
|
local revision = type(data) == "table" and valid_integer(data.revision, 1, 4294967295) or nil
|
|
local body = type(data) == "table"
|
|
and valid_text(data.body or "", Config.Companies.AnnouncementBodyMaxLength, true) or nil
|
|
if not revision or body == nil then
|
|
return { success = false, error = "invalid_profile" }
|
|
end
|
|
local expiry = parse_expiry(data.expiresAt, Config.Companies.AnnouncementMaximumSeconds)
|
|
if expiry == false then
|
|
return { success = false, error = "invalid_expiration" }
|
|
end
|
|
local mutation_token = uuid()
|
|
local audit_id = uuid()
|
|
local statements = {
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_profiles`
|
|
SET `revision` = `revision` + 1, `mutation_token` = ?
|
|
WHERE `company_id` = ? AND `revision` = ?
|
|
]],
|
|
params = { mutation_token, member.company_id, revision },
|
|
},
|
|
{
|
|
query = [[
|
|
UPDATE `sky_phone_company_announcements` announcement
|
|
INNER JOIN `sky_phone_company_profiles` profile ON profile.`company_id` = announcement.`company_id`
|
|
SET announcement.`active` = 0
|
|
WHERE announcement.`company_id` = ? AND profile.`mutation_token` = ?
|
|
]],
|
|
params = { member.company_id, mutation_token },
|
|
},
|
|
}
|
|
if body ~= "" then
|
|
local insert_query
|
|
local insert_params
|
|
if expiry then
|
|
insert_query = [[
|
|
INSERT INTO `sky_phone_company_announcements`
|
|
(`id`, `company_id`, `title`, `body`, `created_by`, `expires_at`)
|
|
SELECT ?, `company_id`, '', ?, ?, FROM_UNIXTIME(?) FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]]
|
|
insert_params = { uuid(), body, member.identifier, expiry, member.company_id, mutation_token }
|
|
else
|
|
insert_query = [[
|
|
INSERT INTO `sky_phone_company_announcements`
|
|
(`id`, `company_id`, `title`, `body`, `created_by`)
|
|
SELECT ?, `company_id`, '', ?, ? FROM `sky_phone_company_profiles`
|
|
WHERE `company_id` = ? AND `mutation_token` = ?
|
|
]]
|
|
insert_params = { uuid(), body, member.identifier, member.company_id, mutation_token }
|
|
end
|
|
statements[#statements + 1] = { query = insert_query, params = insert_params }
|
|
end
|
|
statements[#statements + 1] = audit_statement(
|
|
member.company_id,
|
|
member.identifier,
|
|
"publish_announcement",
|
|
"announcement",
|
|
member.company_id,
|
|
mutation_token,
|
|
audit_id
|
|
)
|
|
if not Bridge.Database.Transaction(statements) then
|
|
return { success = false, error = "request_failed" }
|
|
end
|
|
if not audit_committed(audit_id) then
|
|
return { success = false, error = "revision_conflict" }
|
|
end
|
|
emit_public_change(member.company_id)
|
|
return { success = true, data = company_mutation_payload(source, member.company_id) }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:companies:set-call-availability", function(source, data)
|
|
local allowed, rate_error = allow_mutation(source, "set_call_availability", "CallAvailability")
|
|
if not allowed then
|
|
return rate_error
|
|
end
|
|
if type(data) ~= "table" or type(data.available) ~= "boolean" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
if not data.available then
|
|
SkyPhoneCompanies.ClearCallAvailability(source)
|
|
return { success = true, data = { context = work_context(source) } }
|
|
end
|
|
local member = call_member(source)
|
|
if not member or not member.definition.ServiceLine.CanCall then
|
|
return { success = false, error = "not_authorized" }
|
|
end
|
|
local device, device_error = current_device(source, true)
|
|
if not device then
|
|
return device_error
|
|
end
|
|
call_availability[source] = {
|
|
company_id = member.company_id,
|
|
sim_id = device.sim_id,
|
|
imei = device.imei,
|
|
}
|
|
return { success = true, data = { context = work_context(source) } }
|
|
end)
|
|
|
|
AddEventHandler("playerDropped", function()
|
|
SkyPhoneCompanies.ClearCallAvailability(source)
|
|
member_tokens[source] = nil
|
|
end)
|
|
|
|
AddEventHandler("onResourceStop", function(resource_name)
|
|
if resource_name ~= GetCurrentResourceName() then
|
|
return
|
|
end
|
|
call_availability = {}
|
|
round_robin_positions = {}
|
|
member_tokens = {}
|
|
end)
|
|
end)
|