def _device(self, user_id, name, destination=''):
funckey_prefix = self.search_extension_feature('phoneprogfunckey')
device_extension = self.search_extension_feature(name)
funckey_args = (user_id, device_extension, destination)
funckey_pattern = xivo_helpers.fkey_extension(funckey_prefix, funckey_args)
hint = self.DEVICE_PATTERN.format(funckey_pattern)
return hint
def _device(self, user_id, name, destination=''):
funckey_prefix = extensions_dao.exten_by_name('phoneprogfunckey')
funckey_args = (user_id, extensions_dao.exten_by_name(name),
destination)
funckey_pattern = xivo_helpers.fkey_extension(funckey_prefix,
funckey_args)
hint = self.DEVICE_PATTERN % funckey_pattern
return hint
def set_user_blf(self, user_id, feature_name, state, target):
with db_utils.session_scope():
try:
exten_prefix = self._exten_features_dao.get_extension(
'phoneprogfunckey')
feature_exten = self._exten_features_dao.get_extension(
feature_name)
except NoSuchExtenFeatureError:
logger.info(
'cannot set BLF %s %s missing extension configuration',
feature_name,
state,
)
return
hint = fkey_extension(exten_prefix, (user_id, feature_exten, target))
cli_command = f'devstate change Custom:{hint} {state}'
result = self._amid_client.command(cli_command)
logger.debug('devstate change result: %s', result['response'][0])
def generate(self, output):
self.generate_voice_menus(self.backend.voicemenus.all(commented=0, order='name'), output)
options = output
conf = None
# load context templates
if hasattr(self, 'contextsconf'):
conf = OrderedConf.OrderedRawConf(filename=self.contextsconf)
if conf.has_conflicting_section_names():
raise ValueError, self.contextsconf + " has conflicting section names"
if not conf.has_section('template'):
raise ValueError, "Template section doesn't exist"
# hints & features (init)
xfeatures = {
'bsfilter': {},
'callgroup': {},
'callmeetme': {},
'callqueue': {},
'calluser': {},
'fwdbusy': {},
'fwdrna': {},
'fwdunc': {},
'phoneprogfunckey': {},
'vmusermsg': {}}
extenumbers = self.backend.extenumbers.all(features=xfeatures.keys())
xfeatures.update(dict([x['typeval'], {'exten': x['exten'], 'commented': x['commented']}] for x in extenumbers))
# foreach active context
for ctx in self.backend.contexts.all(commented=False, order='name', asc=False):
# context name preceded with '!' is ignored
if conf.has_section('!' + ctx['name']):
continue
print >> options, "\n[%s]" % ctx['name']
# context includes
for row in self.backend.contextincludes.all(context=ctx['name'], order='priority'):
print >> options, "include = %s" % row['include']
if conf.has_section(ctx['name']):
section = ctx['name']
elif conf.has_section('type:%s' % ctx['contexttype']):
section = 'type:%s' % ctx['contexttype']
else:
section = 'template'
tmpl = []
for option in conf.iter_options(section):
if option.get_name() == 'objtpl':
tmpl.append(option.get_value()); continue
print >> options, "%s = %s" % (option.get_name(), option.get_value().replace('%%CONTEXT%%', ctx['name']))
print >> options
# test if we are in DUNDi active/active mode
dundi_aa = self.backend.general.get(id=1)['dundi'] == 1
# objects extensions (user, group, ...)
for exten in self.backend.extensions.all(context=ctx['name'], commented=False, order='context'):
app = exten['app']
appdata = list(exten['appdata'].replace('|', ',').split(','))
# active/active mode
if dundi_aa and appdata[0] == 'user':
exten['priority'] += 1
if app == 'Macro':
app = 'Gosub'
appdata = (appdata[0], 's', '1(' + ','.join(appdata[1:]) + ')')
exten['action'] = "%s(%s)" % (app, ','.join(appdata))
self.gen_dialplan_from_template(tmpl, exten, options)
# phone (user) hints
hints = self.backend.hints.all(context=ctx['name'])
if len(hints) > 0:
print >> options, "; phones hints"
for hint in hints:
xid = hint['id']
number = hint['number']
name = hint['name']
proto = hint['protocol'].upper()
if proto == 'IAX':
proto = 'IAX2'
interface = "%s/%s" % (proto, name)
if proto == 'CUSTOM':
interface = name
if number:
print >> options, "exten = %s,hint,%s" % (number, interface)
if not xfeatures['calluser'].get('commented', 1):
print >> options, "exten = %s,hint,%s" % (xivo_helpers.fkey_extension(
xfeatures['calluser']['exten'], (xid,)),
interface)
if not xfeatures['vmusermsg'].get('commented', 1) and int(hint['enablevoicemail']) \
and hint['uniqueid']:
if proto == 'CUSTOM':
print >> options, "exten = %s%s,hint,%s" % (xfeatures['vmusermsg']['exten'], number, interface)
# objects(user,group,...) supervision
phonesfk = self.backend.phonefunckeys.all(context=ctx['name'])
if len(phonesfk) > 0:
print >> options, "\n; phones supervision"
xset = set()
for pkey in phonesfk:
xtype = pkey['typeextenumbersright']
calltype = "call%s" % xtype
if pkey['exten'] is not None:
exten = xivo_helpers.clean_extension(pkey['exten'])
elif xfeatures.has_key(calltype) and not xfeatures[calltype].get('commented', 1):
exten = xivo_helpers.fkey_extension(
xfeatures[calltype]['exten'],
(pkey['typevalextenumbersright'],))
else:
continue
xset.add((exten, ("MeetMe:%s" if xtype == 'meetme' else "Custom:%s") % exten))
for hint in xset:
print >> options, "exten = %s,hint,%s" % hint
# BS filters supervision
bsfilters = self.backend.bsfilterhints.all(context=ctx['name'])
numbers = self._build_sorted_bsfilter(bsfilters)
extens = set(xivo_helpers.speed_dial_key_extension(xfeatures['bsfilter'].get('exten'),
boss, None, secretary, True) for boss, secretary in numbers)
if len(extens) > 0:
print >> options, "\n; BS filters supervision"
for exten in extens:
print >> options, "exten = %s,hint,Custom:%s" % (exten, exten)
# prog funckeys supervision
progfunckeys = self.backend.progfunckeys.all(context=ctx['name'])
extens = set()
for k in progfunckeys:
exten = k['exten']
if exten is None and k['typevalextenumbersright'] is not None:
exten = "*%s" % k['typevalextenumbersright']
extens.add(xivo_helpers.fkey_extension(xfeatures['phoneprogfunckey'].get('exten'),
(k['iduserfeatures'], k['leftexten'], exten)))
if len(extens) > 0:
print >> options, "\n; prog funckeys supervision"
for exten in extens:
print >> options, "exten = %s,hint,Custom:%s" % (exten, exten)
print >> options, self._extensions_features(conf, xfeatures)
return options.getvalue()
agi.verbose("Invalid feature: %r" % feature)
return
try:
featureexten = extenfeatures.get_exten_by_name(feature)
except LookupError, e:
agi.verbose(str(e))
return
xset = set()
forwards = dict(extenfeatures.FEATURES['forwards'])
if feature in forwards:
try:
xset.add(fkey_extension(ppfkexten,
(user.id,
featureexten,
getattr(user, "dest%s" % forwards[feature], ""))))
except ValueError, e:
agi.verbose(str(e))
else:
xset.add(fkey_extension(ppfkexten,
(user.id,
featureexten,
dest)))
for x in xset:
agi.set_variable("DEVICE_STATE(Custom:%s)" % x, devstate)
agid.register(phone_progfunckey_devstate)
def test_fkey_extension_dnd(self):
arguments = ('123', '*25', '')
result = xivo_helpers.fkey_extension(self.PREFIX, arguments)
self.assertEqual(result, '*735123***225')
def test_fkey_extension_unc_fwd_without_destination(self):
arguments = ('123', '_*21.', '')
result = xivo_helpers.fkey_extension(self.PREFIX, arguments)
self.assertEqual(result, '*735123***221')
def generate(self, context):
progfunckey = self.dao.progfunckey_extension()
for hint in self.find_hints(context):
arguments = self.progfunckey_arguments(hint)
extension = fkey_extension(progfunckey, arguments)
yield (extension, 'Custom:{}'.format(extension))
def progfunckey(self, prog_exten, user_id, exten, argument):
return fkey_extension(prog_exten, [user_id, exten, argument])
def get_funckeys(cursor, iduserfeatures, number):
extensions = get_extensions(cursor)
cursor.query(("SELECT ${columns} "
"FROM %s "
"LEFT OUTER JOIN %s AS extenumleft "
"ON %s.typeextenumbers = extenumleft.type "
"AND %s.typevalextenumbers = extenumleft.typeval "
"LEFT OUTER JOIN %s AS extenumright "
"ON %s.typeextenumbersright = extenumright.type "
"AND %s.typevalextenumbersright = extenumright.typeval "
"LEFT OUTER JOIN %s "
"ON %s.typevalextenumbersright = %s.id "
"WHERE iduserfeatures = %%s")
% (FK_TABLE,
XNUM_TABLE,
FK_TABLE,
FK_TABLE,
XNUM_TABLE,
FK_TABLE,
FK_TABLE,
UF_TABLE,
FK_TABLE,
UF_TABLE),
[FK_TABLE+x for x in ('.fknum',
'.exten',
'.supervision',
'.progfunckey',
'.iduserfeatures',
'.label',
'.typeextenumbersright',
'.typevalextenumbersright')]
+ ['extenumleft.exten', 'extenumright.exten',
'extenumleft.type', 'extenumleft.typeval',
'extenumright.type', 'extenumright.typeval']
+ [UF_TABLE+x for x in ('.firstname', '.lastname', '.id', '.context')],
(iduserfeatures,))
funckey = {}
for fk in cursor.fetchall():
isbsfilter = False
fknum = fk[FK_TABLE+'.fknum']
label = fk[FK_TABLE+'.label']
exten = fk[FK_TABLE+'.exten']
fkey = {'exten': None,
'label': label,
'supervision': bool(int(fk[FK_TABLE+'.supervision'])),
'context': fk[UF_TABLE+'.context']}
# SPECIAL CASES:
if fk['extenumleft.type'] is None:
# group, queue or user without number
if fk['extenumright.type'] is None \
and fk[FK_TABLE+'.typeextenumbersright'] in ('group',
'queue',
'user'):
fkey['exten'] = \
fkey_extension(
extensions.get('call' + fk[FK_TABLE+'.typeextenumbersright']),
(fk[FK_TABLE+'.typevalextenumbersright'],))
funckey[fknum] = fkey
continue
elif fk['extenumleft.type'] == 'extenfeatures':
if fk['extenumleft.typeval'] == 'bsfilter':
isbsfilter = True
elif bool(fk[FK_TABLE+'.progfunckey']):
if exten is None and fk[FK_TABLE+'.typevalextenumbersright'] is not None:
exten = '*' + fk[FK_TABLE+'.typevalextenumbersright']
fkey['exten'] = \
fkey_extension(
extensions.get('phoneprogfunckey'),
(fk[FK_TABLE+'.iduserfeatures'],
fk['extenumleft.exten'],
exten))
funckey[fknum] = fkey
continue
if label is None \
and fk[FK_TABLE+'.typeextenumbersright'] == 'user' \
and fk[UF_TABLE+'.id']:
label = name_from_first_last(fk[UF_TABLE+'.firstname'],
fk[UF_TABLE+'.lastname'])
if isbsfilter:
fkey['label'] = "BS:%s" % label
else:
fkey['label'] = label
fkey['exten'] = \
speed_dial_key_extension(
fk['extenumleft.exten'],
fk['extenumright.exten'],
exten,
number,
isbsfilter)
fkey['altlabel'] = fk['extenumleft.typeval']
funckey[fknum] = fkey
return funckey
return
try:
featureexten = extenfeatures.get_exten_by_name(feature)
except LookupError, e:
agi.verbose(str(e))
return
xset = set()
forwards = dict(extenfeatures.FEATURES['forwards'])
if forwards.has_key(feature):
try:
xset.add(
fkey_extension(
ppfkexten,
(user.id, featureexten,
getattr(user, "dest%s" % forwards[feature], ""))))
xset.add(fkey_extension(ppfkexten, (user.id, featureexten)))
except ValueError, e:
agi.verbose(str(e))
xset.add(fkey_extension(ppfkexten, (user.id, featureexten, dest)))
for x in xset:
agi.set_variable("DEVSTATE(Custom:%s)" % x, devstate)
agid.register(phone_progfunckey_devstate)
def progfunckey(self, prog_exten, user_id, exten, argument):
return fkey_extension(prog_exten, [user_id, exten, argument])
