mirror of
https://github.com/sky-systems/sky_phone.git
synced 2026-08-29 14:01:35 +00:00
Dominik
597 lines
22 KiB
Lua
597 lines
22 KiB
Lua
Bridge.Database.AfterMigration("sky_phone", function()
|
|
|
|
local allowed_voice_mimes = {
|
|
["audio/webm"] = true,
|
|
["audio/webm;codecs=opus"] = true,
|
|
}
|
|
|
|
local attachment_assets = {
|
|
gif = {
|
|
celebrate = true,
|
|
hearts = true,
|
|
party = true,
|
|
thumbs_up = true,
|
|
wow = true,
|
|
},
|
|
image = {
|
|
["camera-1"] = true,
|
|
["camera-2"] = true,
|
|
["camera-3"] = true,
|
|
["city-lights"] = true,
|
|
["desert-road"] = true,
|
|
["ocean-air"] = true,
|
|
["sunset-drive"] = true,
|
|
},
|
|
video = {
|
|
["city-loop"] = true,
|
|
["ocean-loop"] = true,
|
|
["sunset-loop"] = true,
|
|
},
|
|
}
|
|
|
|
local attachment_mimes = {
|
|
gif = "image/gif",
|
|
image = "image/jpeg",
|
|
video = "video/webm",
|
|
}
|
|
|
|
local function allowed_media_url(value)
|
|
if type(value) ~= "string" or #value == 0 or #value > Config.Media.UrlMaxLength then
|
|
return false
|
|
end
|
|
local host = value:lower():match("^https://([^/:?#]+)")
|
|
if not host then
|
|
return false
|
|
end
|
|
for _, allowed_host in ipairs(Config.Media.AllowedGifHosts) do
|
|
local suffix = "." .. allowed_host
|
|
if host == allowed_host or host:sub(-#suffix) == suffix then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function valid_attachment_asset(message_type, value)
|
|
return attachment_assets[message_type][value]
|
|
or message_type == "gif" and allowed_media_url(value)
|
|
end
|
|
|
|
local function valid_stored_attachment(message_type, value)
|
|
if valid_attachment_asset(message_type, value) then
|
|
return true
|
|
end
|
|
return (message_type == "image" or message_type == "video")
|
|
and type(value) == "string"
|
|
and #value <= Config.Media.UrlMaxLength
|
|
and value:match("^https://") ~= nil
|
|
end
|
|
|
|
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 an SMS 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 current_device(source)
|
|
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 = "device_not_found" }
|
|
end
|
|
if not device.sim_id then
|
|
return nil, { success = false, error = "no_sim" }
|
|
end
|
|
return device
|
|
end
|
|
|
|
local function shared_contact(device, contact_id)
|
|
if type(contact_id) ~= "string" or contact_id == "" or #contact_id > 36 then
|
|
return nil, "invalid_contact"
|
|
end
|
|
local condition
|
|
local params
|
|
if device.account_id then
|
|
condition = "contact.`account_id` = ?"
|
|
params = { contact_id, tonumber(device.account_id) }
|
|
else
|
|
condition = "contact.`account_id` IS NULL AND contact.`device_imei` = ?"
|
|
params = { contact_id, device.imei }
|
|
end
|
|
local rows = Bridge.Database.Query(([[
|
|
SELECT contact.`name`, contact.`organization`, contact.`phone_number`, media.`url` AS `avatar_url`
|
|
FROM `sky_phone_contacts` contact
|
|
LEFT JOIN `sky_phone_media` media ON media.`id` = contact.`avatar_media_id`
|
|
WHERE contact.`contact_id` = ? AND %s
|
|
LIMIT 1
|
|
]]):format(condition), params)
|
|
local contact = rows[1]
|
|
if not contact then
|
|
return nil, "contact_not_found"
|
|
end
|
|
local name = trim(contact.name)
|
|
local organization = trim(contact.organization)
|
|
local number = SkyPhoneSimNumber.Normalize(
|
|
contact.phone_number,
|
|
Config.Sim.NumberLength,
|
|
Config.Sim.NumberPrefix
|
|
)
|
|
if not name or name == "" or #name > Config.Calls.ContactNameMaxLength
|
|
or (organization and #organization > Config.Calls.ContactNameMaxLength) or not number
|
|
then
|
|
error(("[sky_phone] Contact %s cannot be shared because its stored data is invalid."):format(contact_id))
|
|
end
|
|
local snapshot = {
|
|
avatar_url = contact.avatar_url,
|
|
name = name,
|
|
organization = organization ~= "" and organization or nil,
|
|
phone_number = number,
|
|
}
|
|
return {
|
|
data = snapshot,
|
|
payload = json.encode(snapshot),
|
|
}
|
|
end
|
|
|
|
local function format_message(row)
|
|
row.media_duration_ms = tonumber(row.media_duration_ms)
|
|
row.media_asset_id = nil
|
|
row.contact = nil
|
|
row.share = nil
|
|
if row.message_type == "voice" then
|
|
local waveform = row.media_waveform and json.decode(row.media_waveform) or nil
|
|
if type(waveform) ~= "table" then
|
|
error(("[sky_phone] Voice message %s has an invalid waveform payload."):format(tostring(row.id)))
|
|
end
|
|
row.media_waveform = waveform
|
|
row.media_payload = nil
|
|
elseif row.message_type == "contact" then
|
|
local contact = row.media_payload and json.decode(row.media_payload) or nil
|
|
if type(contact) ~= "table" or type(contact.name) ~= "string"
|
|
or type(contact.phone_number) ~= "string"
|
|
or (contact.avatar_url ~= nil and type(contact.avatar_url) ~= "string")
|
|
or (contact.organization ~= nil and type(contact.organization) ~= "string")
|
|
then
|
|
error(("[sky_phone] Message %s has an invalid contact payload."):format(tostring(row.id)))
|
|
end
|
|
row.contact = contact
|
|
row.media_payload = nil
|
|
row.media_duration_ms = nil
|
|
row.media_mime = nil
|
|
row.media_waveform = nil
|
|
elseif row.message_type == "share" then
|
|
local share = row.media_payload and json.decode(row.media_payload) or nil
|
|
if type(share) ~= "table" or type(share.appId) ~= "string"
|
|
or type(share.kind) ~= "string" or type(share.title) ~= "string"
|
|
or type(share.copyText) ~= "string"
|
|
then
|
|
error(("[sky_phone] Message %s has an invalid share payload."):format(tostring(row.id)))
|
|
end
|
|
row.share = share
|
|
row.media_payload = nil
|
|
row.media_duration_ms = nil
|
|
row.media_mime = nil
|
|
row.media_waveform = nil
|
|
elseif attachment_assets[row.message_type] then
|
|
if not valid_stored_attachment(row.message_type, row.media_payload) then
|
|
error(("[sky_phone] Message %s has an invalid attachment asset."):format(tostring(row.id)))
|
|
end
|
|
row.media_asset_id = row.media_payload
|
|
row.media_payload = nil
|
|
row.media_waveform = nil
|
|
if row.message_type ~= "video" then
|
|
row.media_duration_ms = nil
|
|
end
|
|
else
|
|
row.media_payload = nil
|
|
row.media_duration_ms = nil
|
|
row.media_mime = nil
|
|
row.media_waveform = nil
|
|
end
|
|
return row
|
|
end
|
|
|
|
local function validate_attachment(source, device, message_type, data)
|
|
if type(data.mediaAssetId) ~= "string" then
|
|
return nil
|
|
end
|
|
local payload = data.mediaAssetId
|
|
local built_in_asset = valid_attachment_asset(message_type, payload)
|
|
local mime = built_in_asset and attachment_mimes[message_type] or nil
|
|
if not built_in_asset then
|
|
if message_type == "gif" then
|
|
return nil
|
|
end
|
|
local media_id = tonumber(payload)
|
|
if not media_id or media_id < 1 or media_id ~= math.floor(media_id) then
|
|
return nil
|
|
end
|
|
local condition
|
|
local params
|
|
if device.account_id then
|
|
condition = "`account_id` = ?"
|
|
params = { media_id, tonumber(device.account_id) }
|
|
else
|
|
condition = "`account_id` IS NULL AND `device_imei` = ?"
|
|
params = { media_id, device.imei }
|
|
end
|
|
local rows = Bridge.Database.Query(([[
|
|
SELECT `url`, `media_type`, `mime_type` FROM `sky_phone_media`
|
|
WHERE `id` = ? AND %s
|
|
LIMIT 1
|
|
]]):format(condition), params)
|
|
local media = rows[1]
|
|
local expected_type = message_type == "image" and "photo" or "video"
|
|
if not media or media.media_type ~= expected_type
|
|
or type(media.url) ~= "string"
|
|
or #media.url > Config.Media.UrlMaxLength
|
|
or not media.url:match("^https://")
|
|
then
|
|
Bridge.Debug("warn", ("[sky_phone] Rejected unowned SMS media from source %s."):format(tostring(source)))
|
|
return nil
|
|
end
|
|
payload = media.url
|
|
mime = type(media.mime_type) == "string" and media.mime_type ~= "" and media.mime_type or nil
|
|
end
|
|
local duration = nil
|
|
if message_type == "video" and data.mediaDurationMs ~= nil then
|
|
duration = tonumber(data.mediaDurationMs)
|
|
if not duration or duration < 1000 or duration > Config.Messages.VideoMaxDurationMs then
|
|
return nil
|
|
end
|
|
duration = math.floor(duration)
|
|
end
|
|
return {
|
|
duration = duration,
|
|
mime = mime,
|
|
payload = payload,
|
|
}
|
|
end
|
|
|
|
local function validate_voice(data)
|
|
if type(data.mediaPayload) ~= "string"
|
|
or #data.mediaPayload == 0
|
|
or #data.mediaPayload > Config.Messages.VoiceMaxBase64Length
|
|
or data.mediaPayload:find("[^A-Za-z0-9+/=]") then
|
|
return nil
|
|
end
|
|
if type(data.mediaMime) ~= "string" or not allowed_voice_mimes[data.mediaMime] then
|
|
return nil
|
|
end
|
|
local duration = tonumber(data.mediaDurationMs)
|
|
if not duration or duration < 300 or duration > Config.Messages.VoiceMaxDurationMs then
|
|
return nil
|
|
end
|
|
if type(data.mediaWaveform) ~= "table"
|
|
or #data.mediaWaveform < 8
|
|
or #data.mediaWaveform > Config.Messages.VoiceWaveformSamples then
|
|
return nil
|
|
end
|
|
local waveform = {}
|
|
for index = 1, #data.mediaWaveform do
|
|
local sample = tonumber(data.mediaWaveform[index])
|
|
if not sample or sample < 0 or sample > 1 then
|
|
return nil
|
|
end
|
|
waveform[index] = math.floor(sample * 1000 + 0.5) / 1000
|
|
end
|
|
return {
|
|
duration = math.floor(duration),
|
|
mime = data.mediaMime,
|
|
payload = data.mediaPayload,
|
|
waveform = json.encode(waveform),
|
|
}
|
|
end
|
|
|
|
local function notify_sim(sim_id, event_name, data)
|
|
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 source = tonumber(player_source) or player_source
|
|
if SkyPhone.FindDeviceSlots(source, device.imei)[1] then
|
|
local payload = {}
|
|
for key, value in pairs(data) do
|
|
payload[key] = value
|
|
end
|
|
payload.device = {
|
|
imei = device.imei,
|
|
name = device.device_name,
|
|
settings = device.settings,
|
|
}
|
|
TriggerClientEvent(event_name, source, payload)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
Bridge.Callbacks.Register("sky_phone:messages:conversations", function(source)
|
|
local device, error_response = current_device(source)
|
|
if not device then
|
|
return error_response
|
|
end
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `id`, `sender_sim_id`, `recipient_sim_id`, `sender_number`, `recipient_number`,
|
|
`message_type`, `body`, `read_at`, `created_at`
|
|
FROM `sky_phone_sms_messages`
|
|
WHERE `sender_sim_id` = ? OR `recipient_sim_id` = ?
|
|
ORDER BY `created_at` DESC, `id` DESC LIMIT ?
|
|
]], { device.sim_id, device.sim_id, Config.Messages.ConversationScanLimit })
|
|
local conversations = {}
|
|
local ordered = {}
|
|
for _, row in ipairs(rows) do
|
|
local received = row.recipient_sim_id == device.sim_id
|
|
local number = received and row.sender_number or row.recipient_number
|
|
local conversation = conversations[number]
|
|
if not conversation then
|
|
conversation = {
|
|
phoneNumber = number,
|
|
lastMessage = row.body,
|
|
lastMessageAt = row.created_at,
|
|
lastMessageType = row.message_type,
|
|
unread = 0,
|
|
}
|
|
conversations[number] = conversation
|
|
ordered[#ordered + 1] = conversation
|
|
end
|
|
if received and not row.read_at then
|
|
conversation.unread = conversation.unread + 1
|
|
end
|
|
end
|
|
return { success = true, data = ordered }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:messages:thread", function(source, data)
|
|
if type(data) ~= "table" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local device, error_response = current_device(source)
|
|
if not device then
|
|
return error_response
|
|
end
|
|
local number = SkyPhoneSimNumber.Normalize(data.phoneNumber, Config.Sim.NumberLength, Config.Sim.NumberPrefix)
|
|
if not number then
|
|
return { success = false, error = "invalid_number" }
|
|
end
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT * FROM (
|
|
SELECT `id`, `sender_number`, `recipient_number`, `message_type`, `body`, `media_payload`, `media_mime`,
|
|
`media_duration_ms`, `media_waveform`, `read_at`, `created_at`,
|
|
CASE WHEN `sender_sim_id` = ? THEN 'sent' ELSE 'received' END AS `direction`
|
|
FROM `sky_phone_sms_messages`
|
|
WHERE (`sender_sim_id` = ? AND `recipient_number` = ?)
|
|
OR (`recipient_sim_id` = ? AND `sender_number` = ?)
|
|
ORDER BY `created_at` DESC, `id` DESC LIMIT ?
|
|
) recent_messages
|
|
ORDER BY `created_at` ASC, `id` ASC
|
|
]], { device.sim_id, device.sim_id, number, device.sim_id, number, Config.Messages.ThreadPageSize })
|
|
for index = 1, #rows do
|
|
rows[index] = format_message(rows[index])
|
|
end
|
|
Bridge.Database.Query([[
|
|
UPDATE `sky_phone_sms_messages` SET `read_at` = CURRENT_TIMESTAMP
|
|
WHERE `recipient_sim_id` = ? AND `sender_number` = ? AND `read_at` IS NULL
|
|
]], { device.sim_id, number })
|
|
return { success = true, data = rows }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:messages:delete", function(source, data)
|
|
if not SkyPhone.AllowOperation(source, "message_delete", 10, 60) then
|
|
return { success = false, error = "rate_limited" }
|
|
end
|
|
if type(data) ~= "table" or type(data.phoneNumbers) ~= "table"
|
|
or #data.phoneNumbers == 0 or #data.phoneNumbers > Config.Messages.DeleteBatchSize then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local device, error_response = current_device(source)
|
|
if not device then
|
|
return error_response
|
|
end
|
|
local numbers = {}
|
|
local seen = {}
|
|
for index = 1, #data.phoneNumbers do
|
|
local number = SkyPhoneSimNumber.Normalize(
|
|
data.phoneNumbers[index],
|
|
Config.Sim.NumberLength,
|
|
Config.Sim.NumberPrefix
|
|
)
|
|
if not number then
|
|
return { success = false, error = "invalid_number" }
|
|
end
|
|
if not seen[number] then
|
|
seen[number] = true
|
|
numbers[#numbers + 1] = number
|
|
end
|
|
end
|
|
local placeholders = {}
|
|
for index = 1, #numbers do
|
|
placeholders[index] = "?"
|
|
end
|
|
local values = { device.sim_id }
|
|
for _, number in ipairs(numbers) do
|
|
values[#values + 1] = number
|
|
end
|
|
values[#values + 1] = device.sim_id
|
|
for _, number in ipairs(numbers) do
|
|
values[#values + 1] = number
|
|
end
|
|
local list = table.concat(placeholders, ", ")
|
|
Bridge.Database.Query(([[
|
|
DELETE FROM `sky_phone_sms_messages`
|
|
WHERE (`sender_sim_id` = ? AND `recipient_number` IN (%s))
|
|
OR (`recipient_sim_id` = ? AND `sender_number` IN (%s))
|
|
]]):format(list, list), values)
|
|
TriggerClientEvent("sky_phone:messages:changed", source, {})
|
|
return { success = true }
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:messages:media", function(source, data)
|
|
if not SkyPhone.AllowOperation(source, "message_media", Config.Messages.MediaLoadsPerMinute, 60) then
|
|
return { success = false, error = "rate_limited" }
|
|
end
|
|
if type(data) ~= "table" or type(data.id) ~= "string" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local device, error_response = current_device(source)
|
|
if not device then
|
|
return error_response
|
|
end
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `media_payload`, `media_mime`
|
|
FROM `sky_phone_sms_messages`
|
|
WHERE `id` = ? AND `message_type` = 'voice'
|
|
AND (`sender_sim_id` = ? OR `recipient_sim_id` = ?)
|
|
LIMIT 1
|
|
]], { data.id, device.sim_id, device.sim_id })
|
|
if not rows[1] or type(rows[1].media_payload) ~= "string" then
|
|
return { success = false, error = "message_not_found" }
|
|
end
|
|
return {
|
|
success = true,
|
|
data = {
|
|
mime = rows[1].media_mime,
|
|
payload = rows[1].media_payload,
|
|
},
|
|
}
|
|
end)
|
|
|
|
Bridge.Callbacks.Register("sky_phone:messages:send", function(source, data)
|
|
if not SkyPhone.AllowOperation(source, "message_send", Config.Messages.SendsPerMinute, 60) then
|
|
return { success = false, error = "rate_limited" }
|
|
end
|
|
if type(data) ~= "table" then
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local device, error_response = current_device(source)
|
|
if not device then
|
|
return error_response
|
|
end
|
|
local number = SkyPhoneSimNumber.Normalize(data.phoneNumber, Config.Sim.NumberLength, Config.Sim.NumberPrefix)
|
|
if not number then
|
|
return { success = false, error = "invalid_number" }
|
|
end
|
|
if number == device.phone_number then
|
|
return { success = false, error = "self_message" }
|
|
end
|
|
local message_type = data.messageType or "text"
|
|
local body = trim(data.body) or ""
|
|
local voice = nil
|
|
local attachment = nil
|
|
local contact = nil
|
|
local share = nil
|
|
if message_type == "text" then
|
|
if body == "" or #body > Config.Messages.BodyMaxLength then
|
|
return { success = false, error = "invalid_message" }
|
|
end
|
|
elseif message_type == "voice" then
|
|
voice = validate_voice(data)
|
|
if not voice then
|
|
return { success = false, error = "invalid_voice" }
|
|
end
|
|
body = ""
|
|
elseif message_type == "contact" then
|
|
local contact_error
|
|
contact, contact_error = shared_contact(device, data.contactId)
|
|
if not contact then
|
|
return { success = false, error = contact_error }
|
|
end
|
|
body = contact.data.name
|
|
elseif message_type == "share" then
|
|
local share_error
|
|
local encoded
|
|
share, share_error, encoded = SkyPhoneEasyShare.SanitizeChatPayload(source, data.sharePayload)
|
|
if not share then
|
|
return { success = false, error = share_error or "invalid_payload" }
|
|
end
|
|
if body ~= "" and #body > Config.Messages.BodyMaxLength then
|
|
return { success = false, error = "invalid_message" }
|
|
end
|
|
share = { data = share, payload = encoded }
|
|
body = body ~= "" and body or share.data.title
|
|
elseif attachment_assets[message_type] then
|
|
attachment = validate_attachment(source, device, message_type, data)
|
|
if not attachment then
|
|
return { success = false, error = "invalid_attachment" }
|
|
end
|
|
if body ~= "" and #body > Config.Messages.BodyMaxLength then
|
|
return { success = false, error = "invalid_message" }
|
|
end
|
|
else
|
|
return { success = false, error = "invalid_request" }
|
|
end
|
|
local recipients = Bridge.Database.Query([[
|
|
SELECT s.`id`, s.`phone_number`
|
|
FROM `sky_phone_sims` s
|
|
LEFT JOIN `sky_phone_devices` d ON d.`sim_id` = s.`id`
|
|
WHERE s.`phone_number` = ?
|
|
AND (s.`is_virtual` = 0 OR d.`imei` IS NOT NULL)
|
|
LIMIT 1
|
|
]], { number })
|
|
local recipient = recipients[1]
|
|
if not recipient then
|
|
return { success = false, error = "recipient_not_found" }
|
|
end
|
|
local blocks = Bridge.Database.Query([[
|
|
SELECT 1 AS `blocked`
|
|
FROM `sky_phone_call_blocks`
|
|
WHERE `blocker_sim_id` = ? AND `blocked_sim_id` = ?
|
|
LIMIT 1
|
|
]], { recipient.id, device.sim_id })
|
|
if blocks[1] then
|
|
return { success = false, error = "blocked" }
|
|
end
|
|
local id = uuid()
|
|
Bridge.Database.Query([[
|
|
INSERT INTO `sky_phone_sms_messages`
|
|
(`id`, `sender_sim_id`, `recipient_sim_id`, `sender_number`, `recipient_number`, `message_type`,
|
|
`body`, `media_payload`, `media_mime`, `media_duration_ms`, `media_waveform`)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
]], {
|
|
id,
|
|
device.sim_id,
|
|
recipient.id,
|
|
device.phone_number,
|
|
number,
|
|
message_type,
|
|
body,
|
|
voice and voice.payload or attachment and attachment.payload or contact and contact.payload
|
|
or share and share.payload or nil,
|
|
voice and voice.mime or attachment and attachment.mime or nil,
|
|
voice and voice.duration or attachment and attachment.duration or nil,
|
|
voice and voice.waveform or nil,
|
|
})
|
|
local rows = Bridge.Database.Query([[
|
|
SELECT `id`, `sender_number`, `recipient_number`, `message_type`, `body`, `media_payload`, `media_mime`,
|
|
`media_duration_ms`, `media_waveform`, `read_at`, `created_at`, 'sent' AS `direction`
|
|
FROM `sky_phone_sms_messages` WHERE `id` = ? LIMIT 1
|
|
]], { id })
|
|
local message = format_message(rows[1])
|
|
TriggerClientEvent("sky_phone:messages:changed", source, { phoneNumber = number })
|
|
notify_sim(recipient.id, "sky_phone:messages:new", {
|
|
message = message,
|
|
phoneNumber = device.phone_number,
|
|
sender = device.phone_number,
|
|
voice = message_type == "voice",
|
|
})
|
|
return { success = true, data = message }
|
|
end)
|
|
|
|
end)
|