diff --git a/apps/condo/domains/miniapp/access/SendVoIPStartMessageService.js b/apps/condo/domains/miniapp/access/SendVoIPStartMessageService.js new file mode 100644 index 00000000000..940780522f7 --- /dev/null +++ b/apps/condo/domains/miniapp/access/SendVoIPStartMessageService.js @@ -0,0 +1,22 @@ +const { throwAuthenticationError } = require('@open-condo/keystone/apolloErrorFormatter') + +const { canExecuteServiceAsB2CAppServiceUser } = require('@condo/domains/miniapp/utils/b2cAppServiceUserAccess/server.utils') +const { SERVICE } = require('@condo/domains/user/constants/common') + +async function canSendVoIPStartMessage (args) { + const { authentication: { item: user } } = args + + if (!user) return throwAuthenticationError() + if (user.deletedAt) return false + if (user.isAdmin) return true + + if (user.type === SERVICE) { + return await canExecuteServiceAsB2CAppServiceUser(args) + } + + return false +} + +module.exports = { + canSendVoIPStartMessage, +} \ No newline at end of file diff --git a/apps/condo/domains/miniapp/constants.js b/apps/condo/domains/miniapp/constants.js index df8a9043bf1..03a0a9bbf72 100644 --- a/apps/condo/domains/miniapp/constants.js +++ b/apps/condo/domains/miniapp/constants.js @@ -85,6 +85,7 @@ const ACCESS_TOKEN_WRONG_RIGHT_SET_TYPE = 'ACCESS_TOKEN_WRONG_RIGHT_SET_TYPE' const ACCESS_TOKEN_CONTEXT_DOES_NOT_MATCH_RIGHT_SET = 'ACCESS_TOKEN_CONTEXT_DOES_NOT_MATCH_RIGHT_SET' const ACCESS_TOKEN_SERVICE_USER_DOES_NOT_MATCH_CONTEXT = 'ACCESS_TOKEN_SERVICE_USER_DOES_NOT_MATCH_CONTEXT' const ACCESS_TOKEN_NEGATIVE_TTL = 'ACCESS_TOKEN_NEGATIVE_TTL' +const CALL_DATA_NOT_PROVIDED_ERROR = 'CALL_DATA_NOT_PROVIDED' const MAX_PERMISSION_NAME_LENGTH = 50 const MIN_PERMISSION_NAME_LENGTH = 1 @@ -132,6 +133,9 @@ const ACCESS_TOKEN_SESSION_ID_PREFIX = `${Buffer.from('b2bAccessToken').toString const ACCESS_TOKEN_UPDATE_MANY_CHUNK_SIZE = 500 +const NATIVE_VOIP_TYPE = 'sip' +const B2C_APP_VOIP_TYPE = 'b2cApp' + module.exports = { ALL_APPS_CATEGORY, CONNECTED_APPS_CATEGORY, @@ -207,4 +211,9 @@ module.exports = { DEFAULT_NOTIFICATION_WINDOW_MAX_COUNT, DEFAULT_NOTIFICATION_WINDOW_DURATION_IN_SECONDS, + + CALL_DATA_NOT_PROVIDED_ERROR, + + NATIVE_VOIP_TYPE, + B2C_APP_VOIP_TYPE, } \ No newline at end of file diff --git a/apps/condo/domains/miniapp/gql.js b/apps/condo/domains/miniapp/gql.js index 00aefcfd902..a9215783d34 100644 --- a/apps/condo/domains/miniapp/gql.js +++ b/apps/condo/domains/miniapp/gql.js @@ -29,6 +29,12 @@ const SEND_B2C_APP_PUSH_MESSAGE_MUTATION = gql` } ` +const SEND_VOIP_START_MESSAGE_MUTATION = gql` + mutation sendVoIPStartMessage ($data: SendVoIPStartMessageInput!) { + result: sendVoIPStartMessage(data: $data) { verifiedContactsCount createdMessagesCount erroredMessagesCount } + } +` + const B2B_APP_NEWS_SHARING_CONFIG_FIELDS = `{ publishUrl previewUrl pushNotificationSettings customFormUrl getRecipientsUrl getRecipientsCountersUrl icon { publicUrl } previewPicture { publicUrl } name ${COMMON_FIELDS} }` const B2BAppNewsSharingConfig = generateGqlQueries('B2BAppNewsSharingConfig', B2B_APP_NEWS_SHARING_CONFIG_FIELDS) @@ -135,5 +141,6 @@ module.exports = { B2BAppRoleWithoutEmployeeRole, B2BAppPosIntegrationConfig, B2CAppAccessRightSet, + SEND_VOIP_START_MESSAGE_MUTATION, /* AUTOGENERATE MARKER */ } diff --git a/apps/condo/domains/miniapp/schema/B2CAppAccessRightSet.test.js b/apps/condo/domains/miniapp/schema/B2CAppAccessRightSet.test.js index 31d200aaa53..3a091279abc 100644 --- a/apps/condo/domains/miniapp/schema/B2CAppAccessRightSet.test.js +++ b/apps/condo/domains/miniapp/schema/B2CAppAccessRightSet.test.js @@ -4,7 +4,7 @@ const { faker } = require('@faker-js/faker') -const { makeLoggedInAdminClient, makeClient, UUID_RE } = require('@open-condo/keystone/test.utils') +const { makeLoggedInAdminClient, makeClient, UUID_RE, expectToThrowAccessDeniedErrorToResult } = require('@open-condo/keystone/test.utils') const { expectToThrowAuthenticationErrorToObj, expectToThrowAuthenticationErrorToObjects, expectToThrowAccessDeniedErrorToObj, expectToThrowAccessDeniedErrorToObjects, @@ -12,12 +12,14 @@ const { -const { B2CAppAccessRightSet, createTestB2CAppAccessRightSet, updateTestB2CAppAccessRightSet, createTestB2CAppProperty, updateTestB2CAppProperty, B2CAppProperty } = require('@condo/domains/miniapp/utils/testSchema') +const { B2CAppAccessRightSet, createTestB2CAppAccessRightSet, updateTestB2CAppAccessRightSet, createTestB2CAppProperty, updateTestB2CAppProperty, B2CAppProperty, sendVoIPStartMessageByTestClient, updateTestB2CAppAccessRight } = require('@condo/domains/miniapp/utils/testSchema') const { createTestB2CApp, createTestB2CAppAccessRight } = require('@condo/domains/miniapp/utils/testSchema') +const { FLAT_UNIT_TYPE } = require('@condo/domains/property/constants/common') const { buildFakeAddressAndMeta } = require('@condo/domains/property/utils/testSchema/factories') const { makeClientWithNewRegisteredAndLoggedInUser, makeClientWithSupportUser } = require('@condo/domains/user/utils/testSchema') const { makeClientWithServiceUser } = require('@condo/domains/user/utils/testSchema') + describe('B2CAppAccessRightSet', () => { let admin @@ -304,13 +306,14 @@ describe('B2CAppAccessRightSet', () => { let user let b2cApp let serviceUser + let b2cAccessRight beforeEach(async () => { support = await makeClientWithSupportUser() user = await makeClientWithNewRegisteredAndLoggedInUser() serviceUser = await makeClientWithServiceUser(); - [b2cApp] = await createTestB2CApp(admin) - await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp) + [b2cApp] = await createTestB2CApp(admin); + [b2cAccessRight] = await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp) }) test('B2CAppAccessRightSet', async () => { @@ -418,6 +421,57 @@ describe('B2CAppAccessRightSet', () => { expect(foundB2CAppProperty.id).toEqual(createdB2CAppProperty.id) }) + + test('SendVoIPStartMessageService', async () => { + const args = { + app: { id: b2cApp.id }, + addressKey: faker.datatype.uuid(), + unitName: faker.random.alphaNumeric(8), + unitType: FLAT_UNIT_TYPE, + callData: { + callId: faker.random.alphaNumeric(8), + b2cAppCallData: { + B2CAppContext: faker.random.alphaNumeric(8), + }, + }, + } + + // Can't without access right set + await expectToThrowAccessDeniedErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(serviceUser, args) + }) + + // Can't with access right set and without b2c app property + const [rightSet] = await createTestB2CAppAccessRightSet(support, b2cApp, { canExecuteSendVoIPStartMessage: true }) + await updateTestB2CAppAccessRight(support, b2cAccessRight.id, { accessRightSet: { connect: { id: rightSet.id } } }) + await expectToThrowAccessDeniedErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(serviceUser, args) + }) + + // Can with access right set and b2c app property + const [b2cAppProperty] = await createTestB2CAppProperty(serviceUser, b2cApp) + args.addressKey = b2cAppProperty.addressKey + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, args) + expect(result).toEqual(expect.objectContaining({ + verifiedContactsCount: expect.any(Number), + createdMessagesCount: expect.any(Number), + erroredMessagesCount: expect.any(Number), + })) + + // Can't with access right and another b2c app proeprty + const [anotherB2CApp] = await createTestB2CApp(admin) + const [anotherB2CAppProperty] = await createTestB2CAppProperty(admin, anotherB2CApp) + args.addressKey = anotherB2CAppProperty.addressKey + await expectToThrowAccessDeniedErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(serviceUser, args) + }) + + // Can't for another app + args.app.id = anotherB2CApp.id + await expectToThrowAccessDeniedErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(serviceUser, args) + }) + }) }) }) diff --git a/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.js b/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.js new file mode 100644 index 00000000000..0e38e8067bf --- /dev/null +++ b/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.js @@ -0,0 +1,572 @@ +const get = require('lodash/get') +const omit = require('lodash/omit') + +const { GQLError, GQLErrorCode: { BAD_USER_INPUT } } = require('@open-condo/keystone/errors') +const { getLogger } = require('@open-condo/keystone/logging') +const { checkDvAndSender } = require('@open-condo/keystone/plugins/dvAndSender') +const { GQLCustomSchema, find, getByCondition } = require('@open-condo/keystone/schema') + +const { COMMON_ERRORS } = require('@condo/domains/common/constants/errors') +const access = require('@condo/domains/miniapp/access/SendVoIPStartMessageService') +const { + PROPERTY_NOT_FOUND_ERROR, + APP_NOT_FOUND_ERROR, + DEFAULT_NOTIFICATION_WINDOW_MAX_COUNT, + DEFAULT_NOTIFICATION_WINDOW_DURATION_IN_SECONDS, + CALL_DATA_NOT_PROVIDED_ERROR, + NATIVE_VOIP_TYPE, + B2C_APP_VOIP_TYPE, +} = require('@condo/domains/miniapp/constants') +const { B2CAppProperty, CustomValue } = require('@condo/domains/miniapp/utils/serverSchema') +const { setCallStatus, CALL_STATUS_START_SENT } = require('@condo/domains/miniapp/utils/voip') +const { + MESSAGE_META, + VOIP_INCOMING_CALL_MESSAGE_TYPE, MESSAGE_SENDING_STATUS, +} = require('@condo/domains/notification/constants/constants') +const { sendMessage } = require('@condo/domains/notification/utils/serverSchema') +const { UNIT_TYPES } = require('@condo/domains/property/constants/common') +const { getOldestNonDeletedProperty } = require('@condo/domains/property/utils/serverSchema/helpers') +const { Resident } = require('@condo/domains/resident/utils/serverSchema') +const { RedisGuard } = require('@condo/domains/user/utils/serverSchema/guards') + +const CACHE_TTL = { + DEFAULT: DEFAULT_NOTIFICATION_WINDOW_DURATION_IN_SECONDS, + [VOIP_INCOMING_CALL_MESSAGE_TYPE]: 2, +} + +const POSSIBLE_CUSTOM_FIELD_NAMES = Object.keys(get(MESSAGE_META[VOIP_INCOMING_CALL_MESSAGE_TYPE], 'data', {})).filter(key => key.startsWith('voip')) +const redisGuard = new RedisGuard() + +const logger = getLogger() + +const SERVICE_NAME = 'sendVoIPStartMessage' +const ERRORS = { + PROPERTY_NOT_FOUND: { + mutation: SERVICE_NAME, + variable: ['data', 'addressKey'], + code: BAD_USER_INPUT, + type: PROPERTY_NOT_FOUND_ERROR, + message: 'Unable to find Property or B2CAppProperty by provided addressKey', + messageForUser: `api.miniapp.${SERVICE_NAME}.PROPERTY_NOT_FOUND`, + }, + APP_NOT_FOUND: { + mutation: SERVICE_NAME, + variable: ['data', 'addressKey'], + code: BAD_USER_INPUT, + type: APP_NOT_FOUND_ERROR, + message: 'Unable to find B2CApp.', + messageForUser: `api.miniapp.${SERVICE_NAME}.APP_NOT_FOUND`, + }, + CALL_DATA_NOT_PROVIDED: { + mutation: SERVICE_NAME, + variable: ['data, callData'], + type: CALL_DATA_NOT_PROVIDED_ERROR, + code: BAD_USER_INPUT, + message: '"b2cAppCallData" or "nativeCallData" or both should be provided', + }, + DV_VERSION_MISMATCH: { + ...COMMON_ERRORS.DV_VERSION_MISMATCH, + mutation: SERVICE_NAME, + }, + WRONG_SENDER_FORMAT: { + ...COMMON_ERRORS.WRONG_SENDER_FORMAT, + mutation: SERVICE_NAME, + }, +} + +function logInfo ({ b2cAppId, callId, stats, err }) { + logger.info({ msg: `${SERVICE_NAME} stats`, entityName: 'B2CApp', entityId: b2cAppId, data: { callId, stats }, err: err }) +} + +async function checkLimits ({ context, b2cAppId, logContext }) { + const appSettings = await getByCondition('AppMessageSetting', { + b2cApp: { id: b2cAppId }, + type: VOIP_INCOMING_CALL_MESSAGE_TYPE, + deletedAt: null, + }) + + const searchKey = `${VOIP_INCOMING_CALL_MESSAGE_TYPE}-${b2cAppId}` + const ttl = CACHE_TTL[VOIP_INCOMING_CALL_MESSAGE_TYPE] || CACHE_TTL['DEFAULT'] + + try { + await redisGuard.checkCustomLimitCounters( + `${SERVICE_NAME}-${searchKey}`, + appSettings?.notificationWindowSize ?? ttl, + appSettings?.numberOfNotificationInWindow ?? DEFAULT_NOTIFICATION_WINDOW_MAX_COUNT, + context, + ) + } catch (err) { + logContext.logInfoStats.step = 'check limits' + logInfo({ ...logContext, err: err }) + throw err + } +} + +function getInitialLogContext ({ addressKey, unitName, unitType, app, callData }) { + return { + logInfoStats: { + step: 'init', + addressKey, + unitName, + unitType, + verifiedContactsCount: 0, + residentsCount: 0, + verifiedResidentsCount: 0, + createdMessagesCount: 0, + erroredMessagesCount: 0, + createMessageErrors: [], + isStatusCached: false, + isPropertyFound: false, + isAppFound: false, + }, + b2cAppId: app.id, + callId: callData.callId, + } +} + +async function sendMessageToUser ({ + context, resident, contact, user, + customVoIPValuesByContactId, + sender, dv, b2cApp: { id: b2cAppId, name: b2cAppName }, + callData, +}) { + const customVoIPValues = customVoIPValuesByContactId[contact.id] || {} + + // NOTE(YEgorLu): as in domains/notification/constants/config for VOIP_INCOMING_CALL_MESSAGE_TYPE + let preparedDataArgs = { + B2CAppId: b2cAppId, + B2CAppName: b2cAppName, + residentId: resident.id, + callId: callData.callId, + } + + const needToPasteB2CAppCallData = !callData.nativeCallData || (callData.b2cAppCallData && customVoIPValues.voipType === B2C_APP_VOIP_TYPE) + + if (!needToPasteB2CAppCallData) { + let voipType = customVoIPValues.voipType || NATIVE_VOIP_TYPE + // CustomValue says to use B2C_APP_VOIP_TYPE, but we have no b2cAppCallData + if (voipType === B2C_APP_VOIP_TYPE) { + voipType = NATIVE_VOIP_TYPE + } + + preparedDataArgs = { + ...preparedDataArgs, + voipType: voipType, + voipAddress: callData.nativeCallData.voipAddress, + voipLogin: callData.nativeCallData.voipLogin, + voipPassword: callData.nativeCallData.voipPassword, + voipDtfmCommand: callData.nativeCallData.voipPanels?.[0]?.dtmfCommand, + voipPanels: callData.nativeCallData.voipPanels, + stunServers: callData.nativeCallData.stunServers, + stun: callData.nativeCallData.stunServers?.[0], + codec: callData.nativeCallData.codec, + ...omit(customVoIPValues, 'voipType'), + } + } else { + preparedDataArgs = { + ...preparedDataArgs, + B2CAppContext: callData.b2cAppCallData.B2CAppContext, + } + } + + const requiredMetaData = get(MESSAGE_META[VOIP_INCOMING_CALL_MESSAGE_TYPE], 'data', {}) + const metaData = Object.fromEntries( + Object.keys(requiredMetaData).map((key) => [key, preparedDataArgs[key]]) + ) + + const messageAttrs = { + sender, + type: VOIP_INCOMING_CALL_MESSAGE_TYPE, + to: { user: { id: user.id } }, + meta: { + dv, + title: '', // NOTE(YEgorLu): title and body are rewritten by translations for push type + body: '', + data: metaData, + }, + } + + const result = await sendMessage(context, messageAttrs) + return { resident, contact, user, result } +} + +async function getVerifiedResidentsWithContacts ({ context, logContext, addressKey, unitName, unitType }) { + let verifiedResidentsWithContacts = [] + + const oldestProperty = await getOldestNonDeletedProperty({ addressKey }) + logContext.logInfoStats.step = 'find property' + logContext.logInfoStats.propertyFound = !!oldestProperty + + if (!oldestProperty?.id) { + logInfo(logContext) + return { + verifiedResidentsWithContacts, + earlyReturnValue: { + verifiedContactsCount: 0, + createdMessagesCount: 0, + erroredMessagesCount: 0, + }, + } + } + + const allVerifiedContactsOnUnit = await find('Contact', { + property: { id: oldestProperty.id, deletedAt: null }, + unitName_i: unitName, + unitType: unitType, + isVerified: true, + deletedAt: null, + }) + logContext.logInfoStats.step = 'find contacts' + logContext.logInfoStats.contactsCount = allVerifiedContactsOnUnit.length + + if (!allVerifiedContactsOnUnit.length) { + logInfo(logContext) + return { + verifiedResidentsWithContacts, + earlyReturnValue: { + verifiedContactsCount: 0, + createdMessagesCount: 0, + erroredMessagesCount: 0, + }, + } + } + + const allResidentsOnUnit = await Resident.getAll(context, { + addressKey, + unitName, + unitType, + deletedAt: null, + }, 'id user { id phone }') + logContext.logInfoStats.step = 'find residents' + logContext.logInfoStats.residentsCount = allResidentsOnUnit.length + + if (!allResidentsOnUnit.length) { + logInfo(logContext) + return { + verifiedResidentsWithContacts, + earlyReturnValue: { + verifiedContactsCount: allVerifiedContactsOnUnit.length, + createdMessagesCount: 0, + erroredMessagesCount: 0, + }, + } + } + + const verifiedResidentsWithContactsByPhone = {} + + for (const contact of allVerifiedContactsOnUnit) { + const verifiedResidentWithContact = { contact, resident: null, user: null } + verifiedResidentsWithContacts.push(verifiedResidentWithContact) + verifiedResidentsWithContactsByPhone[verifiedResidentWithContact.contact.phone] = verifiedResidentWithContact + } + + for (const resident of allResidentsOnUnit) { + const phone = resident.user.phone + if (!phone || !verifiedResidentsWithContactsByPhone[phone]) continue + verifiedResidentsWithContactsByPhone[phone].resident = resident + verifiedResidentsWithContactsByPhone[phone].user = resident.user + } + + verifiedResidentsWithContacts = verifiedResidentsWithContacts.filter(({ resident, user, contact }) => !!resident && !!contact && !!user) + + logContext.logInfoStats.step = 'find verified residents' + logContext.logInfoStats.contactsCount = verifiedResidentsWithContacts.length + + return { + verifiedResidentsWithContacts, + earlyReturnValue: { + verifiedContactsCount: allVerifiedContactsOnUnit.length, + createdMessagesCount: 0, + erroredMessagesCount: 0, + }, + } +} + +async function verifyApp ({ context, logContext, addressKey, app }) { + + const b2cAppId = app.id + + const b2cAppProperty = await B2CAppProperty.getOne(context, { + app: { id: b2cAppId, deletedAt: null }, + addressKey: addressKey, + deletedAt: null, + }, 'id app { id name }') + + if (!b2cAppProperty) { + logInfo(logContext) + throw new GQLError(ERRORS.PROPERTY_NOT_FOUND, context) + } + logContext.logInfoStats.isPropertyFound = true + + if (!b2cAppProperty.app) { + logInfo(logContext) + throw new GQLError(ERRORS.APP_NOT_FOUND, context) + } + logContext.logInfoStats.isAppFound = true + + return { b2cAppId, b2cAppName: b2cAppProperty.app.name } +} + +async function getCustomVoIPValuesByContacts ({ context, contactIds }) { + const customVoIPValues = await CustomValue.getAll(context, { + customField: { name_in: POSSIBLE_CUSTOM_FIELD_NAMES, deletedAt: null }, + itemId_in: contactIds, + deletedAt: null, + }, 'id itemId data customField { name }') + return customVoIPValues.reduce((byContactId, customValue) => { + if (!byContactId[customValue.itemId]) byContactId[customValue.itemId] = {} + byContactId[customValue.itemId][customValue.customField.name] = customValue.data + return byContactId + }, {}) +} + +function parseSendMessageResults ({ logContext, sendMessagePromisesResults }) { + const sendMessageStats = sendMessagePromisesResults.map(promiseResult => { + if (promiseResult.status === 'rejected') { + logContext.logInfoStats.erroredMessagesCount++ + logContext.logInfoStats.createMessageErrors.push(promiseResult.reason) + return { error: promiseResult.reason } + } + const { resident, result } = promiseResult.value + + if (result.isDuplicateMessage) { + logContext.logInfoStats.erroredMessagesCount++ + logContext.logInfoStats.createMessageErrors.push(`${resident.id} duplicate message`) + return { error: `${resident.id} duplicate message` } + } + if (result.status !== MESSAGE_SENDING_STATUS) { + logContext.logInfoStats.erroredMessagesCount++ + logContext.logInfoStats.createMessageErrors.push(`${resident.id} invalid status for some reason`) + return { error: `${resident.id} invalid status for some reason` } + } + logContext.logInfoStats.createdMessagesCount++ + return result + }) + + for (const messageStat of sendMessageStats) { + if (messageStat.error) { + logContext.logInfoStats.erroredMessagesCount++ + logContext.logInfoStats.createMessageErrors.push(messageStat.error) + continue + } + logContext.logInfoStats.createdMessagesCount++ + } + + return sendMessageStats +} + +function parseStartingMessagesIdsByUserIdsByMessageResults ({ sendMessagePromisesResults }) { + const startingMessagesIdsByUserIds = {} + for (const promiseResult of sendMessagePromisesResults) { + if (promiseResult.status !== 'fulfilled') { + continue + } + + const { user, result } = promiseResult.value + if (result?.id) { + startingMessagesIdsByUserIds[user.id] = result.id + } + } + + return startingMessagesIdsByUserIds +} + +const SendVoIPStartMessageService = new GQLCustomSchema('SendVoIPStartMessageService', { + types: [ + { + access: true, + type: `input SendVoIPStartMessageVoIPPanelParameters { + """ + Dtmf command used to open the panel + """ + dtmfCommand: String! + """ + Name of a panel to be displayed + """ + name: String + }`, + }, + { + access: true, + type: `input SendVoIPStartMessageDataForCallHandlingByB2CApp { + """ + Data that will be provided to B2CApp. May be stringified JSON + """ + B2CAppContext: String!, + }`, + }, + { + access: true, + type: `input SendVoIPStartMessageDataForCallHandlingByNative { + """ + Address of sip server, which device should connect to + """ + voipAddress: String!, + """ + Login for connection to sip server + """ + voipLogin: String!, + """ + Password for connection to sip server + """ + voipPassword: String!, + """ + Panels and their commands to open. First one must be the main one. Multiple panels are in testing stage right now and may change + """ + voipPanels: [SendVoIPStartMessageVoIPPanelParameters!]! + """ + Stun server urls. Are used to determine device public ip for media streams + """ + stunServers: [String!], + """ + Preferred codec (usually vp8) + """ + codec: String + }`, + }, + { + access: true, + type: `input SendVoIPStartMessageData { + """ + Unique value for each call session between panel and resident (means same for different devices also). + Must be provided for correct work with multiple devices that use same voip call. + F.e. to cancel calls with CANCELED_CALL_MESSAGE_PUSH messages + """ + callId: String!, + """ + If you want your B2CApp to handle incoming VoIP call, provide this argument. + """ + b2cAppCallData: SendVoIPStartMessageDataForCallHandlingByB2CApp, + """ + If you want mobile app to handle call (without your B2CApp), provide this argument. If "b2cAppCallData" and "nativeCallData" are provided together, native call is prioritized. + """ + nativeCallData: SendVoIPStartMessageDataForCallHandlingByNative + }`, + }, + { + access: true, + type: `input SendVoIPStartMessageInput { + dv: Int!, + sender: SenderFieldInput!, + app: B2CAppWhereUniqueInput!, + """ + Should be "addressKey" of B2CAppProperty / Property for which you want to send message + """ + addressKey: String!, + """ + Name of unit, same as in Property map + """ + unitName: String!, + """ + Type of unit, same as in Property map + """ + unitType: SendVoIPStartMessageUnitType!, + callData: SendVoIPStartMessageData! + }`, + }, + { + access: true, + type: `type SendVoIPStartMessageOutput { + """ + Count of all Organization Contacts, which we possibly could've sent messages to + """ + verifiedContactsCount: Int, + """ + Count of Messages that will be sent, one for each verified Resident + """ + createdMessagesCount: Int, + """ + Count of Messages which was not created due to some internal error + """ + erroredMessagesCount: Int + }`, + }, + { + access: true, + type: `enum SendVoIPStartMessageUnitType { ${UNIT_TYPES.join('\n')} }`, + }, + ], + + mutations: [ + { + access: access.canSendVoIPStartMessage, + schema: 'sendVoIPStartMessage(data: SendVoIPStartMessageInput!): SendVoIPStartMessageOutput', + doc: { + summary: 'Mutation sends VOIP_INCOMING_CALL Messages to each verified resident on address + unit. Also caches calls, so mobile app can properly react to cancel calls. ' + + 'You can either provide all data.* arguments so mobile app will use it\'s own app to answer call, or provide just B2CAppContext + callId to use your B2CApp\'s calling app', + errors: omit(ERRORS, 'DV_VERSION_MISMATCH', 'WRONG_SENDER_FORMAT'), + }, + resolver: async (parent, args, context) => { + const { data: argsData } = args + const { dv, sender, app, addressKey, unitName, unitType, callData } = argsData + + if (!callData.b2cAppCallData && !callData.nativeCallData) { + throw new GQLError(ERRORS.CALL_DATA_NOT_PROVIDED, context) + } + + checkDvAndSender(argsData, ERRORS.DV_VERSION_MISMATCH, ERRORS.WRONG_SENDER_FORMAT, context) + + const logContext = getInitialLogContext(argsData) + + // 1) Check B2CApp and B2CAppProperty + const { b2cAppId, b2cAppName } = await verifyApp({ context, logContext, addressKey, app }) + + // 2) Get verified residents + const { verifiedResidentsWithContacts, earlyReturnValue } = await getVerifiedResidentsWithContacts({ context, logContext, addressKey, unitName, unitType }) + if (!verifiedResidentsWithContacts.length) { + return earlyReturnValue + } + const { verifiedContactsCount } = earlyReturnValue + + // 3) Check limits + await checkLimits({ context, logContext, b2cAppId }) + + const customVoIPValuesByContactId = await getCustomVoIPValuesByContacts({ context, contactIds: [...new Set(verifiedResidentsWithContacts.map(({ contact }) => contact.id))] }) + + // 4) Send messages + /** @type {Array>} */ + const sendMessagePromises = verifiedResidentsWithContacts + .map(({ resident, contact, user }) => { + return sendMessageToUser({ + context, resident, contact, user, customVoIPValuesByContactId, + dv, sender, callData, b2cApp: { id: b2cAppId, name: b2cAppName }, + }) + }) + + // 5) Set call status in redis + logContext.logInfoStats.step = 'send messages' + const sendMessageResults = await Promise.allSettled(sendMessagePromises) + const sendMessageStats = parseSendMessageResults({ sendMessagePromisesResults: sendMessageResults, logContext }) + const startingMessagesIdsByUserIds = parseStartingMessagesIdsByUserIdsByMessageResults({ sendMessagePromisesResults: sendMessageResults }) + + if (sendMessageStats.some(stat => !stat.error)) { + logContext.logInfoStats.isStatusCached = await setCallStatus({ + b2cAppId, + callId: callData.callId, + status: CALL_STATUS_START_SENT, + // NOTE(YEgorLu): we can use uniqKey for that: [pushType, b2cAppId, callId, userId, YYYY-MM-DD].join() + // but this would require to check current and previous day/period + // for now lets save it in session, usually we receive cancel message in less than 1 minute anyway + startingMessagesIdsByUserIds: startingMessagesIdsByUserIds, // check uniqKey + }) + } + + logContext.logInfoStats.step = 'result' + logInfo(logContext) + + return { + verifiedContactsCount, + createdMessagesCount: sendMessageStats.filter(stat => !stat.error).length, + erroredMessagesCount: sendMessageStats.filter(stat => !!stat.error).length, + } + }, + }, + ], + +}) + +module.exports = { + SendVoIPStartMessageService, + ERRORS, + CACHE_TTL, +} diff --git a/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.test.js b/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.test.js new file mode 100644 index 00000000000..5da615fc8a5 --- /dev/null +++ b/apps/condo/domains/miniapp/schema/SendVoIPStartMessageService.test.js @@ -0,0 +1,776 @@ +const { faker } = require('@faker-js/faker') + +const { + makeLoggedInAdminClient, + makeClient, + expectToThrowAccessDeniedErrorToResult, + expectToThrowAuthenticationErrorToResult, + expectToThrowGQLErrorToResult, + expectToThrowGraphQLRequestError, +} = require('@open-condo/keystone/test.utils') + +const { createTestContact } = require('@condo/domains/contact/utils/testSchema') +const { + createTestB2CApp, + sendVoIPStartMessageByTestClient, + createTestB2CAppProperty, + createTestB2CAppAccessRight, + createTestB2CAppAccessRightSet, + updateTestB2CAppAccessRight, + createTestB2BApp, + createTestB2BAppContext, + createTestB2BAppAccessRightSet, + createTestB2BAppAccessRight, + createTestCustomValue, + createTestAppMessageSetting, + createTestCustomField, +} = require('@condo/domains/miniapp/utils/testSchema') +const { getCallStatus, CALL_STATUS_START_SENT } = require('@condo/domains/miniapp/utils/voip') +const { + VOIP_INCOMING_CALL_MESSAGE_TYPE, +} = require('@condo/domains/notification/constants/constants') +const { Message } = require('@condo/domains/notification/utils/testSchema') +const { FLAT_UNIT_TYPE } = require('@condo/domains/property/constants/common') +const { makeClientWithResidentAccessAndProperty } = require('@condo/domains/property/utils/testSchema') +const { createTestResident } = require('@condo/domains/resident/utils/testSchema') +const { makeClientWithSupportUser, makeClientWithNewRegisteredAndLoggedInUser, + makeClientWithResidentUser, createTestPhone, + makeClientWithServiceUser, +} = require('@condo/domains/user/utils/testSchema') + +const { ERRORS } = require('./SendVoIPStartMessageService') + +const { NATIVE_VOIP_TYPE, B2C_APP_VOIP_TYPE } = require('../constants') + +async function prepareSingleActor ({ admin, organization, property, unitName, unitType }) { + const phone = createTestPhone() + const userClient = await makeClientWithResidentUser({}, { phone }) + const [contact] = await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: true, + phone: phone, + }) + const [resident] = await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + + return { + user: userClient.user, + contact, + resident, + } +} + +describe('SendVoIPStartMessageService', () => { + let admin + + beforeAll(async () => { + admin = await makeLoggedInAdminClient() + }) + + describe('Access', () => { + let b2cApp + let property + let serviceUser + let b2cAccessRight + + beforeAll(async () => { + const [testB2CApp] = await createTestB2CApp(admin) + b2cApp = testB2CApp + + const { property: testProperty } = await makeClientWithResidentAccessAndProperty() + property = testProperty + await createTestB2CAppProperty(admin, b2cApp, { address: testProperty.address, addressMeta: testProperty.addressMeta }) + serviceUser = await makeClientWithServiceUser(); + [b2cAccessRight] = await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp) + }) + + const TEST_CASES = [ + { name: 'admin can', getClient: () => admin, expectError: null }, + { name: 'support can\'t', getClient: () => makeClientWithSupportUser(), expectError: expectToThrowAccessDeniedErrorToResult }, + { name: 'user can\'t', getClient: () => makeClientWithNewRegisteredAndLoggedInUser(), expectError: expectToThrowAccessDeniedErrorToResult }, + { name: 'anonymous can\'t', getClient: () => makeClient(), expectError: expectToThrowAuthenticationErrorToResult }, + { + name: 'service user without access right set and b2c app property can\'t', + getClient: () => serviceUser, + expectError: expectToThrowAccessDeniedErrorToResult, + }, + { + name: 'service user with access right set and b2c app property can', + getClient: async () => { + const [rightSet] = await createTestB2CAppAccessRightSet(admin, b2cApp, { canExecuteSendVoIPStartMessage: true }) + await updateTestB2CAppAccessRight(admin, b2cAccessRight.id, { accessRightSet: { connect: { id: rightSet.id } } }) + return serviceUser + }, + expectError: null, + }, + ] + + test.each(TEST_CASES)('$name', async ({ getClient, expectError }) => { + const client = await getClient() + const mutate = () => sendVoIPStartMessageByTestClient(client, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: faker.random.alphaNumeric(3), + unitType: FLAT_UNIT_TYPE, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + if (expectError) { + await expectError(async () => await mutate()) + } else { + const [result] = await mutate() + expect(result).toBeDefined() + expect(result.verifiedContactsCount).toBe(0) + expect(result.createdMessagesCount).toBe(0) + expect(result.erroredMessagesCount).toBe(0) + } + }) + }) + + describe('Validation', () => { + + test('should throw error if no app with provided id', async () => { + await expectToThrowGQLErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(admin, { + app: { id: faker.datatype.uuid() }, + addressKey: faker.datatype.uuid(), + unitName: faker.random.alphaNumeric(3), + unitType: FLAT_UNIT_TYPE, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + }, ERRORS.PROPERTY_NOT_FOUND) + }) + + test('should throw error if no b2cappproperty with provided addressKey', async () => { + const [b2cApp] = await createTestB2CApp(admin) + + await expectToThrowGQLErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(admin, { + app: { id: b2cApp.id }, + addressKey: faker.datatype.uuid(), + unitName: faker.random.alphaNumeric(3), + unitType: FLAT_UNIT_TYPE, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + }, ERRORS.PROPERTY_NOT_FOUND) + }) + + test('should throw error if callData does not contain data for b2c or native call', async () => { + const [b2cApp] = await createTestB2CApp(admin) + const { property } = await makeClientWithResidentAccessAndProperty() + await createTestB2CAppProperty(admin, b2cApp, { address: property.address, addressMeta: property.addressMeta }) + + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + await expectToThrowGQLErrorToResult(async () => { + await sendVoIPStartMessageByTestClient(admin, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { + callId: faker.datatype.uuid(), + }, + }) + }, ERRORS.CALL_DATA_NOT_PROVIDED) + }) + + }) + + describe('Logic', () => { + let serviceUser + let b2cAppProperty + let organization + let property + let b2cApp + + beforeAll(async () => { + const [testB2CApp] = await createTestB2CApp(admin) + b2cApp = testB2CApp + + const { organization: testOrganization, property: testProperty } = await makeClientWithResidentAccessAndProperty() + organization = testOrganization + property = testProperty; + [b2cAppProperty] = await createTestB2CAppProperty(admin, b2cApp, { address: testProperty.address, addressMeta: testProperty.addressMeta }) + serviceUser = await makeClientWithServiceUser() + const [accessRightSet] = await createTestB2CAppAccessRightSet(admin, b2cApp, { canExecuteSendVoIPStartMessage: true }) + await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp, { accessRightSet: { connect: { id: accessRightSet.id } } }) + + await createTestAppMessageSetting(admin, { b2cApp, numberOfNotificationInWindow: 1000, type: VOIP_INCOMING_CALL_MESSAGE_TYPE }) + }) + + test('successfully sends VoIP start message when all conditions are met', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + const verifiedContactsCount = 5 + const verifiedResidentsCount = 3 + const notVerifiedResidentsCount = verifiedContactsCount - verifiedResidentsCount + + const prepareDataPromises = [] + + for (let i = 0; i < verifiedContactsCount; i++) { + prepareDataPromises.push((async (admin, organization, property) => { + const phone = createTestPhone() + const userClient = await makeClientWithResidentUser({}, { phone }) + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: true, + phone: phone, + }) + const needToCreateVerifiedResident = i < verifiedResidentsCount + if (needToCreateVerifiedResident) { + await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + } + })(admin, organization, property)) + } + for (let i = 0; i < notVerifiedResidentsCount; i++) { + prepareDataPromises.push((async (admin, property) => { + const userClient = await makeClientWithResidentUser() + await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + })(admin, property)) + } + await Promise.all(prepareDataPromises) + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + + expect(result.verifiedContactsCount).toBe(verifiedContactsCount) + expect(result.createdMessagesCount).toBe(verifiedResidentsCount) + expect(result.erroredMessagesCount).toBe(0) + }) + + test('returns zeroish stats when no verified contacts found on unit', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: false, + }) + const userClient = await makeClientWithResidentUser() + await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + + expect(result.verifiedContactsCount).toBe(0) + expect(result.createdMessagesCount).toBe(0) + expect(result.erroredMessagesCount).toBe(0) + }) + + test('returns zero message attempts when no residents found for verified contacts', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: true, + }) + const userClient = await makeClientWithResidentUser() + await createTestResident(admin, userClient.user, property, { + unitName: faker.random.alphaNumeric(3), + unitType: unitType, + }) + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + + expect(result.verifiedContactsCount).toBe(1) + expect(result.createdMessagesCount).toBe(0) + expect(result.erroredMessagesCount).toBe(0) + }) + + describe('Cache', () => { + test('Saves call status in cache', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + const residentsCount = 3 + const prepareDataPromises = [] + + for (let i = 0; i < residentsCount; i++) { + prepareDataPromises.push((async (admin) => { + const phone = createTestPhone() + const userClient = await makeClientWithResidentUser({}, { phone }) + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: true, + phone: phone, + }) + await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + })(admin)) + } + await Promise.all(prepareDataPromises) + + const callId = faker.datatype.uuid() + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { callId, b2cAppCallData: { B2CAppContext: '' } }, + }) + expect(result.verifiedContactsCount).toBe(residentsCount) + expect(result.createdMessagesCount).toBe(residentsCount) + expect(result.erroredMessagesCount).toBe(0) + + const cache = await getCallStatus({ b2cAppId: b2cApp.id, callId }) + expect(cache).not.toBe(null) + expect(cache.status).toBe(CALL_STATUS_START_SENT) + }) + + test('Saves User.id to Message.id binding', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + const residentsCount = 3 + const prepareDataPromises = [] + const userIds = [] + + for (let i = 0; i < residentsCount; i++) { + prepareDataPromises.push((async (admin) => { + const phone = createTestPhone() + const userClient = await makeClientWithResidentUser({}, { phone }) + userIds.push(userClient.user.id) + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: unitType, + isVerified: true, + phone: phone, + }) + await createTestResident(admin, userClient.user, property, { + unitName: unitName, + unitType: unitType, + }) + })(admin)) + } + await Promise.all(prepareDataPromises) + + const callId = faker.datatype.uuid() + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: { callId, b2cAppCallData: { B2CAppContext: '' } }, + }) + expect(result.verifiedContactsCount).toBe(residentsCount) + expect(result.createdMessagesCount).toBe(residentsCount) + expect(result.erroredMessagesCount).toBe(0) + + const createdMessages = await Message.getAll(admin, { + user: { id_in: userIds }, + type: VOIP_INCOMING_CALL_MESSAGE_TYPE, + }, { first: residentsCount }) + expect(createdMessages).toHaveLength(residentsCount) + const expectedUserIdToMessageId = Object.fromEntries(createdMessages.map(message => ([message.user.id, message.id]))) + + const cache = await getCallStatus({ b2cAppId: b2cApp.id, callId }) + expect(cache).not.toBe(null) + expect(cache.startingMessagesIdsByUserIds).toEqual(expectedUserIdToMessageId) + }) + + test('Does not save status if have no users to send push', async () => { + const unitName = faker.random.alphaNumeric(3) + await createTestContact(admin, organization, property, { + unitName: unitName, + unitType: FLAT_UNIT_TYPE, + isVerified: true, + }) + const callId = faker.datatype.uuid() + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: FLAT_UNIT_TYPE, + callData: { + callId: callId, + b2cAppCallData: { B2CAppContext: '' }, + }, + }) + expect(result.verifiedContactsCount).toBe(1) + expect(result.createdMessagesCount).toBe(0) + expect(result.erroredMessagesCount).toBe(0) + + const cache = await getCallStatus({ b2cAppId: b2cApp.id, callId }) + expect(cache).toBe(null) + }) + }) + + describe('voipType priority', () => { + let customVoIPTypeField + + beforeAll(async () => { + [customVoIPTypeField] = await createTestCustomField(admin, { + name: 'voipType', + modelName: 'Contact', + type: 'String', + validationRules: null, + isVisible: false, + priority: 0, + isUniquePerObject: true, + staffCanRead: false, + sender: { dv: 1, fingerprint: faker.random.alphaNumeric(8) }, + }) + }) + + test('complex case with everything', async () => { + const serviceUser = await makeClientWithServiceUser() + const [b2cApp] = await createTestB2CApp(admin) + const { organization, property } = await makeClientWithResidentAccessAndProperty() + await createTestB2CAppProperty(admin, b2cApp, { address: property.address, addressMeta: property.addressMeta }) + const [accessRightSet] = await createTestB2CAppAccessRightSet(admin, b2cApp, { canExecuteSendVoIPStartMessage: true }) + await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp, { accessRightSet: { connect: { id: accessRightSet.id } } }) + + + const [b2bApp] = await createTestB2BApp(admin) + await createTestB2BAppContext(admin, b2bApp, organization, { status: 'Finished' }) + const [b2bAppAccessRightSet] = await createTestB2BAppAccessRightSet(admin, b2bApp, { canReadOrganizations: true, canReadCustomValues: true, canManageCustomValues: true }) + await createTestB2BAppAccessRight(admin, serviceUser.user, b2bApp, b2bAppAccessRightSet) + + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + + const residentsCount = 4 + const prepareDataPromises = [] + const actors = [] + + for (let i = 0; i < residentsCount; i++) { + prepareDataPromises.push((async ({ admin, organization, property, unitName, unitType }) => { + const actor = await prepareSingleActor({ admin, organization, property, unitName, unitType }) + actors.push(actor) + })({ admin, organization, property, unitName, unitType })) + } + await Promise.all(prepareDataPromises) + + const normalVoIPType = 'sip' + const resident1VoIPType = 'variant2' + const resident2VoIPType = 'variant3' + const resident3VoIPType = B2C_APP_VOIP_TYPE + + const customVoIPTypesWithActors = [ + [resident1VoIPType, actors[0]], + [resident2VoIPType, actors[1]], + [resident3VoIPType, actors[2]], + ] + + for (const [customVoIPType, actor] of customVoIPTypesWithActors) { + await createTestCustomValue(serviceUser, customVoIPTypeField, organization, { + sourceType: 'B2BApp', + data: customVoIPType, + itemId: actor.contact.id, + sourceId: b2bApp.id, + isUniquePerObject: true, + }) + } + + const dataAttrs = { + callId: faker.datatype.uuid(), + b2cAppCallData: { + B2CAppContext: faker.random.alphaNumeric(10), + }, + nativeCallData: { + voipAddress: faker.internet.ip(), + voipLogin: faker.internet.userName(), + voipPassword: faker.internet.password(), + voipPanels: [ + { dtmfCommand: faker.random.alphaNumeric(2), name: faker.random.alphaNumeric(3) }, + { dtmfCommand: faker.random.alphaNumeric(2), name: faker.random.alphaNumeric(3) }, + ], + stunServers: [faker.internet.ip(), faker.internet.ip()], + codec: 'vp8', + }, + } + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: unitType, + callData: dataAttrs, + }) + expect(result.verifiedContactsCount).toBe(residentsCount) + expect(result.createdMessagesCount).toBe(residentsCount) + expect(result.erroredMessagesCount).toBe(0) + + const createdMessages = await Message.getAll(admin, { + user: { id_in: actors.map(actor => actor.user.id) }, + type: VOIP_INCOMING_CALL_MESSAGE_TYPE, + }, { first: residentsCount }) + + expect(createdMessages).toHaveLength(residentsCount) + expect([...new Set(createdMessages.map(msg => msg.user))]).toHaveLength(residentsCount) + + const createdMessagesByResident = createdMessages.reduce((byResident, msg) => { + byResident[msg.meta.data.residentId] = msg + return byResident + }, {}) + expect(Object.keys(createdMessagesByResident)).toEqual(expect.arrayContaining(actors.map(actor => actor.resident.id))) + + + const defaultMetaDataFields = { + B2CAppId: b2cApp.id, + B2CAppName: b2cApp.name, + callId: dataAttrs.callId, + } + const defaultMetaDataB2CAppCallDataFields = { + ...defaultMetaDataFields, + B2CAppContext: dataAttrs.b2cAppCallData.B2CAppContext, + } + const defaultMetaDataNativeCallDataFields = { + ...defaultMetaDataFields, + voipAddress: dataAttrs.nativeCallData.voipAddress, + voipLogin: dataAttrs.nativeCallData.voipLogin, + voipPassword: dataAttrs.nativeCallData.voipPassword, + voipDtfmCommand: dataAttrs.nativeCallData.voipPanels[0].dtmfCommand, + voipPanels: dataAttrs.nativeCallData.voipPanels, + stun: dataAttrs.nativeCallData.stunServers[0], + stunServers: dataAttrs.nativeCallData.stunServers, + codec: dataAttrs.nativeCallData.codec, + } + + const normalVoIPTypeMessages = createdMessages.filter(msg => msg.meta.data.voipType === normalVoIPType) + try { + expect(normalVoIPTypeMessages).toHaveLength(1) + } catch (err) { + console.error('normalVoIPTypeMessages fail') + throw err + } + expect(normalVoIPTypeMessages[0]).toEqual(expect.objectContaining({ + meta: expect.objectContaining({ + data: expect.objectContaining({ + ...defaultMetaDataNativeCallDataFields, + residentId: actors[3].resident.id, + voipType: String(normalVoIPType), + }), + }), + })) + + const resident1VoIPTypeMessages = createdMessages.filter(msg => msg.meta.data.voipType === resident1VoIPType) + try { + expect(resident1VoIPTypeMessages).toHaveLength(1) + } catch (err) { + console.error('resident1VoIPTypeMessages fail') + throw err + } + expect(resident1VoIPTypeMessages[0]).toEqual(expect.objectContaining({ + meta: expect.objectContaining({ + data: expect.objectContaining({ + ...defaultMetaDataNativeCallDataFields, + residentId: actors[0].resident.id, + voipType: String(resident1VoIPType), + }), + }), + })) + + const resident2VoIPTypeMessages = createdMessages.filter(msg => msg.meta.data.voipType === resident2VoIPType) + try { + expect(resident2VoIPTypeMessages).toHaveLength(1) + } catch (err) { + console.error('resident2VoIPTypeMessages fail') + throw err + } + expect(resident2VoIPTypeMessages[0]).toEqual(expect.objectContaining({ + meta: expect.objectContaining({ + data: expect.objectContaining({ + ...defaultMetaDataNativeCallDataFields, + residentId: actors[1].resident.id, + voipType: String(resident2VoIPType), + }), + }), + })) + + const b2cAppVoIPTypeMessages = createdMessages.filter(msg => !!msg.meta.data.B2CAppContext) + expect(b2cAppVoIPTypeMessages).toHaveLength(1) + try { + expect(b2cAppVoIPTypeMessages).toHaveLength(1) + } catch (err) { + console.error('b2cAppVoIPTypeMessages fail') + throw err + } + expect(b2cAppVoIPTypeMessages[0]).toEqual(expect.objectContaining({ + meta: expect.objectContaining({ + data: expect.objectContaining({ + ...defaultMetaDataB2CAppCallDataFields, + residentId: actors[2].resident.id, + }), + }), + })) + + }) + + test('uses native call voipType when CustomValue is absent', async () => { + const unitName = faker.random.alphaNumeric(3) + const unitType = FLAT_UNIT_TYPE + const actor = await prepareSingleActor({ admin, organization, property, unitName, unitType }) + + const callData = { + callId: faker.datatype.uuid(), + b2cAppCallData: { B2CAppContext: faker.random.alphaNumeric(10) }, + nativeCallData: { + voipAddress: faker.internet.ip(), + voipLogin: faker.internet.userName(), + voipPassword: faker.internet.password(), + voipPanels: [{ dtmfCommand: faker.random.alphaNumeric(2), name: faker.random.alphaNumeric(3) }], + stunServers: [faker.internet.ip()], + codec: 'vp8', + }, + } + + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName, + unitType, + callData, + }) + + expect(result.verifiedContactsCount).toBe(1) + expect(result.createdMessagesCount).toBe(1) + expect(result.erroredMessagesCount).toBe(0) + + const [createdMessage] = await Message.getAll(admin, { + user: { id: actor.user.id }, + type: VOIP_INCOMING_CALL_MESSAGE_TYPE, + }, { first: 1 }) + + expect(createdMessage).toEqual(expect.objectContaining({ + meta: expect.objectContaining({ + data: expect.objectContaining({ + residentId: actor.resident.id, + voipType: NATIVE_VOIP_TYPE, + voipAddress: callData.nativeCallData.voipAddress, + }), + }), + })) + expect(createdMessage.meta.data.B2CAppContext).toBeUndefined() + }) + + }) + + test('applies values from CustomFields with names equals to native voip push keys starting with "voip"', async () => { + const [b2cApp] = await createTestB2CApp(admin) + const { organization, property } = await makeClientWithResidentAccessAndProperty() + await createTestB2CAppProperty(admin, b2cApp, { address: property.address, addressMeta: property.addressMeta }) + const unitName = faker.random.alphaNumeric(3) + + const serviceUser = await makeClientWithServiceUser() + const [b2bApp] = await createTestB2BApp(admin) + await createTestB2BAppContext(admin, b2bApp, organization, { status: 'Finished' }) + const [b2bAppAccessRightSet] = await createTestB2BAppAccessRightSet(admin, b2bApp, { canReadOrganizations: true, canReadCustomValues: true, canManageCustomValues: true }) + await createTestB2BAppAccessRight(admin, serviceUser.user, b2bApp, b2bAppAccessRightSet) + + const [b2cRightSet] = await createTestB2CAppAccessRightSet(admin, b2cApp, { canExecuteSendVoIPStartMessage: true }) + await createTestB2CAppAccessRight(admin, serviceUser.user, b2cApp, { accessRightSet: { connect: { id: b2cRightSet.id } } }) + + + const actor = await prepareSingleActor({ admin, organization, property, unitName, unitType: FLAT_UNIT_TYPE }) + + + const customValue = faker.random.alphaNumeric(8) + const customFieldNames = ['voipAddress', 'voipPassword', 'voipDtfmCommand', 'voipPanels'] + for (const fieldName of customFieldNames) { + const [customField] = await createTestCustomField(admin, { + name: fieldName, + modelName: 'Contact', + type: 'String', + validationRules: null, + isVisible: false, + priority: 0, + isUniquePerObject: true, + staffCanRead: false, + sender: { dv: 1, fingerprint: faker.random.alphaNumeric(8) }, + }) + await createTestCustomValue(serviceUser, customField, organization, { + sourceType: 'B2BApp', + data: customValue, + itemId: actor.contact.id, + sourceId: b2bApp.id, + isUniquePerObject: true, + }) + } + const callId = faker.datatype.uuid() + const [result] = await sendVoIPStartMessageByTestClient(serviceUser, { + app: { id: b2cApp.id }, + addressKey: property.addressKey, + unitName: unitName, + unitType: FLAT_UNIT_TYPE, + callData: { + callId: callId, + nativeCallData: { + voipAddress: faker.internet.ip(), + voipLogin: faker.internet.userName(), + voipPassword: faker.internet.password(), + voipPanels: [{ dtmfCommand: faker.random.alphaNumeric(2), name: faker.random.alphaNumeric(3) }], + stunServers: [faker.internet.ip()], + codec: 'vp8', + }, + }, + }) + expect(result.verifiedContactsCount).toBe(1) + expect(result.createdMessagesCount).toBe(1) + expect(result.erroredMessagesCount).toBe(0) + + const [createdMessage] = await Message.getAll(admin, { type: VOIP_INCOMING_CALL_MESSAGE_TYPE, user: { id: actor.user.id } }) + + expect(createdMessage.meta.data).toEqual(expect.objectContaining( + Object.fromEntries(customFieldNames.map(fieldName => ([fieldName, customValue]))) + )) + }) + }) +}) \ No newline at end of file diff --git a/apps/condo/domains/miniapp/schema/index.js b/apps/condo/domains/miniapp/schema/index.js index 59d58f54c02..aec0230adbc 100644 --- a/apps/condo/domains/miniapp/schema/index.js +++ b/apps/condo/domains/miniapp/schema/index.js @@ -25,6 +25,8 @@ const { CustomValue } = require('./CustomValue') const { MessageAppBlackList } = require('./MessageAppBlackList') const { SendB2BAppPushMessageService } = require('./SendB2BAppPushMessageService') const { SendB2CAppPushMessageService } = require('./SendB2CAppPushMessageService') +const { SendVoIPStartMessageService } = require('./SendVoIPStartMessageService') + /* AUTOGENERATE MARKER */ module.exports = { @@ -50,5 +52,6 @@ module.exports = { CustomValue, B2BAppPosIntegrationConfig, B2CAppAccessRightSet, + SendVoIPStartMessageService, /* AUTOGENERATE MARKER */ } diff --git a/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/config.js b/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/config.js index 04f48945f01..74600c99d7d 100644 --- a/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/config.js +++ b/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/config.js @@ -25,7 +25,7 @@ const B2C_APP_SERVICE_USER_ACCESS_AVAILABLE_SCHEMAS = { }, // Something that has B2CApp info and addressKey services: { - // sendVoIPStartPushMessage: {}, // NOTE(YEgorLu): to be made in DOMA-12905 + sendVoIPStartMessage: {}, // sendVoIPCancelPushMessage: {}, // NOTE(YEgorLu): to be made in DOMA-12906 }, } diff --git a/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/server.utils.js b/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/server.utils.js index f8947311363..b24d37394d4 100644 --- a/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/server.utils.js +++ b/apps/condo/domains/miniapp/utils/b2cAppServiceUserAccess/server.utils.js @@ -86,7 +86,7 @@ async function canReadByServiceUser (args, schemaConfig) { const permissionKey = `canRead${pluralize.plural(listKey)}` - return getFilterByFieldPathValue(pathToB2CApp, getB2CAppFilter({ user, requirePermission: !!schemaConfig.rightSetRequired, permissionKey })) + return getFilterByFieldPathValue(pathToB2CApp, getB2CAppFilter({ user, requirePermission: schemaConfig.rightSetRequired !== false, permissionKey })) } async function canManageByServiceUser ({ authentication: { item: user }, listKey, originalInput, itemId, itemIds, operation, context }, schemaConfig, parentSchemaName) { @@ -174,7 +174,7 @@ async function canManageByServiceUser ({ authentication: { item: user }, listKey const uniqueB2CAppIds = [...new Set(b2cAppIds)] const b2cApps = await find('B2CApp', { - ...getB2CAppFilter({ user, requirePermission: !!schemaConfig.rightSetRequired, permissionKey }), + ...getB2CAppFilter({ user, requirePermission: schemaConfig.rightSetRequired !== false, permissionKey }), id_in: uniqueB2CAppIds, deletedAt: null, }) @@ -207,7 +207,7 @@ async function canExecuteByServiceUser (params, serviceConfig) { deletedAt: null, addressKey, app: { - ...getB2CAppFilter({ user, requirePermission: !!serviceConfig.rightSetRequired, permissionKey }), + ...getB2CAppFilter({ user, requirePermission: serviceConfig.rightSetRequired !== false, permissionKey }), id: b2cAppId, deletedAt: null, }, diff --git a/apps/condo/domains/miniapp/utils/testSchema/index.js b/apps/condo/domains/miniapp/utils/testSchema/index.js index 35d495127bd..86354a41293 100644 --- a/apps/condo/domains/miniapp/utils/testSchema/index.js +++ b/apps/condo/domains/miniapp/utils/testSchema/index.js @@ -18,6 +18,7 @@ const { const { ALL_MINI_APPS_QUERY, SEND_B2C_APP_PUSH_MESSAGE_MUTATION, + SEND_VOIP_START_MESSAGE_MUTATION, B2BApp: B2BAppGQL, B2BAppContext: B2BAppContextGQL, B2BAppAccessRight: B2BAppAccessRightGQL, @@ -389,6 +390,22 @@ async function sendB2CAppPushMessageByTestClient (client, extraAttrs = {}) { return [data.result, attrs] } +async function sendVoIPStartMessageByTestClient (client, extraAttrs = {}) { + if (!client) throw new Error('no client') + + const sender = { dv: 1, fingerprint: faker.random.alphaNumeric(8) } + const attrs = { + dv: 1, + sender, + ...extraAttrs, + } + const { data, errors } = await client.mutate(SEND_VOIP_START_MESSAGE_MUTATION, { data: attrs }) + + throwIfError(data, errors, { query: SEND_VOIP_START_MESSAGE_MUTATION, variables: { data: attrs } }) + + return [data.result, attrs] +} + async function createTestMessageAppBlackList (client, extraAttrs = {}) { if (!client) throw new Error('no client') @@ -835,5 +852,6 @@ module.exports = { AppMessageSetting, createTestAppMessageSetting, updateTestAppMessageSetting, B2BAppPosIntegrationConfig, createTestB2BAppPosIntegrationConfig, updateTestB2BAppPosIntegrationConfig, B2CAppAccessRightSet, createTestB2CAppAccessRightSet, updateTestB2CAppAccessRightSet, + sendVoIPStartMessageByTestClient, /* AUTOGENERATE MARKER */ } diff --git a/apps/condo/domains/miniapp/utils/voip.js b/apps/condo/domains/miniapp/utils/voip.js new file mode 100644 index 00000000000..503dda38e26 --- /dev/null +++ b/apps/condo/domains/miniapp/utils/voip.js @@ -0,0 +1,59 @@ +const { getKVClient } = require('@open-condo/keystone/kv') + +const KEY_PREFIX = 'voipCallStatus' +const kv = getKVClient(KEY_PREFIX) +const CALL_STATUS_TTL_IN_SECONDS = 60 * 3 + +const CALL_STATUS_START_SENT = 'CALL_STATUS_START_SENT' +const CALL_STATUS_CANCEL_SENT = 'CALL_STATUS_CANCEL_SENT' +const CALL_STATUSES = { + CALL_STATUS_START_SENT: CALL_STATUS_START_SENT, + CALL_STATUS_CANCEL_SENT: CALL_STATUS_CANCEL_SENT, +} + +function validateCallId (callId) { + return typeof callId === 'string' + && callId.length > 0 + && callId.length < 300 +} + +function normalizeCallId (callId) { + return callId + // eslint-disable-next-line no-control-regex + .replace(/[\u0000-\u001F\s]/g, '') +} + +function buildKey (b2cAppId, callId) { + return [KEY_PREFIX, b2cAppId, Buffer.from(callId).toString('base64')].join(':') +} + +// NOTE(YEgorLu): startingMessagesIdsByUserIds present for older mobile apps compatibility, as they use this to cancel calls. +// Will be removed someday in the future. Should be okay to save it only for few minutes +async function setCallStatus ({ b2cAppId, callId, status, startingMessagesIdsByUserIds }) { + if (!validateCallId(callId)) return false + return kv.set( + buildKey(b2cAppId, normalizeCallId(callId)), + JSON.stringify({ status, startingMessagesIdsByUserIds }), + 'EX', + CALL_STATUS_TTL_IN_SECONDS, + ) +} + +async function getCallStatus ({ b2cAppId, callId }) { + if (!validateCallId(callId)) return null + const res = await kv.get(buildKey(b2cAppId, normalizeCallId(callId))) + try { + return JSON.parse(res) + } catch { + return null + } +} + +module.exports = { + setCallStatus, + getCallStatus, + + CALL_STATUSES, + CALL_STATUS_START_SENT, + CALL_STATUS_CANCEL_SENT, +} \ No newline at end of file diff --git a/apps/condo/domains/notification/constants/constants.js b/apps/condo/domains/notification/constants/constants.js index cf06f14af07..c6913fa3b81 100644 --- a/apps/condo/domains/notification/constants/constants.js +++ b/apps/condo/domains/notification/constants/constants.js @@ -639,6 +639,8 @@ const MESSAGE_META = { voipLogin: { required: false }, voipPassword: { required: false }, voipDtfmCommand: { required: false }, + voipPanels: { required: false }, + stunServers: { required: false }, stun: { required: false }, codec: { required: false }, }, diff --git a/apps/condo/domains/property/utils/serverSchema/helpers.js b/apps/condo/domains/property/utils/serverSchema/helpers.js index 0a34d281a2f..9c75e614694 100644 --- a/apps/condo/domains/property/utils/serverSchema/helpers.js +++ b/apps/condo/domains/property/utils/serverSchema/helpers.js @@ -2,6 +2,10 @@ const { get, omitBy, isNull, isArray } = require('lodash') const FLAT_WITHOUT_FLAT_TYPE_MESSAGE = 'Flat is specified, but flat type is not!' +const { itemsQuery } = require('@open-condo/keystone/schema') + +const { MANAGING_COMPANY_TYPE } = require('@condo/domains/organization/constants/common') + /** * Sometimes address can contain flat with prefix, for example, in case of scanning receipt with QR-code. * Input data is out of control ;) @@ -102,10 +106,24 @@ const getUnitsFromSections = (sections = []) => { ).flat(2) } +async function getOldestNonDeletedProperty ({ addressKey }) { + const [oldestProperty] = await itemsQuery('Property', { + where: { + addressKey: addressKey, + deletedAt: null, + organization: { type: MANAGING_COMPANY_TYPE }, + }, + first: 1, + sortBy: ['isApproved_DESC', 'createdAt_ASC'], // sorting order is essential here + }) + return oldestProperty +} + module.exports = { FLAT_WITHOUT_FLAT_TYPE_MESSAGE, getAddressUpToBuildingFrom, normalizePropertyMap, getAddressDetails, getUnitsFromSections, + getOldestNonDeletedProperty, } diff --git a/apps/condo/lang/en/en.json b/apps/condo/lang/en/en.json index 71af4704005..e237d99e0a9 100644 --- a/apps/condo/lang/en/en.json +++ b/apps/condo/lang/en/en.json @@ -483,6 +483,10 @@ "api.miniapp.sendB2CAppPushMessage.RESIDENT_NOT_FOUND": "Unable to find resident by provided id.", "api.miniapp.sendB2CAppPushMessage.USER_NOT_FOUND": "Unable to find user by provided id.", "api.miniapp.sendB2CAppPushMessage.WRONG_SENDER_FORMAT": "Invalid format of \"sender\" field value. {details}", + "api.miniapp.sendVoIPStartMessage.PROPERTY_NOT_FOUND": "Building not found for the provided \"addressKey\"", + "api.miniapp.sendVoIPStartMessage.APP_NOT_FOUND": "Application not found for the provided \"id\"", + "api.miniapp.sendVoIPStartMessage.DV_VERSION_MISMATCH": "Invalid data version value", + "api.miniapp.sendVoIPStartMessage.WRONG_SENDER_FORMAT": "Invalid format for the \"sender\" field", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_BAD_RESPONSE": "Response from NewsSharing miniapp was successful, but the data format was incorrect. Please consult with miniapp developer", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_FAILED": "Could not get a successful response from NewsSharing miniapp. Please check the network and url configuration", "api.news.getNewsSharingRecipients.NOT_NEWS_SHARING_APP": "Provided b2bAppContext.app is not a NewsSharing miniapp", diff --git a/apps/condo/lang/es/es.json b/apps/condo/lang/es/es.json index 010711f283d..d952b8a2ef9 100644 --- a/apps/condo/lang/es/es.json +++ b/apps/condo/lang/es/es.json @@ -483,6 +483,10 @@ "api.miniapp.sendB2CAppPushMessage.RESIDENT_NOT_FOUND": "No se ha encontrado el vecino con el id introducido", "api.miniapp.sendB2CAppPushMessage.USER_NOT_FOUND": "No se ha encontrado el usuario con el id introducido", "api.miniapp.sendB2CAppPushMessage.WRONG_SENDER_FORMAT": "Formato del campo \"sender\" no válido", + "api.miniapp.sendVoIPStartMessage.PROPERTY_NOT_FOUND": "No se encontró el edificio para el \"addressKey\" proporcionado", + "api.miniapp.sendVoIPStartMessage.APP_NOT_FOUND": "No se encontró la aplicación para el \"id\" proporcionado", + "api.miniapp.sendVoIPStartMessage.DV_VERSION_MISMATCH": "Valor de versión de datos no válido", + "api.miniapp.sendVoIPStartMessage.WRONG_SENDER_FORMAT": "Formato no válido para el campo \"sender\"", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_BAD_RESPONSE": "La solicitud a la miniapp ha devuelto datos incorrectos", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_FAILED": "La solicitud a la miniapp se completó con un error.", "api.news.getNewsSharingRecipients.NOT_NEWS_SHARING_APP": "Esta miniapp no admite la funcionalidad de envío de noticias", diff --git a/apps/condo/lang/ru/ru.json b/apps/condo/lang/ru/ru.json index 6758c69beff..8d2775f6b58 100644 --- a/apps/condo/lang/ru/ru.json +++ b/apps/condo/lang/ru/ru.json @@ -483,6 +483,10 @@ "api.miniapp.sendB2CAppPushMessage.RESIDENT_NOT_FOUND": "Не удалось найти жителя по переданному id", "api.miniapp.sendB2CAppPushMessage.USER_NOT_FOUND": "Не удалось найти пользователя по переданному id", "api.miniapp.sendB2CAppPushMessage.WRONG_SENDER_FORMAT": "Неверный формат поля \"sender\"", + "api.miniapp.sendVoIPStartMessage.PROPERTY_NOT_FOUND": "Не удалось найти здание по переданному \"addressKey\"", + "api.miniapp.sendVoIPStartMessage.APP_NOT_FOUND": "Не удалось найти приложение по переданному \"id\"", + "api.miniapp.sendVoIPStartMessage.DV_VERSION_MISMATCH": "Неверное значение версии данных", + "api.miniapp.sendVoIPStartMessage.WRONG_SENDER_FORMAT": "Неверный формат поля \"sender\"", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_BAD_RESPONSE": "Запрос в миниапп вернул некорректные данные", "api.news.getNewsSharingRecipients.NEWS_SHARING_APP_REQUEST_FAILED": "Запрос в миниапп завершился с ошибкой", "api.news.getNewsSharingRecipients.NOT_NEWS_SHARING_APP": "Этот миниапп не поддерживает функциональность отправки новостей", diff --git a/apps/condo/migrations/20260420183110-0525_b2cappaccessrightset_canexecutesendvoipstartmessage_and_more.js b/apps/condo/migrations/20260420183110-0525_b2cappaccessrightset_canexecutesendvoipstartmessage_and_more.js new file mode 100644 index 00000000000..35aff361953 --- /dev/null +++ b/apps/condo/migrations/20260420183110-0525_b2cappaccessrightset_canexecutesendvoipstartmessage_and_more.js @@ -0,0 +1,48 @@ +// auto generated by kmigrator +// KMIGRATOR:0525_b2cappaccessrightset_canexecutesendvoipstartmessage_and_more:IyBHZW5lcmF0ZWQgYnkgRGphbmdvIDUuMS41IG9uIDIwMjYtMDQtMjAgMTM6MzEKCmZyb20gZGphbmdvLmRiIGltcG9ydCBtaWdyYXRpb25zLCBtb2RlbHMKCgpjbGFzcyBNaWdyYXRpb24obWlncmF0aW9ucy5NaWdyYXRpb24pOgoKICAgIGRlcGVuZGVuY2llcyA9IFsKICAgICAgICAoJ19kamFuZ29fc2NoZW1hJywgJzA1MjRfYjJjYXBwYWNjZXNzcmlnaHRzZXRoaXN0b3J5cmVjb3JkX2FuZF9tb3JlJyksCiAgICBdCgogICAgb3BlcmF0aW9ucyA9IFsKICAgICAgICBtaWdyYXRpb25zLkFkZEZpZWxkKAogICAgICAgICAgICBtb2RlbF9uYW1lPSdiMmNhcHBhY2Nlc3NyaWdodHNldCcsCiAgICAgICAgICAgIG5hbWU9J2NhbkV4ZWN1dGVTZW5kVm9JUFN0YXJ0TWVzc2FnZScsCiAgICAgICAgICAgIGZpZWxkPW1vZGVscy5Cb29sZWFuRmllbGQoZGVmYXVsdD1GYWxzZSksCiAgICAgICAgKSwKICAgICAgICBtaWdyYXRpb25zLkFkZEZpZWxkKAogICAgICAgICAgICBtb2RlbF9uYW1lPSdiMmNhcHBhY2Nlc3NyaWdodHNldGhpc3RvcnlyZWNvcmQnLAogICAgICAgICAgICBuYW1lPSdjYW5FeGVjdXRlU2VuZFZvSVBTdGFydE1lc3NhZ2UnLAogICAgICAgICAgICBmaWVsZD1tb2RlbHMuQm9vbGVhbkZpZWxkKGJsYW5rPVRydWUsIG51bGw9VHJ1ZSksCiAgICAgICAgKSwKICAgIF0K +// KMIGRATOR_VIEWS:0525_b2cappaccessrightset_canexecutesendvoipstartmessage_and_more:{"dv":1,"lists":{"User":{"fields":["avatar","createdAt","createdBy","customAccess","deletedAt","dv","email","externalEmail","externalPhone","externalSystemName","hasMarketingConsent","id","isAdmin","isEmailVerified","isExternalEmailVerified","isExternalPhoneVerified","isPhoneVerified","isSupport","isTwoFactorAuthenticationEnabled","locale","meta","name","newId","password","phone","rightsSet","sender","showGlobalHints","type","updatedAt","updatedBy","v"],"sensitiveFields":["email","externalEmail","externalPhone","meta","name","password","phone"]},"UserExternalIdentity":{"fields":["createdAt","createdBy","deletedAt","dv","id","identityId","identityType","meta","newId","sender","updatedAt","updatedBy","user","userType","v"],"sensitiveFields":["identityId","meta"]},"UserRightsSet":{"fields":["canExecuteGetAvailableSubscriptionPlans","canExecuteRegisterNewServiceUser","canExecuteRegisterSubscriptionContext","canExecuteSendMessage","canExecute_allBillingReceiptsSum","canExecute_allPaymentsSum","canExecute_internalSendHashedResidentPhones","canManageB2BAppAccessRightSets","canManageB2BAppAccessRights","canManageB2BAppContexts","canManageB2BAppNewsSharingConfigs","canManageB2BAppPermissions","canManageB2BAppPromoBlocks","canManageB2BApps","canManageB2CAppAccessRights","canManageB2CAppBuilds","canManageB2CAppProperties","canManageB2CApps","canManageBillingIntegrationOrganizationContextDeletedAtField","canManageMessageBatches","canManageOidcClients","canManageOrganizationIsApprovedField","canManageOrganizations","canManageProperties","canManageResetUserLimitActions","canManageTicketAutoAssignments","canManageTicketSentToAuthoritiesAtField","canManageTickets","canManageUserHasMarketingConsentField","canManageUserRightsSetField","canManageUserRightsSets","canReadB2BAppAccessRightSets","canReadB2BAppAccessRights","canReadB2BAppContexts","canReadB2BAppNewsSharingConfigs","canReadB2BAppPermissions","canReadB2BAppPromoBlocks","canReadB2BApps","canReadB2CAppAccessRights","canReadB2CAppBuilds","canReadB2CAppProperties","canReadB2CApps","canReadBillingIntegrationOrganizationContexts","canReadBillingReceipts","canReadMessageBatches","canReadMessages","canReadOidcClients","canReadOrganizations","canReadPayments","canReadProperties","canReadResetUserLimitActions","canReadResidents","canReadTicketAutoAssignments","canReadTickets","canReadUserEmailField","canReadUserPhoneField","canReadUserRightsSets","canReadUsers","createdAt","createdBy","deletedAt","dv","id","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":["canExecute_internalSendHashedResidentPhones","canReadUserEmailField","canReadUserPhoneField"]},"Organization":{"fields":["avatar","country","createdAt","createdBy","deletedAt","description","dv","features","id","importId","importRemoteSystem","isApproved","meta","name","newId","phone","phoneNumberPrefix","sender","tin","type","updatedAt","updatedBy","v"],"sensitiveFields":["phone","phoneNumberPrefix"]},"OrganizationEmployee":{"fields":["createdAt","createdBy","deletedAt","dv","email","hasAllSpecializations","id","inviteCode","isAccepted","isBlocked","isRejected","name","newId","organization","phone","position","role","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":["email","inviteCode","name","phone"]},"OrganizationEmployeeRole":{"fields":["canBeAssignedAsExecutor","canBeAssignedAsResponsible","canDownloadCallRecords","canImportBillingReceipts","canInviteNewOrganizationEmployees","canManageB2BApps","canManageBankAccountReportTasks","canManageBankAccountReports","canManageBankAccounts","canManageBankContractorAccounts","canManageBankIntegrationAccountContexts","canManageBankIntegrationOrganizationContexts","canManageBankTransactions","canManageCallRecords","canManageContactRoles","canManageContacts","canManageDocuments","canManageEmployees","canManageIncidents","canManageIntegrations","canManageInvoices","canManageMarketItemPrices","canManageMarketItems","canManageMarketPriceScopes","canManageMarketSetting","canManageMarketplace","canManageMeterReadings","canManageMeters","canManageMobileFeatureConfigs","canManageNewsItemTemplates","canManageNewsItems","canManageOrganization","canManageOrganizationEmployeeRequests","canManageProperties","canManagePropertyScopes","canManageRoles","canManageSubscriptions","canManageTicketAutoAssignments","canManageTicketComments","canManageTicketPropertyHints","canManageTickets","canManageTour","canReadAnalytics","canReadBillingReceipts","canReadCallRecords","canReadContacts","canReadDocuments","canReadEmployees","canReadExternalReports","canReadIncidents","canReadInvoices","canReadMarketItemPrices","canReadMarketItems","canReadMarketPriceScopes","canReadMarketSetting","canReadMarketplace","canReadMeters","canReadNewsItems","canReadPayments","canReadPaymentsWithInvoices","canReadProperties","canReadServices","canReadSettings","canReadTickets","canReadTour","canShareTickets","createdAt","createdBy","deletedAt","description","dv","id","isDefault","isEditable","name","newId","organization","sender","ticketVisibilityType","updatedAt","updatedBy","v"],"sensitiveFields":["canReadSettings"]},"OrganizationLink":{"fields":["createdAt","createdBy","deletedAt","dv","from","id","newId","sender","to","updatedAt","updatedBy","v"],"sensitiveFields":[]},"OrganizationEmployeeSpecialization":{"fields":["createdAt","createdBy","deletedAt","dv","employee","id","newId","sender","specialization","updatedAt","updatedBy","v"],"sensitiveFields":[]},"OrganizationEmployeeRequest":{"fields":["createdAt","createdBy","createdEmployee","deletedAt","dv","id","isAccepted","isRejected","newId","organization","organizationId","organizationName","organizationTin","processedAt","processedBy","retries","sender","updatedAt","updatedBy","user","userName","userPhone","v"],"sensitiveFields":["userName","userPhone"]},"Property":{"fields":["address","addressKey","addressMeta","addressSources","area","createdAt","createdBy","deletedAt","dv","id","isApproved","map","name","newId","organization","sender","type","uninhabitedUnitsCount","unitsCount","updatedAt","updatedBy","v","yearOfConstruction"],"sensitiveFields":[]},"BillingIntegration":{"fields":["appUrl","b2bApp","bannerColor","bannerPromoImage","bannerTextColor","billingPageIcon","billingPageTitle","checkAccountNumberUrl","checkAddressUrl","connectedMessage","connectedUrl","contextDefaultStatus","createdAt","createdBy","currencyCode","dataFormat","deletedAt","detailedDescription","dv","extendsBillingPage","group","id","instruction","instructionExtraLink","isHidden","isTrustedBankAccountSource","logo","name","newId","receiptsLoadingTime","sender","setupUrl","shortDescription","skipNoAccountNotifications","targetDescription","updatedAt","updatedBy","uploadMessage","uploadUrl","v"],"sensitiveFields":[]},"BillingIntegrationAccessRight":{"fields":["createdAt","createdBy","deletedAt","dv","id","integration","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"BillingIntegrationOrganizationContext":{"fields":["createdAt","createdBy","currentProblem","deletedAt","dv","id","integration","lastReport","newId","organization","sender","settings","state","status","updatedAt","updatedBy","v"],"sensitiveFields":["settings","state"]},"BillingIntegrationProblem":{"fields":["context","createdAt","createdBy","deletedAt","dv","id","message","meta","newId","sender","title","updatedAt","updatedBy","v"],"sensitiveFields":[]},"BillingProperty":{"fields":["address","addressKey","addressMeta","addressSources","context","createdAt","createdBy","deletedAt","dv","globalId","id","importId","meta","newId","normalizedAddress","raw","sender","updatedAt","updatedBy","v"],"sensitiveFields":["meta","raw"]},"BillingAccount":{"fields":["context","createdAt","createdBy","deletedAt","dv","fullName","globalId","id","importId","isClosed","meta","newId","number","ownerType","property","raw","sender","unitName","unitType","updatedAt","updatedBy","v"],"sensitiveFields":["fullName","meta","raw"]},"BillingReceipt":{"fields":["account","amountDistribution","balance","balanceUpdatedAt","category","charge","context","createdAt","createdBy","deletedAt","dv","file","formula","id","importId","newId","paid","paymentStatusChangeWebhookSecret","paymentStatusChangeWebhookUrl","penalty","period","printableNumber","privilege","property","raw","recalculation","receiver","recipient","sender","services","toPay","toPayDetails","updatedAt","updatedBy","v"],"sensitiveFields":["amountDistribution","paymentStatusChangeWebhookSecret","paymentStatusChangeWebhookUrl","raw","services","toPayDetails"]},"BillingRecipient":{"fields":["bankAccount","bankName","bic","classificationCode","context","createdAt","createdBy","deletedAt","dv","id","iec","importId","meta","name","newId","offsettingAccount","purpose","sender","territoryCode","tin","updatedAt","updatedBy","v"],"sensitiveFields":["meta"]},"BillingCategory":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","receiptValidityMonths","requiresFullPayment","sender","serviceNames","skipNotifications","updatedAt","updatedBy","v"],"sensitiveFields":[]},"BankAccount":{"fields":["approvedAt","approvedBy","bankName","classificationCode","country","createdAt","createdBy","currencyCode","deletedAt","dv","id","importId","integrationContext","isApproved","meta","name","newId","number","organization","property","routingNumber","routingNumberMeta","sender","territoryCode","tin","tinMeta","updatedAt","updatedBy","v"],"sensitiveFields":["meta","routingNumberMeta","tinMeta"]},"BankCategory":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"BankCostItem":{"fields":["category","createdAt","createdBy","deletedAt","dv","id","isOutcome","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"BankContractorAccount":{"fields":["bankName","costItem","country","createdAt","createdBy","currencyCode","deletedAt","dv","id","importId","meta","name","newId","number","organization","routingNumber","sender","territoryCode","tin","updatedAt","updatedBy","v"],"sensitiveFields":["meta"]},"BankIntegration":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"BankIntegrationAccessRight":{"fields":["createdAt","createdBy","deletedAt","dv","id","integration","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"BankIntegrationAccountContext":{"fields":["createdAt","createdBy","deletedAt","dv","enabled","id","integration","meta","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":["meta"]},"BankTransaction":{"fields":["account","amount","contractorAccount","costItem","createdAt","createdBy","currencyCode","date","deletedAt","dv","id","importId","importRemoteSystem","integrationContext","isOutcome","meta","newId","number","organization","purpose","sender","updatedAt","updatedBy","v"],"sensitiveFields":["meta"]},"BankIntegrationOrganizationContext":{"fields":["createdAt","createdBy","deletedAt","dv","enabled","id","integration","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"Ticket":{"fields":["assignee","canReadByResident","categoryClassifier","classifier","client","clientEmail","clientName","clientPhone","completedAt","contact","createdAt","createdBy","customClassifier","deadline","deferredUntil","deletedAt","details","dv","executor","feedbackAdditionalOptions","feedbackComment","feedbackUpdatedAt","feedbackValue","floorName","id","isAutoClassified","isCompletedAfterDeadline","isEmergency","isInsurance","isPaid","isPayable","isResidentTicket","isWarranty","kanbanColumn","kanbanOrder","lastCommentAt","lastCommentWithOrganizationTypeAt","lastCommentWithResidentTypeAt","lastCommentWithResidentTypeCreatedByUserType","lastResidentCommentAt","meta","newId","number","order","organization","placeClassifier","priority","problemClassifier","property","propertyAddress","propertyAddressMeta","qualityControlAdditionalOptions","qualityControlComment","qualityControlUpdatedAt","qualityControlUpdatedBy","qualityControlValue","related","reviewComment","reviewValue","sectionName","sectionType","sender","sentToAuthoritiesAt","source","sourceMeta","status","statusReason","statusReopenedCounter","statusUpdatedAt","title","unitName","unitType","updatedAt","updatedBy","v"],"sensitiveFields":["clientEmail","clientName","clientPhone","details","meta","sourceMeta","title"]},"TicketSource":{"fields":["createdAt","createdBy","deletedAt","dv","id","isDefault","name","newId","organization","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketStatus":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketFile":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","newId","organization","sender","ticket","updatedAt","updatedBy","v"],"sensitiveFields":["file"]},"TicketChange":{"fields":["actualCreationDate","assigneeDisplayNameFrom","assigneeDisplayNameTo","assigneeIdFrom","assigneeIdTo","canReadByResidentFrom","canReadByResidentTo","classifierDisplayNameFrom","classifierDisplayNameTo","classifierIdFrom","classifierIdTo","clientDisplayNameFrom","clientDisplayNameTo","clientEmailFrom","clientEmailTo","clientIdFrom","clientIdTo","clientNameFrom","clientNameTo","clientPhoneFrom","clientPhoneTo","contactDisplayNameFrom","contactDisplayNameTo","contactIdFrom","contactIdTo","createdAt","createdBy","customClassifierFrom","customClassifierTo","deadlineFrom","deadlineTo","deferredUntilFrom","deferredUntilTo","detailsFrom","detailsTo","dv","executorDisplayNameFrom","executorDisplayNameTo","executorIdFrom","executorIdTo","feedbackAdditionalOptionsFrom","feedbackAdditionalOptionsTo","feedbackCommentFrom","feedbackCommentTo","feedbackValueFrom","feedbackValueTo","floorNameFrom","floorNameTo","id","isEmergencyFrom","isEmergencyTo","isInsuranceFrom","isInsuranceTo","isPaidFrom","isPaidTo","isPayableFrom","isPayableTo","isResidentTicketFrom","isResidentTicketTo","isWarrantyFrom","isWarrantyTo","kanbanColumnFrom","kanbanColumnTo","kanbanOrderFrom","kanbanOrderTo","metaFrom","metaTo","observersDisplayNamesFrom","observersDisplayNamesTo","observersIdsFrom","observersIdsTo","organizationDisplayNameFrom","organizationDisplayNameTo","organizationIdFrom","organizationIdTo","priorityFrom","priorityTo","propertyAddressFrom","propertyAddressMetaFrom","propertyAddressMetaTo","propertyAddressTo","propertyDisplayNameFrom","propertyDisplayNameTo","propertyIdFrom","propertyIdTo","qualityControlAdditionalOptionsFrom","qualityControlAdditionalOptionsTo","qualityControlCommentFrom","qualityControlCommentTo","qualityControlValueFrom","qualityControlValueTo","relatedDisplayNameFrom","relatedDisplayNameTo","relatedIdFrom","relatedIdTo","reviewCommentFrom","reviewCommentTo","reviewValueFrom","reviewValueTo","sectionNameFrom","sectionNameTo","sectionTypeFrom","sectionTypeTo","sender","sentToAuthoritiesAtFrom","sentToAuthoritiesAtTo","sourceDisplayNameFrom","sourceDisplayNameTo","sourceIdFrom","sourceIdTo","sourceMetaFrom","sourceMetaTo","statusDisplayNameFrom","statusDisplayNameTo","statusIdFrom","statusIdTo","statusReasonFrom","statusReasonTo","statusReopenedCounterFrom","statusReopenedCounterTo","ticket","titleFrom","titleTo","unitNameFrom","unitNameTo","unitTypeFrom","unitTypeTo","updatedAt","updatedBy","v"],"sensitiveFields":["clientEmailFrom","clientEmailTo","clientNameFrom","clientNameTo","clientPhoneFrom","clientPhoneTo","detailsFrom","detailsTo","metaFrom","metaTo","sourceMetaFrom","sourceMetaTo","titleFrom","titleTo"]},"TicketComment":{"fields":["content","createdAt","createdBy","deletedAt","dv","id","newId","sender","ticket","type","updatedAt","updatedBy","user","v"],"sensitiveFields":["content"]},"TicketPlaceClassifier":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketCategoryClassifier":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketProblemClassifier":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketClassifier":{"fields":["category","createdAt","createdBy","deletedAt","dv","id","newId","organization","place","problem","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketCommentFile":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","newId","organization","sender","ticket","ticketComment","updatedAt","updatedBy","v"],"sensitiveFields":["file"]},"UserTicketCommentReadTime":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","readCommentAt","readOrganizationCommentAt","readResidentCommentAt","sender","ticket","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"TicketPropertyHint":{"fields":["content","createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketPropertyHintProperty":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","organization","property","sender","ticketPropertyHint","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketExportTask":{"fields":["createdAt","createdBy","deletedAt","dv","exportedRecordsCount","file","format","id","locale","meta","newId","options","sender","sortBy","status","timeZone","totalRecordsCount","updatedAt","updatedBy","user","v","where"],"sensitiveFields":["file","meta","where"]},"TicketOrganizationSetting":{"fields":["createdAt","createdBy","defaultDeadlineDuration","deletedAt","dv","emergencyDeadlineDuration","id","newId","organization","paidDeadlineDuration","sender","updatedAt","updatedBy","v","warrantyDeadlineDuration"],"sensitiveFields":[]},"Incident":{"fields":["createdAt","createdBy","deletedAt","details","dv","hasAllProperties","id","newId","number","organization","sender","status","textForResident","updatedAt","updatedBy","v","workFinish","workStart","workType"],"sensitiveFields":[]},"IncidentChange":{"fields":["createdAt","createdBy","detailsFrom","detailsTo","dv","id","incident","organizationDisplayNameFrom","organizationDisplayNameTo","organizationIdFrom","organizationIdTo","sender","statusFrom","statusTo","textForResidentFrom","textForResidentTo","updatedAt","updatedBy","v","workFinishFrom","workFinishTo","workStartFrom","workStartTo","workTypeFrom","workTypeTo"],"sensitiveFields":[]},"IncidentProperty":{"fields":["createdAt","createdBy","deletedAt","dv","id","incident","newId","organization","property","propertyAddress","propertyAddressMeta","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"IncidentClassifier":{"fields":["category","createdAt","createdBy","deletedAt","dv","id","newId","organization","problem","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"IncidentClassifierIncident":{"fields":["classifier","createdAt","createdBy","deletedAt","dv","id","incident","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"UserFavoriteTicket":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","organization","sender","ticket","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"IncidentExportTask":{"fields":["createdAt","createdBy","deletedAt","dv","exportedRecordsCount","file","format","id","locale","meta","newId","sender","sortBy","status","timeZone","totalRecordsCount","updatedAt","updatedBy","user","v","where"],"sensitiveFields":["file","meta","where"]},"CallRecord":{"fields":["callerPhone","createdAt","createdBy","deletedAt","destCallerPhone","dv","file","id","importId","isIncomingCall","newId","organization","sender","startedAt","talkTime","transcript","updatedAt","updatedBy","v"],"sensitiveFields":["callerPhone","destCallerPhone","file","transcript"]},"CallRecordFragment":{"fields":["callRecord","createdAt","createdBy","deletedAt","dv","id","newId","organization","sender","startedAt","ticket","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketAutoAssignment":{"fields":["assignee","classifier","createdAt","createdBy","deletedAt","dv","executor","id","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TicketDocumentGenerationTask":{"fields":["createdAt","createdBy","deletedAt","documentType","dv","file","format","id","meta","newId","progress","sender","status","ticket","timeZone","updatedAt","updatedBy","user","v"],"sensitiveFields":["file","meta"]},"TicketObserver":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","sender","ticket","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"Message":{"fields":["createdAt","createdBy","deletedAt","deliveredAt","dv","email","emailFrom","id","lang","meta","newId","organization","phone","processingMeta","readAt","remoteClient","sender","sentAt","status","type","uniqKey","updatedAt","updatedBy","user","v"],"sensitiveFields":["email","emailFrom","meta","phone","processingMeta"]},"RemoteClient":{"fields":["appId","createdAt","createdBy","deletedAt","deviceId","deviceKey","devicePlatform","dv","id","meta","newId","owner","pushToken","pushTokenVoIP","pushTransport","pushTransportVoIP","pushType","pushTypeVoIP","sender","updatedAt","updatedBy","v"],"sensitiveFields":["deviceKey","pushToken","pushTokenVoIP"]},"MessageUserBlackList":{"fields":["createdAt","createdBy","deletedAt","description","dv","email","id","newId","phone","sender","type","updatedAt","updatedBy","user","v"],"sensitiveFields":["email","phone"]},"MessageOrganizationBlackList":{"fields":["createdAt","createdBy","deletedAt","description","dv","id","newId","organization","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"NotificationUserSetting":{"fields":["createdAt","createdBy","deletedAt","dv","id","isEnabled","messageTransport","messageType","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"TelegramUserChat":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","sender","telegramChatId","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"RemoteClientPushToken":{"fields":["createdAt","createdBy","deletedAt","dv","id","isPush","isVoIP","newId","provider","remoteClient","sender","token","updatedAt","updatedBy","v"],"sensitiveFields":["token"]},"Contact":{"fields":["communityFee","createdAt","createdBy","deletedAt","dv","email","id","isVerified","meta","name","newId","note","organization","ownershipPercentage","phone","property","role","sender","unitName","unitType","updatedAt","updatedBy","v"],"sensitiveFields":["email","name","note","phone"]},"ContactRole":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"ContactExportTask":{"fields":["createdAt","createdBy","deletedAt","dv","exportedRecordsCount","file","format","id","locale","meta","newId","sender","sortBy","status","timeZone","totalRecordsCount","updatedAt","updatedBy","user","v","where"],"sensitiveFields":["file","meta","where"]},"Resident":{"fields":["address","addressKey","addressMeta","addressSources","createdAt","createdBy","deletedAt","dv","id","newId","organization","property","sender","unitName","unitType","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"ServiceConsumer":{"fields":["accountNumber","acquiringIntegrationContext","billingIntegrationContext","createdAt","createdBy","deletedAt","dv","id","isDiscovered","newId","organization","paymentCategory","resident","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"TourStep":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","order","organization","sender","status","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"UserHelpRequest":{"fields":["billingIntegration","createdAt","createdBy","deletedAt","dv","email","id","isReadyToSend","meta","newId","organization","phone","sender","subscriptionPlanPricingRule","type","updatedAt","updatedBy","v"],"sensitiveFields":["email","meta","phone"]},"UserHelpRequestFile":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","newId","sender","updatedAt","updatedBy","userHelpRequest","v"],"sensitiveFields":["file"]},"MeterResource":{"fields":["createdAt","createdBy","deletedAt","dv","id","measure","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MeterReadingSource":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MeterReading":{"fields":["accountNumber","billingStatus","billingStatusText","client","clientEmail","clientName","clientPhone","contact","createdAt","createdBy","date","deletedAt","dv","id","meter","newId","organization","sender","source","updatedAt","updatedBy","v","value1","value2","value3","value4"],"sensitiveFields":["clientEmail","clientName","clientPhone"]},"Meter":{"fields":["accountNumber","archiveDate","b2bApp","b2cApp","commissioningDate","controlReadingsDate","createdAt","createdBy","deletedAt","dv","id","installationDate","isAutomatic","meta","newId","nextVerificationDate","number","numberOfTariffs","organization","place","property","resource","sealingDate","sender","unitName","unitType","updatedAt","updatedBy","v","verificationDate"],"sensitiveFields":["meta"]},"PropertyMeter":{"fields":["archiveDate","b2bApp","commissioningDate","controlReadingsDate","createdAt","createdBy","deletedAt","dv","id","installationDate","isAutomatic","meta","newId","nextVerificationDate","number","numberOfTariffs","organization","property","resource","sealingDate","sender","updatedAt","updatedBy","v","verificationDate"],"sensitiveFields":["meta"]},"PropertyMeterReading":{"fields":["createdAt","createdBy","date","deletedAt","dv","id","meter","newId","organization","sender","source","updatedAt","updatedBy","v","value1","value2","value3","value4"],"sensitiveFields":[]},"MeterReportingPeriod":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","notifyEndDay","notifyStartDay","organization","property","restrictionEndDay","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MeterResourceOwner":{"fields":["address","addressKey","addressMeta","addressSources","createdAt","createdBy","deletedAt","dv","id","newId","organization","resource","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MeterReadingsImportTask":{"fields":["createdAt","createdBy","deletedAt","dv","errorFile","errorMessage","file","format","id","importedRecordsCount","isPropertyMeters","locale","meta","newId","organization","processedRecordsCount","sender","status","totalRecordsCount","updatedAt","updatedBy","user","v"],"sensitiveFields":["errorFile","file","meta"]},"MeterReadingExportTask":{"fields":["createdAt","createdBy","deletedAt","dv","exportedRecordsCount","file","format","id","locale","meta","newId","sender","sortBy","status","timeZone","totalRecordsCount","updatedAt","updatedBy","user","v","where"],"sensitiveFields":["file","meta","where"]},"MeterUserSetting":{"fields":["createdAt","createdBy","deletedAt","dv","id","meter","name","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"SubscriptionPlan":{"fields":["ai","analytics","canBePromoted","createdAt","createdBy","customization","deletedAt","description","dv","enabledB2BApps","enabledB2CApps","id","isHidden","marketplace","meters","name","newId","news","organizationType","payments","priority","properties","sender","support","tickets","trialDays","updatedAt","updatedBy","v"],"sensitiveFields":[]},"SubscriptionPlanPricingRule":{"fields":["conditions","createdAt","createdBy","currencyCode","deletedAt","description","dv","id","isHidden","name","newId","period","price","priority","sender","subscriptionPlan","updatedAt","updatedBy","v"],"sensitiveFields":[]},"SubscriptionContext":{"fields":["bindingId","createdAt","createdBy","deletedAt","dv","endAt","frozenPaymentInfo","id","invoice","isTrial","newId","organization","sender","startAt","status","subscriptionPlan","subscriptionPlanPricingRule","updatedAt","updatedBy","v"],"sensitiveFields":["bindingId","frozenPaymentInfo"]},"AcquiringIntegration":{"fields":["canGroupReceipts","contextDefaultStatus","createdAt","createdBy","deletedAt","dv","explicitFeeDistributionSchema","hostUrl","id","isHidden","maximumPaymentAmount","minimumPaymentAmount","name","newId","sender","setupUrl","supportedBillingIntegrationsGroup","type","updatedAt","updatedBy","v","vatPercentOptions"],"sensitiveFields":[]},"AcquiringIntegrationAccessRight":{"fields":["createdAt","createdBy","deletedAt","dv","id","integration","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"AcquiringIntegrationContext":{"fields":["createdAt","createdBy","deletedAt","dv","email","id","implicitFeeDistributionSchema","integration","invoiceEmails","invoiceImplicitFeeDistributionSchema","invoiceReason","invoiceRecipient","invoiceSalesTaxPercent","invoiceStatus","invoiceTaxRegime","invoiceVatPercent","newId","organization","reason","recipient","sender","settings","state","status","updatedAt","updatedBy","v"],"sensitiveFields":["email","invoiceEmails","settings","state"]},"MultiPayment":{"fields":["amountWithoutExplicitFee","cardNumber","createdAt","createdBy","currencyCode","deletedAt","dv","explicitFee","explicitServiceCharge","id","implicitFee","importId","integration","meta","newId","payerEmail","paymentWay","recurrentPaymentContext","sender","serviceCategory","serviceFee","status","transactionId","updatedAt","updatedBy","user","v","withdrawnAt"],"sensitiveFields":["meta","payerEmail"]},"Payment":{"fields":["accountNumber","advancedAt","amount","context","createdAt","createdBy","currencyCode","deletedAt","depositedDate","dv","explicitFee","explicitServiceCharge","frozenDistribution","frozenInvoice","frozenReceipt","frozenSplits","id","implicitFee","importId","invoice","multiPayment","newId","order","organization","period","posReceiptUrl","purpose","rawAddress","receipt","recipient","recipientBankAccount","recipientBic","sender","serviceFee","status","transferDate","updatedAt","updatedBy","v"],"sensitiveFields":["frozenDistribution","frozenInvoice","frozenReceipt","frozenSplits","posReceiptUrl"]},"PaymentStatusChangeWebhookUrl":{"fields":["createdAt","createdBy","deletedAt","description","dv","id","isEnabled","name","newId","organization","sender","updatedAt","updatedBy","url","v"],"sensitiveFields":[]},"RecurrentPaymentContext":{"fields":["autoPayReceipts","billingCategory","createdAt","createdBy","deletedAt","dv","enabled","id","limit","newId","paymentDay","sender","serviceConsumer","settings","updatedAt","updatedBy","v"],"sensitiveFields":["settings"]},"PropertyScope":{"fields":["createdAt","createdBy","deletedAt","dv","hasAllEmployees","hasAllProperties","id","name","newId","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"PropertyScopeOrganizationEmployee":{"fields":["createdAt","createdBy","deletedAt","dv","employee","id","newId","propertyScope","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"PropertyScopeProperty":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","property","propertyScope","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"NewsItem":{"fields":["body","createdAt","createdBy","deletedAt","dv","id","isPublished","newId","number","organization","publishedAt","sendAt","sender","sentAt","title","type","updatedAt","updatedBy","v","validBefore"],"sensitiveFields":[]},"NewsItemScope":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","newsItem","property","sender","type","unitName","unitType","updatedAt","updatedBy","v"],"sensitiveFields":[]},"NewsItemTemplate":{"fields":["body","category","createdAt","createdBy","deletedAt","dv","id","name","newId","organization","sender","title","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"NewsItemUserRead":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","newsItem","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"NewsItemRecipientsExportTask":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","newId","organization","scopes","sender","status","updatedAt","updatedBy","user","v"],"sensitiveFields":["file"]},"NewsItemSharing":{"fields":["b2bAppContext","createdAt","createdBy","deletedAt","dv","id","lastPostRequest","newId","newsItem","sender","sharingParams","status","statusMessage","updatedAt","updatedBy","v"],"sensitiveFields":["lastPostRequest","sharingParams"]},"NewsItemFile":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","newId","newsItem","organization","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BApp":{"fields":["additionalDomains","appUrl","category","contextDefaultStatus","createdAt","createdBy","deletedAt","detailedDescription","developer","developerUrl","displayPriority","dv","features","gallery","hasDynamicTitle","icon","id","importId","importRemoteSystem","isGlobal","isHidden","isPublic","label","logo","menuCategory","name","newId","newsSharingConfig","oidcClient","posIntegrationConfig","price","sender","shortDescription","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppContext":{"fields":["app","createdAt","createdBy","deletedAt","dv","id","meta","newId","organization","sender","status","updatedAt","updatedBy","v"],"sensitiveFields":["meta"]},"B2BAppAccessRight":{"fields":["accessRightSet","app","createdAt","createdBy","deletedAt","dv","id","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"B2CApp":{"fields":["additionalDomains","appUrl","colorSchema","createdAt","createdBy","currentBuild","deletedAt","developer","dv","id","importId","importRemoteSystem","isHidden","logo","name","newId","oidcClient","sender","shortDescription","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2CAppAccessRight":{"fields":["accessRightSet","app","createdAt","createdBy","deletedAt","dv","id","importId","importRemoteSystem","newId","sender","updatedAt","updatedBy","user","v"],"sensitiveFields":[]},"B2CAppBuild":{"fields":["app","createdAt","createdBy","data","deletedAt","dv","id","importId","importRemoteSystem","newId","sender","updatedAt","updatedBy","v","version"],"sensitiveFields":["data"]},"B2CAppProperty":{"fields":["address","addressKey","addressMeta","addressSources","app","createdAt","createdBy","deletedAt","dv","id","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppPromoBlock":{"fields":["backgroundColor","backgroundImage","createdAt","createdBy","deletedAt","dv","external","id","newId","priority","sender","subtitle","targetUrl","textVariant","title","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppPermission":{"fields":["app","createdAt","createdBy","deletedAt","dv","id","key","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppRole":{"fields":["app","createdAt","createdBy","deletedAt","dv","id","newId","permissions","role","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppAccessRightSet":{"fields":["app","canExecuteRegisterBillingReceiptFile","canExecuteRegisterBillingReceipts","canExecuteRegisterMetersReadings","canExecuteRegisterPropertyMetersReadings","canExecuteSendB2BAppPushMessage","canExecuteSetPaymentPosReceiptUrl","canManageB2BAccessTokens","canManageBillingAccounts","canManageBillingIntegrationOrganizationContexts","canManageBillingProperties","canManageBillingReceiptFiles","canManageBillingReceipts","canManageBillingRecipients","canManageContacts","canManageCustomValues","canManageInvoices","canManageMeterReadings","canManageMeterReportingPeriods","canManageMeters","canManageOrganizationEmployeeRoles","canManageOrganizationEmployees","canManageOrganizations","canManagePayments","canManageProperties","canManageTicketCommentFiles","canManageTicketComments","canManageTicketFiles","canManageTickets","canReadB2BAccessTokens","canReadBillingAccounts","canReadBillingIntegrationOrganizationContexts","canReadBillingProperties","canReadBillingReceiptFiles","canReadBillingReceipts","canReadBillingRecipients","canReadContacts","canReadCustomValues","canReadInvoices","canReadMeterReadings","canReadMeterReportingPeriods","canReadMeters","canReadOrganizationEmployeeRoles","canReadOrganizationEmployees","canReadOrganizations","canReadPayments","canReadProperties","canReadTicketCommentFiles","canReadTicketComments","canReadTicketFiles","canReadTickets","createdAt","createdBy","deletedAt","dv","id","name","newId","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAppNewsSharingConfig":{"fields":["createdAt","createdBy","customFormUrl","deletedAt","dv","getRecipientsCountersUrl","getRecipientsUrl","icon","id","name","newId","previewPicture","previewUrl","publishUrl","pushNotificationSettings","sender","updatedAt","updatedBy","v"],"sensitiveFields":["customFormUrl","getRecipientsCountersUrl","getRecipientsUrl","previewUrl","publishUrl","pushNotificationSettings"]},"AppMessageSetting":{"fields":["b2bApp","b2cApp","createdAt","createdBy","deletedAt","dv","id","newId","notificationWindowSize","numberOfNotificationInWindow","reason","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"B2BAccessToken":{"fields":["context","createdAt","createdBy","deletedAt","dv","expiresAt","id","newId","rightSet","sender","sessionId","updatedAt","updatedBy","user","v"],"sensitiveFields":["sessionId"]},"CustomField":{"fields":["createdAt","createdBy","deletedAt","dv","id","isUniquePerObject","isVisible","locale","modelName","name","newId","priority","sender","staffCanRead","type","updatedAt","updatedBy","v","validationRules"],"sensitiveFields":[]},"B2BAppPosIntegrationConfig":{"fields":["createdAt","createdBy","deletedAt","dv","fetchLastPosReceiptUrl","id","newId","paymentsAlertPageUrl","sender","updatedAt","updatedBy","v"],"sensitiveFields":["fetchLastPosReceiptUrl","paymentsAlertPageUrl"]},"B2CAppAccessRightSet":{"fields":["app","canExecuteSendVoIPStartMessage","createdAt","createdBy","deletedAt","dv","id","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MobileFeatureConfig":{"fields":["commonPhone","contentConfiguration","createdAt","createdBy","deletedAt","dv","id","meta","newId","onlyGreaterThanPreviousMeterReadingIsEnabled","organization","sender","ticketSubmittingIsDisabled","updatedAt","updatedBy","v"],"sensitiveFields":["commonPhone"]},"MarketCategory":{"fields":["createdAt","createdBy","deletedAt","dv","id","image","mobileSettings","name","newId","order","parentCategory","sender","updatedAt","updatedBy","v"],"sensitiveFields":["mobileSettings"]},"MarketItem":{"fields":["createdAt","createdBy","deletedAt","description","dv","id","marketCategory","name","newId","organization","sender","sku","updatedAt","updatedBy","v"],"sensitiveFields":[]},"Invoice":{"fields":["accountNumber","amountDistribution","canceledAt","client","clientName","clientPhone","contact","createdAt","createdBy","deletedAt","dv","id","newId","number","organization","paidAt","payerOrganization","paymentStatusChangeWebhookSecret","paymentStatusChangeWebhookUrl","paymentType","property","publishedAt","rows","sender","status","ticket","toPay","type","unitName","unitType","updatedAt","updatedBy","v"],"sensitiveFields":["amountDistribution","clientName","clientPhone","paymentStatusChangeWebhookSecret","paymentStatusChangeWebhookUrl"]},"MarketItemFile":{"fields":["createdAt","createdBy","deletedAt","dv","file","id","marketItem","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MarketItemPrice":{"fields":["createdAt","createdBy","deletedAt","dv","id","marketItem","newId","price","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MarketPriceScope":{"fields":["createdAt","createdBy","deletedAt","dv","id","marketItemPrice","newId","property","sender","type","updatedAt","updatedBy","v"],"sensitiveFields":[]},"MarketSetting":{"fields":["createdAt","createdBy","deletedAt","dv","id","newId","organization","residentAllowedPaymentTypes","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"DocumentCategory":{"fields":["createdAt","createdBy","deletedAt","dv","id","name","newId","sender","updatedAt","updatedBy","v"],"sensitiveFields":[]},"Document":{"fields":["canReadByResident","category","createdAt","createdBy","deletedAt","dv","file","id","meta","name","newId","organization","property","sender","updatedAt","updatedBy","v"],"sensitiveFields":["file","meta"]},"ExecutionAIFlowTask":{"fields":["aiSessionId","cleanContext","context","createdAt","createdBy","deletedAt","dv","error","errorMessage","flowType","id","itemId","locale","meta","modelName","newId","organization","result","sender","status","updatedAt","updatedBy","user","v"],"sensitiveFields":["cleanContext","context","meta","result"]}}} + +exports.up = async (knex) => { + await knex.raw(` + BEGIN; +-- +-- Add field canExecuteSendVoIPStartMessage to b2cappaccessrightset +-- +ALTER TABLE "B2CAppAccessRightSet" ADD COLUMN "canExecuteSendVoIPStartMessage" boolean DEFAULT false NOT NULL; +ALTER TABLE "B2CAppAccessRightSet" ALTER COLUMN "canExecuteSendVoIPStartMessage" DROP DEFAULT; +-- +-- Add field canExecuteSendVoIPStartMessage to b2cappaccessrightsethistoryrecord +-- +ALTER TABLE "B2CAppAccessRightSetHistoryRecord" ADD COLUMN "canExecuteSendVoIPStartMessage" boolean NULL; +-- +-- Recreate view for "B2CAppAccessRightSet" table +-- +DROP VIEW IF EXISTS "analytics"."B2CAppAccessRightSet"; +CREATE VIEW "analytics"."B2CAppAccessRightSet" AS (SELECT "app", "canExecuteSendVoIPStartMessage", "createdAt", "createdBy", "deletedAt", "dv", "id", "newId", "sender", "updatedAt", "updatedBy", "v" FROM "public"."B2CAppAccessRightSet"); + +COMMIT; + + `) +} + +exports.down = async (knex) => { + await knex.raw(` + BEGIN; +-- +-- Add field canExecuteSendVoIPStartMessage to b2cappaccessrightsethistoryrecord +-- +ALTER TABLE "B2CAppAccessRightSetHistoryRecord" DROP COLUMN "canExecuteSendVoIPStartMessage" CASCADE; +-- +-- Add field canExecuteSendVoIPStartMessage to b2cappaccessrightset +-- +ALTER TABLE "B2CAppAccessRightSet" DROP COLUMN "canExecuteSendVoIPStartMessage" CASCADE; +-- +-- Recreate view for "B2CAppAccessRightSet" table +-- +DROP VIEW IF EXISTS "analytics"."B2CAppAccessRightSet"; +CREATE VIEW "analytics"."B2CAppAccessRightSet" AS (SELECT "app", "createdAt", "createdBy", "deletedAt", "dv", "id", "newId", "sender", "updatedAt", "updatedBy", "v" FROM "public"."B2CAppAccessRightSet"); + +COMMIT; + + `) +} diff --git a/apps/condo/schema.graphql b/apps/condo/schema.graphql index 1bf3db16c3f..5638759c58e 100644 --- a/apps/condo/schema.graphql +++ b/apps/condo/schema.graphql @@ -83298,6 +83298,7 @@ type B2CAppAccessRightSetHistoryRecord { """ _label_: String app: String + canExecuteSendVoIPStartMessage: Boolean id: ID! v: Int createdAt: String @@ -83320,6 +83321,8 @@ input B2CAppAccessRightSetHistoryRecordWhereInput { app_not: String app_in: [String] app_not_in: [String] + canExecuteSendVoIPStartMessage: Boolean + canExecuteSendVoIPStartMessage_not: Boolean id: ID id_not: ID id_in: [ID] @@ -83403,6 +83406,8 @@ input B2CAppAccessRightSetHistoryRecordWhereUniqueInput { } enum SortB2CAppAccessRightSetHistoryRecordsBy { + canExecuteSendVoIPStartMessage_ASC + canExecuteSendVoIPStartMessage_DESC id_ASC id_DESC v_ASC @@ -83423,6 +83428,7 @@ enum SortB2CAppAccessRightSetHistoryRecordsBy { input B2CAppAccessRightSetHistoryRecordUpdateInput { app: String + canExecuteSendVoIPStartMessage: Boolean v: Int createdAt: String updatedAt: String @@ -83444,6 +83450,7 @@ input B2CAppAccessRightSetHistoryRecordsUpdateInput { input B2CAppAccessRightSetHistoryRecordCreateInput { app: String + canExecuteSendVoIPStartMessage: Boolean v: Int createdAt: String updatedAt: String @@ -83478,6 +83485,7 @@ type B2CAppAccessRightSet { """ Link to B2CApp """ app: B2CApp + canExecuteSendVoIPStartMessage: Boolean id: ID! v: Int createdAt: String @@ -83506,6 +83514,8 @@ input B2CAppAccessRightSetWhereInput { OR: [B2CAppAccessRightSetWhereInput] app: B2CAppWhereInput app_is_null: Boolean + canExecuteSendVoIPStartMessage: Boolean + canExecuteSendVoIPStartMessage_not: Boolean id: ID id_not: ID id_in: [ID] @@ -83571,6 +83581,8 @@ input B2CAppAccessRightSetWhereUniqueInput { enum SortB2CAppAccessRightSetsBy { app_ASC app_DESC + canExecuteSendVoIPStartMessage_ASC + canExecuteSendVoIPStartMessage_DESC id_ASC id_DESC v_ASC @@ -83591,6 +83603,7 @@ enum SortB2CAppAccessRightSetsBy { input B2CAppAccessRightSetUpdateInput { app: B2CAppRelateToOneInput + canExecuteSendVoIPStartMessage: Boolean v: Int createdAt: String updatedAt: String @@ -83609,6 +83622,7 @@ input B2CAppAccessRightSetsUpdateInput { input B2CAppAccessRightSetCreateInput { app: B2CAppRelateToOneInput + canExecuteSendVoIPStartMessage: Boolean v: Int createdAt: String updatedAt: String @@ -93722,6 +93736,103 @@ type SendB2BAppPushMessageOutput { id: String! } +input VoIPPanel { + """Dtfm command for panel""" + dtfmCommand: String! + + """Name of a panel to be displayed""" + name: String! +} + +input SendVoIPStartMessageDataForCallHandlingByB2CApp { + """Data that will be provided to B2CApp. May be stringified JSON""" + B2CAppContext: String! +} + +input SendVoIPStartMessageDataForCallHandlingByNative { + """Address of sip server, which device should connect to""" + voipAddress: String! + + """Login for connection to sip server""" + voipLogin: String! + + """Password for connection to sip server""" + voipPassword: String! + + """ + Panels and their commands to open. First one must be the main one. Multiple panels are in testing stage right now and may change + """ + voipPanels: [VoIPPanel!]! + + """ + Stun server urls. Are used to determine device public ip for media streams + """ + stunServers: [String!] + + """Preferred codec (usually vp8)""" + codec: String + + """ + Type of the native client to handle call. Values defined in mobile app. "0" used as legacy "sip" voipType for backwards compatibility. + """ + voipType: Int = 0 +} + +input SendVoIPStartMessageData { + """ + Unique value for each call session between panel and resident (means same for different devices also). + Must be provided for correct work with multiple devices that use same voip call. + F.e. to cancel calls with CANCELED_CALL_MESSAGE_PUSH messages + """ + callId: String! + + """ + If you want your B2CApp to handle incoming VoIP call, provide this argument. + """ + b2cAppCallData: SendVoIPStartMessageDataForCallHandlingByB2CApp + + """ + If you want mobile app to handle call (without your B2CApp), provide this argument. If "b2cAppCallData" and "nativeCallData" are provided together, native call is prioritized. + """ + nativeCallData: SendVoIPStartMessageDataForCallHandlingByNative +} + +input SendVoIPStartMessageInput { + dv: Int! + sender: SenderFieldInput! + app: B2CAppWhereUniqueInput! + + """ + Should be "addressKey" of B2CAppProperty / Property for which you want to send message + """ + addressKey: String! + + """Name of unit, same as in Property map""" + unitName: String! + + """Type of unit, same as in Property map""" + unitType: AllowedVoIPMessageUnitType! + callData: SendVoIPStartMessageData! +} + +type SendVoIPStartMessageOutput { + """ + Count of all Organization Contacts, which we possibly could've sent messages to + """ + verifiedContactsCount: Int + + """Count of Messages that will be sent, one for each verified Resident""" + createdMessagesCount: Int + + """Count of Messages which was not created due to some internal error""" + erroredMessagesCount: Int +} + +enum AllowedVoIPMessageUnitType { + flat + apartment +} + type unauthenticateUserOutput { """ `true` when unauthentication succeeds. @@ -106636,6 +106747,12 @@ type Mutation { "voipDtfmCommand": { "required": false }, + "voipPanels": { + "required": false + }, + "stunServers": { + "required": false + }, "stun": { "required": false }, @@ -108079,6 +108196,37 @@ type Mutation { """ sendB2BAppPushMessage(data: SendB2BAppPushMessageInput!): SendB2BAppPushMessageOutput + """ + Mutation sends VOIP_INCOMING_CALL Messages to each verified resident on address + unit. Also caches calls, so mobile app can properly react to cancel calls. You can either provide all data.* arguments so mobile app will use it's own app to answer call, or provide just B2CAppContext + callId to use your B2CApp's calling app + + + + **Errors** + + Following objects will be presented in `extensions` property of thrown error + + `{ + "code": "BAD_USER_INPUT", + "type": "PROPERTY_NOT_FOUND", + "message": "Unable to find Property or B2CAppProperty by provided addressKey", + "messageForUser": "Building not found for the provided \"addressKey\"" + }` + + `{ + "code": "BAD_USER_INPUT", + "type": "APP_NOT_FOUND", + "message": "Unable to find B2CApp.", + "messageForUser": "Application not found for the provided \"id\"" + }` + + `{ + "code": "BAD_USER_INPUT", + "type": "CALL_DATA_NOT_PROVIDED", + "message": "\"b2cAppCallData\" or \"nativeCallData\" or both should be provided" + }` + """ + sendVoIPStartMessage(data: SendVoIPStartMessageInput!): SendVoIPStartMessageOutput + """ Authenticate and generate a token for a User with the Password Authentication Strategy. """ authenticateUserWithPassword(email: String, password: String): authenticateUserOutput diff --git a/apps/condo/schema.ts b/apps/condo/schema.ts index 209ce7514b7..7ff7818dae0 100644 --- a/apps/condo/schema.ts +++ b/apps/condo/schema.ts @@ -1987,6 +1987,11 @@ export type AllMiniAppsWhereInput = { connected?: InputMaybe; }; +export enum AllowedVoIpMessageUnitType { + Apartment = 'apartment', + Flat = 'flat' +} + export type AmountDistributionField = { __typename?: 'AmountDistributionField'; amount: Scalars['String']['output']; @@ -8289,6 +8294,7 @@ export type B2CAppAccessRightSet = { _label_?: Maybe; /** Link to B2CApp */ app?: Maybe; + canExecuteSendVoIPStartMessage?: Maybe; createdAt?: Maybe; /** Identifies a user, which has created this record. It is a technical connection, that can represent real users, as well as automated systems (bots, scripts). This field should not participate in business logic. */ createdBy?: Maybe; @@ -8307,6 +8313,7 @@ export type B2CAppAccessRightSet = { export type B2CAppAccessRightSetCreateInput = { app?: InputMaybe; + canExecuteSendVoIPStartMessage?: InputMaybe; createdAt?: InputMaybe; createdBy?: InputMaybe; deletedAt?: InputMaybe; @@ -8330,6 +8337,7 @@ export type B2CAppAccessRightSetHistoryRecord = { */ _label_?: Maybe; app?: Maybe; + canExecuteSendVoIPStartMessage?: Maybe; createdAt?: Maybe; createdBy?: Maybe; deletedAt?: Maybe; @@ -8347,6 +8355,7 @@ export type B2CAppAccessRightSetHistoryRecord = { export type B2CAppAccessRightSetHistoryRecordCreateInput = { app?: InputMaybe; + canExecuteSendVoIPStartMessage?: InputMaybe; createdAt?: InputMaybe; createdBy?: InputMaybe; deletedAt?: InputMaybe; @@ -8369,6 +8378,7 @@ export enum B2CAppAccessRightSetHistoryRecordHistoryActionType { export type B2CAppAccessRightSetHistoryRecordUpdateInput = { app?: InputMaybe; + canExecuteSendVoIPStartMessage?: InputMaybe; createdAt?: InputMaybe; createdBy?: InputMaybe; deletedAt?: InputMaybe; @@ -8390,6 +8400,8 @@ export type B2CAppAccessRightSetHistoryRecordWhereInput = { app_in?: InputMaybe>>; app_not?: InputMaybe; app_not_in?: InputMaybe>>; + canExecuteSendVoIPStartMessage?: InputMaybe; + canExecuteSendVoIPStartMessage_not?: InputMaybe; createdAt?: InputMaybe; createdAt_gt?: InputMaybe; createdAt_gte?: InputMaybe; @@ -8490,6 +8502,7 @@ export type B2CAppAccessRightSetRelateToOneInput = { export type B2CAppAccessRightSetUpdateInput = { app?: InputMaybe; + canExecuteSendVoIPStartMessage?: InputMaybe; createdAt?: InputMaybe; createdBy?: InputMaybe; deletedAt?: InputMaybe; @@ -8506,6 +8519,8 @@ export type B2CAppAccessRightSetWhereInput = { OR?: InputMaybe>>; app?: InputMaybe; app_is_null?: InputMaybe; + canExecuteSendVoIPStartMessage?: InputMaybe; + canExecuteSendVoIPStartMessage_not?: InputMaybe; createdAt?: InputMaybe; createdAt_gt?: InputMaybe; createdAt_gte?: InputMaybe; @@ -49948,6 +49963,12 @@ export type Mutation = { * "voipDtfmCommand": { * "required": false * }, + * "voipPanels": { + * "required": false + * }, + * "stunServers": { + * "required": false + * }, * "stun": { * "required": false * }, @@ -50871,6 +50892,36 @@ export type Mutation = { * }` */ sendOrganizationEmployeeRequest?: Maybe; + /** + * Mutation sends VOIP_INCOMING_CALL Messages to each verified resident on address + unit. Also caches calls, so mobile app can properly react to cancel calls. You can either provide all data.* arguments so mobile app will use it's own app to answer call, or provide just B2CAppContext + callId to use your B2CApp's calling app + * + * + * + * **Errors** + * + * Following objects will be presented in `extensions` property of thrown error + * + * `{ + * "code": "BAD_USER_INPUT", + * "type": "PROPERTY_NOT_FOUND", + * "message": "Unable to find Property or B2CAppProperty by provided addressKey", + * "messageForUser": "Building not found for the provided \"addressKey\"" + * }` + * + * `{ + * "code": "BAD_USER_INPUT", + * "type": "APP_NOT_FOUND", + * "message": "Unable to find B2CApp.", + * "messageForUser": "Application not found for the provided \"id\"" + * }` + * + * `{ + * "code": "BAD_USER_INPUT", + * "type": "CALL_DATA_NOT_PROVIDED", + * "message": "\"b2cAppCallData\" or \"nativeCallData\" or both should be provided" + * }` + */ + sendVoIPStartMessage?: Maybe; setMessageStatus?: Maybe; setPaymentPosReceiptUrl?: Maybe; shareTicket?: Maybe; @@ -58717,6 +58768,11 @@ export type MutationSendOrganizationEmployeeRequestArgs = { }; +export type MutationSendVoIpStartMessageArgs = { + data: SendVoIpStartMessageInput; +}; + + export type MutationSetMessageStatusArgs = { data: SetMessageStatusInput; }; @@ -89799,6 +89855,64 @@ export type SendOrganizationEmployeeRequestInput = { sender: SenderFieldInput; }; +export type SendVoIpStartMessageData = { + /** If you want your B2CApp to handle incoming VoIP call, provide this argument. */ + b2cAppCallData?: InputMaybe; + /** + * Unique value for each call session between panel and resident (means same for different devices also). + * Must be provided for correct work with multiple devices that use same voip call. + * F.e. to cancel calls with CANCELED_CALL_MESSAGE_PUSH messages + */ + callId: Scalars['String']['input']; + /** If you want mobile app to handle call (without your B2CApp), provide this argument. If "b2cAppCallData" and "nativeCallData" are provided together, native call is prioritized. */ + nativeCallData?: InputMaybe; +}; + +export type SendVoIpStartMessageDataForCallHandlingByB2CApp = { + /** Data that will be provided to B2CApp. May be stringified JSON */ + B2CAppContext: Scalars['String']['input']; +}; + +export type SendVoIpStartMessageDataForCallHandlingByNative = { + /** Preferred codec (usually vp8) */ + codec?: InputMaybe; + /** Stun server urls. Are used to determine device public ip for media streams */ + stunServers?: InputMaybe>; + /** Address of sip server, which device should connect to */ + voipAddress: Scalars['String']['input']; + /** Login for connection to sip server */ + voipLogin: Scalars['String']['input']; + /** Panels and their commands to open. First one must be the main one. Multiple panels are in testing stage right now and may change */ + voipPanels: Array; + /** Password for connection to sip server */ + voipPassword: Scalars['String']['input']; + /** Type of the native client to handle call. Values defined in mobile app. "0" used as legacy "sip" voipType for backwards compatibility. */ + voipType?: InputMaybe; +}; + +export type SendVoIpStartMessageInput = { + /** Should be "addressKey" of B2CAppProperty / Property for which you want to send message */ + addressKey: Scalars['String']['input']; + app: B2CAppWhereUniqueInput; + callData: SendVoIpStartMessageData; + dv: Scalars['Int']['input']; + sender: SenderFieldInput; + /** Name of unit, same as in Property map */ + unitName: Scalars['String']['input']; + /** Type of unit, same as in Property map */ + unitType: AllowedVoIpMessageUnitType; +}; + +export type SendVoIpStartMessageOutput = { + __typename?: 'SendVoIPStartMessageOutput'; + /** Count of Messages that will be sent, one for each verified Resident */ + createdMessagesCount?: Maybe; + /** Count of Messages which was not created due to some internal error */ + erroredMessagesCount?: Maybe; + /** Count of all Organization Contacts, which we possibly could've sent messages to */ + verifiedContactsCount?: Maybe; +}; + export type SenderField = { __typename?: 'SenderField'; dv: Scalars['Int']['output']; @@ -91396,6 +91510,8 @@ export enum SortB2CAppAccessRightHistoryRecordsBy { } export enum SortB2CAppAccessRightSetHistoryRecordsBy { + CanExecuteSendVoIpStartMessageAsc = 'canExecuteSendVoIPStartMessage_ASC', + CanExecuteSendVoIpStartMessageDesc = 'canExecuteSendVoIPStartMessage_DESC', CreatedAtAsc = 'createdAt_ASC', CreatedAtDesc = 'createdAt_DESC', DeletedAtAsc = 'deletedAt_ASC', @@ -91417,6 +91533,8 @@ export enum SortB2CAppAccessRightSetHistoryRecordsBy { export enum SortB2CAppAccessRightSetsBy { AppAsc = 'app_ASC', AppDesc = 'app_DESC', + CanExecuteSendVoIpStartMessageAsc = 'canExecuteSendVoIPStartMessage_ASC', + CanExecuteSendVoIpStartMessageDesc = 'canExecuteSendVoIPStartMessage_DESC', CreatedAtAsc = 'createdAt_ASC', CreatedAtDesc = 'createdAt_DESC', CreatedByAsc = 'createdBy_ASC', @@ -117562,6 +117680,13 @@ export enum VillageMapType { Village = 'village' } +export type VoIpPanel = { + /** Dtfm command for panel */ + dtfmCommand: Scalars['String']['input']; + /** Name of a panel to be displayed */ + name: Scalars['String']['input']; +}; + /** Webhooks are a way that the APP can send automated web callback with some messages to other apps or system to inform them about any updates. How does it work: 1. When objects are created or changed, we make requests to the GraphQL API to get data on behalf of the specified user; 2. Then we send the data to remote url. Webhook model contains basic configuration of integration, such as external server url, name, encryption parameters and so on. */ export type Webhook = { __typename?: 'Webhook';