You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
658 lines
25 KiB
658 lines
25 KiB
import _ from 'lodash'
|
|
import {
|
|
cfCreateOfficeHours,
|
|
cfCreateSourceSet,
|
|
cfCreateTimeSetDate,
|
|
cfCreateTimeSetDateRange,
|
|
cfCreateTimeSetWeekdays,
|
|
cfDeleteDestinationSet,
|
|
cfDeleteSourceSet,
|
|
cfDeleteTimeSet,
|
|
cfLoadDestinationSets,
|
|
cfLoadMappingsFull,
|
|
cfLoadSourceSets,
|
|
cfLoadTimeSets, cfUpdateOfficeHours,
|
|
cfUpdateSourceSet,
|
|
cfUpdateTimeSetDate,
|
|
cfUpdateTimeSetDateRange,
|
|
cfUpdateTimeSetWeekdays
|
|
} from 'src/api/call-forwarding'
|
|
import {
|
|
get, getList,
|
|
patchReplace,
|
|
patchReplaceFull,
|
|
post, put
|
|
} from 'src/api/common'
|
|
import { i18n } from 'src/boot/i18n'
|
|
import { normalizePriorities } from 'src/helpers/call-forwarding-destinations'
|
|
import { showGlobalError, showGlobalWarning } from 'src/helpers/ui'
|
|
import { v4 } from 'uuid'
|
|
|
|
const DEFAULT_RING_TIMEOUT = 60
|
|
const DEFAULT_PRIORITY = 0
|
|
const WAIT_IDENTIFIER = 'csc-cf-mappings-full'
|
|
|
|
function createDefaultDestination (destination, defaultAnnouncementId, priority = DEFAULT_PRIORITY) {
|
|
const payload = {
|
|
destination: destination || ' ',
|
|
priority,
|
|
timeout: DEFAULT_RING_TIMEOUT
|
|
}
|
|
if (destination === 'customhours') {
|
|
payload.announcement_id = defaultAnnouncementId
|
|
}
|
|
return payload
|
|
}
|
|
|
|
export async function loadMappingsFull ({ dispatch, commit, rootGetters }, id) {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
const subscriberId = id || rootGetters['user/getSubscriberId']
|
|
const mappingData = await cfLoadMappingsFull(subscriberId)
|
|
const mappings = mappingData[0]
|
|
const destinationSets = mappingData[1].items
|
|
|
|
commit('dataSucceeded', {
|
|
mappings,
|
|
destinationSets,
|
|
sourceSets: mappingData[2].items,
|
|
timeSets: mappingData[3].items
|
|
})
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
|
|
export async function createMapping ({ dispatch, commit, state, rootGetters }, payload) {
|
|
try {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
let type = payload.type
|
|
if (payload.type === 'cfu' && state.mappings.cft && state.mappings.cft.length > 0) {
|
|
type = 'cft'
|
|
}
|
|
const subscriberId = payload.subscriberId ? payload.subscriberId : rootGetters['user/getSubscriberId']
|
|
const mappings = _.cloneDeep(state.mappings[type])
|
|
const destinationSet = await post({
|
|
resource: 'cfdestinationsets',
|
|
body: {
|
|
name: `csc-${v4()}`,
|
|
subscriber_id: subscriberId,
|
|
destinations: [createDefaultDestination()]
|
|
}
|
|
})
|
|
|
|
mappings.push({
|
|
destinationset_id: destinationSet.id
|
|
})
|
|
|
|
const patchedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: subscriberId,
|
|
fieldPath: type,
|
|
value: mappings
|
|
})
|
|
const latestDestinationSets = await cfLoadDestinationSets()
|
|
|
|
commit('dataSucceeded', {
|
|
mappings: patchedMappings,
|
|
destinationSets: latestDestinationSets.items
|
|
})
|
|
} catch (error) {
|
|
showGlobalError(error.message)
|
|
} finally {
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
}
|
|
|
|
export async function deleteMapping ({ dispatch, commit, state, rootGetters }, payload) {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
const mappings = _.cloneDeep(state.mappings[payload.type])
|
|
const updatedMappings = mappings.reduce(($updatedMappings, value, index) => {
|
|
if (index !== payload.index) {
|
|
$updatedMappings.push(value)
|
|
}
|
|
return $updatedMappings
|
|
}, [])
|
|
const patchRes = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.type,
|
|
value: updatedMappings
|
|
})
|
|
|
|
try {
|
|
await cfDeleteDestinationSet(payload.destinationset_id)
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'cfdestinationset\' not found.') {
|
|
// This happens when CF was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
} else {
|
|
showGlobalError(e.message)
|
|
}
|
|
}
|
|
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
mappings: patchRes,
|
|
destinationSets: destinationSets.items
|
|
})
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
|
|
export async function toggleMapping ({ dispatch, commit, state, rootGetters }, payload) {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
const updatedMappings = _.cloneDeep(state.mappings[payload.type])
|
|
updatedMappings[payload.index].enabled = !updatedMappings[payload.index].enabled
|
|
const patchRes = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.type,
|
|
value: updatedMappings
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: patchRes
|
|
})
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
|
|
export async function updateDestination ({ dispatch, commit, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-destination-set-update', { root: true })
|
|
const destinations = _.cloneDeep(state.destinationSetMap[payload.destinationSetId].destinations)
|
|
destinations[payload.destinationIndex].destination = payload.destination
|
|
const normalizedDestinations = normalizePriorities(destinations)
|
|
await patchReplace({
|
|
resource: 'cfdestinationsets',
|
|
resourceId: payload.destinationSetId,
|
|
fieldPath: 'destinations',
|
|
value: normalizedDestinations
|
|
})
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
destinationSets: destinationSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-destination-set-update', { root: true })
|
|
}
|
|
|
|
export async function addDestination ({ dispatch, commit, state, rootGetters }, payload) {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
const destinations = _.cloneDeep(state.destinationSetMap[payload.destinationSetId].destinations)
|
|
const normalizedDestinations = normalizePriorities(destinations)
|
|
normalizedDestinations.push(createDefaultDestination(
|
|
payload.destination,
|
|
payload.defaultAnnouncementId,
|
|
normalizedDestinations.length
|
|
))
|
|
await patchReplace({
|
|
resource: 'cfdestinationsets',
|
|
resourceId: payload.destinationSetId,
|
|
fieldPath: 'destinations',
|
|
value: normalizedDestinations
|
|
})
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
destinationSets: destinationSets.items
|
|
})
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
|
|
export async function rewriteDestination ({ dispatch, commit, state, rootGetters }, destination) {
|
|
try {
|
|
const req = await post({
|
|
resource: 'applyrewrites',
|
|
body: {
|
|
direction: 'callee_in',
|
|
subscriber_id: rootGetters['user/getSubscriberId'],
|
|
numbers: [_.trim(destination)]
|
|
}
|
|
})
|
|
return req.result
|
|
} catch (err) {
|
|
return destination
|
|
}
|
|
}
|
|
|
|
export async function removeDestination ({ dispatch, commit, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-destination-set-remove', { root: true })
|
|
const destinations = _.cloneDeep(state.destinationSetMap[payload.destinationSetId].destinations)
|
|
const updatedDestinations = destinations.reduce(($updatedDestinations, value, index) => {
|
|
if (index !== payload.destinationIndex) {
|
|
$updatedDestinations.push(value)
|
|
}
|
|
return $updatedDestinations
|
|
}, [])
|
|
const normalizedDestinations = normalizePriorities(updatedDestinations)
|
|
await patchReplace({
|
|
resource: 'cfdestinationsets',
|
|
resourceId: payload.destinationSetId,
|
|
fieldPath: 'destinations',
|
|
value: normalizedDestinations
|
|
})
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
destinationSets: destinationSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-destination-set-remove', { root: true })
|
|
}
|
|
|
|
export async function updateDestinationTimeout ({ dispatch, commit, state }, payload) {
|
|
dispatch('wait/start', WAIT_IDENTIFIER, { root: true })
|
|
const destinations = _.cloneDeep(state.destinationSetMap[payload.destinationSetId].destinations)
|
|
destinations[payload.destinationIndex].timeout = payload.destinationTimeout
|
|
const normalizedDestinations = normalizePriorities(destinations)
|
|
try {
|
|
await patchReplace({
|
|
resource: 'cfdestinationsets',
|
|
resourceId: payload.destinationSetId,
|
|
fieldPath: 'destinations',
|
|
value: normalizedDestinations
|
|
})
|
|
} catch (e) {
|
|
showGlobalError(e.message)
|
|
}
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
destinationSets: destinationSets.items
|
|
})
|
|
dispatch('wait/end', WAIT_IDENTIFIER, { root: true })
|
|
}
|
|
|
|
export async function loadSourceSets ({ dispatch, commit }) {
|
|
dispatch('wait/start', 'csc-cf-sourcesets', { root: true })
|
|
const sourceSets = await cfLoadSourceSets()
|
|
commit('dataSucceeded', {
|
|
sourceSets: sourceSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-sourcesets', { root: true })
|
|
}
|
|
|
|
export async function createSourceSet ({ dispatch, commit, rootGetters, state }, payload) {
|
|
try {
|
|
dispatch('wait/start', 'csc-cf-source-set-create', { root: true })
|
|
const sourceSetId = await cfCreateSourceSet(rootGetters['user/getSubscriberId'], payload)
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].sourceset_id = sourceSetId
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
const sourceSets = await cfLoadSourceSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
sourceSets: sourceSets.items
|
|
})
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-source-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function updateSourceSet ({ dispatch, commit, rootGetters }, payload) {
|
|
try {
|
|
dispatch('wait/start', 'csc-cf-source-set-create', { root: true })
|
|
await cfUpdateSourceSet(rootGetters['user/getSubscriberId'], payload)
|
|
const sourceSets = await cfLoadSourceSets()
|
|
commit('dataSucceeded', {
|
|
sourceSets: sourceSets.items
|
|
})
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'sourceset\' not found.') {
|
|
// This happens when CF was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
} else {
|
|
showGlobalError(e.message)
|
|
}
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-source-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function deleteSourceSet ({ dispatch, commit, rootGetters, state }, payload) {
|
|
try {
|
|
dispatch('wait/start', 'csc-cf-source-set-create', { root: true })
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].sourceset_id = null
|
|
updatedMapping[payload.mapping.index].sourceset = null
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
try {
|
|
await cfDeleteSourceSet(payload.id)
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'sourceset\' not found.') {
|
|
// This happens when entity was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity from DB.
|
|
// In this scenario the sources is only removed from the mappings.
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
// Force reload of SourceSets
|
|
} else {
|
|
throw e
|
|
}
|
|
}
|
|
const sourceSets = await cfLoadSourceSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
sourceSets: sourceSets.items
|
|
})
|
|
} catch (e) {
|
|
showGlobalError(e.message)
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-source-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function assignSourceSet ({ dispatch, commit, rootGetters, state }, payload) {
|
|
try {
|
|
dispatch('wait/start', 'csc-cf-source-set-create', { root: true })
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].sourceset_id = payload.id
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings
|
|
})
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-source-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function unassignSourceSet ({ dispatch, commit, rootGetters, state }, payload) {
|
|
try {
|
|
dispatch('wait/start', 'csc-cf-source-set-create', { root: true })
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].sourceset_id = null
|
|
updatedMapping[payload.mapping.index].sourceset = null
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings
|
|
})
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-source-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function createTimeSetDate ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
const timeSetId = await cfCreateTimeSetDate(rootGetters['user/getSubscriberId'], payload.date)
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].timeset_id = timeSetId.id
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function updateTimeSetDate ({ dispatch, commit }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
try {
|
|
await cfUpdateTimeSetDate(payload.id, payload.date)
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
timeSets: timeSets.items
|
|
})
|
|
} catch (e) {
|
|
showGlobalError(e.message)
|
|
} finally {
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
}
|
|
|
|
export async function deleteTimeSet ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].timeset_id = null
|
|
updatedMapping[payload.mapping.index].timeset = null
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
try {
|
|
await cfDeleteTimeSet(payload.id)
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'cftimeset\' not found.') {
|
|
// This happens when CF was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
} else {
|
|
showGlobalError(e.message)
|
|
}
|
|
}
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function ringPrimaryNumber ({ commit, rootGetters, state }, payload) {
|
|
const mappings = _.cloneDeep(state.mappings)
|
|
mappings.cft = mappings.cfu
|
|
mappings.cfu = []
|
|
mappings.cft_ringtimeout = 60
|
|
const updatedMappings = await put({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
body: mappings
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings
|
|
})
|
|
}
|
|
|
|
export async function doNotRingPrimaryNumber ({ commit, rootGetters, state }, payload) {
|
|
const mappings = _.cloneDeep(state.mappings)
|
|
mappings.cfu = mappings.cft
|
|
mappings.cft = []
|
|
mappings.cft_ringtimeout = null
|
|
const updatedMappings = await put({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
body: mappings
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings
|
|
})
|
|
}
|
|
|
|
export async function updateRingTimeout ({ commit, rootGetters, state }, payload) {
|
|
// eslint-disable-next-line no-console
|
|
console.debug('aaa')
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: 'cft_ringtimeout',
|
|
value: payload.ringTimeout
|
|
})
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings
|
|
})
|
|
}
|
|
|
|
export async function createTimeSetDateRange ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
const timeSetId = await cfCreateTimeSetDateRange(rootGetters['user/getSubscriberId'], payload.date)
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].timeset_id = timeSetId.id
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function updateTimeSetDateRange ({ dispatch, commit }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
try {
|
|
await cfUpdateTimeSetDateRange(payload.id, payload.date)
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'timeset\' not found.') {
|
|
// This happens when CF was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
} else {
|
|
showGlobalError(e.message)
|
|
}
|
|
}
|
|
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function createTimeSetWeekdays ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
const timeSetId = await cfCreateTimeSetWeekdays(rootGetters['user/getSubscriberId'], payload.weekdays)
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].timeset_id = timeSetId.id
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function updateTimeSetWeekdays ({ dispatch, commit }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
try {
|
|
await cfUpdateTimeSetWeekdays(payload.id, payload.weekdays)
|
|
} catch (e) {
|
|
if (e.code === 404 && e.message === 'Entity \'timeset\' not found.') {
|
|
// This happens when CF was set by Admin therefore current
|
|
// csc user doesn't have rights to delete the entity
|
|
showGlobalWarning(i18n.global.t('Entity belongs to admin'))
|
|
} else {
|
|
showGlobalError(e.message)
|
|
}
|
|
}
|
|
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function createOfficeHours ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
const timeSetId = await cfCreateOfficeHours(rootGetters['user/getSubscriberId'], payload.times)
|
|
const updatedMapping = _.cloneDeep(state.mappings[payload.mapping.type])
|
|
updatedMapping[payload.mapping.index].timeset_id = timeSetId.id
|
|
const updatedMappings = await patchReplaceFull({
|
|
resource: 'cfmappings',
|
|
resourceId: (payload.subscriberId) ? payload.subscriberId : rootGetters['user/getSubscriberId'],
|
|
fieldPath: payload.mapping.type,
|
|
value: updatedMapping
|
|
})
|
|
if (payload.id) {
|
|
await cfDeleteTimeSet(payload.id)
|
|
}
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
mappings: updatedMappings,
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function updateOfficeHours ({ dispatch, commit, rootGetters, state }, payload) {
|
|
dispatch('wait/start', 'csc-cf-time-set-create', { root: true })
|
|
try {
|
|
await cfUpdateOfficeHours(payload.id, payload.times)
|
|
} catch (e) {
|
|
showGlobalError(e.message)
|
|
}
|
|
|
|
const timeSets = await cfLoadTimeSets()
|
|
commit('dataSucceeded', {
|
|
timeSets: timeSets.items
|
|
})
|
|
dispatch('wait/end', 'csc-cf-time-set-create', { root: true })
|
|
}
|
|
|
|
export async function loadAnnouncements ({ dispatch, commit }) {
|
|
try {
|
|
const announcements = await getList({
|
|
resource: 'soundhandles',
|
|
all: true,
|
|
params: {
|
|
group: 'custom_announcements'
|
|
}
|
|
})
|
|
commit('setAnnouncements', announcements.items.map((item) => {
|
|
return { label: item.handle, value: item.id }
|
|
}))
|
|
} catch (err) {
|
|
commit('setAnnouncements', [])
|
|
}
|
|
}
|
|
|
|
export async function getAnnouncementById ({ dispatch, commit, rootGetters, state }, announcementId) {
|
|
const announcement = await get({
|
|
resource: 'soundhandles',
|
|
resourceId: announcementId
|
|
})
|
|
return {
|
|
value: announcement.id,
|
|
label: announcement.handle
|
|
}
|
|
}
|
|
|
|
export async function updateAnnouncement ({ dispatch, commit, state }, payload) {
|
|
try {
|
|
const destinations = _.cloneDeep(state.destinationSetMap[payload.destinationSetId].destinations)
|
|
destinations[payload.destinationIndex].announcement_id = payload.announcementId
|
|
const normalizedDestinations = normalizePriorities(destinations)
|
|
await patchReplace({
|
|
resource: 'cfdestinationsets',
|
|
resourceId: payload.destinationSetId,
|
|
fieldPath: 'destinations',
|
|
value: normalizedDestinations
|
|
})
|
|
} catch (e) {
|
|
showGlobalError(e.message)
|
|
}
|
|
|
|
const destinationSets = await cfLoadDestinationSets()
|
|
commit('dataSucceeded', {
|
|
destinationSets: destinationSets.items
|
|
})
|
|
}
|