def keyfilter_cmd(args):
if len(args) > 3:
keygroup = args[0]
if es.exists('keygroup', keygroup):
key = args[1]
if es.exists('key', keygroup, key):
action = args[2]
if action in ['not', 'only']:
kv = keyvalues.getKeyGroup(keygroup)
keyfiltervar = args[3]
keyfilterlist = []
if len(args) > 4:
keyfiltervalue = args[4]
else:
keyfiltervalue = None
if action == 'not':
for keyvar in list(kv[key].keys()):
if keyfiltervar in keyvar and (str(kv[key][keyvar]) == keyfiltervalue or not keyfiltervalue):
keyfilterlist.append(keyvar)
elif action == 'only':
for keyvar in list(kv[key].keys()):
if not keyfiltervar in keyvar or (str(kv[key][keyvar]) != keyfiltervalue and keyfiltervalue):
keyfilterlist.append(keyvar)
for keyvar in keyfilterlist:
if keyvar in kv[key]:
del kv[key][keyvar]
else:
es.dbgmsg(0, 'keyfilter: Invalid action provided. Syntax: keyfilter <keygroup> <key> <not/only> <part-of-value-name> [value]')
else:
es.dbgmsg(0, 'keyfilter: Invalid key for keygroup "%s" provided: %s' % (keygroup, key))
else:
es.dbgmsg(0, 'keyfilter: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keyfilter: Not enough arguments to keyfilter. Syntax: <keygroup> <key> <not/only> <part-of-value-name> [value]')
def foreachkey(argv):
var, isin, keygroup, commands = argv[:4]
if isin != 'in':
raise SyntaxError
if not es.exists('keygroup', keygroup):
raise NameError('keygroup', keygroup)
stack.setfor(var, list(getKeyGroup(keygroup).keys()))
stack.insertrawblock(commands)
def foreachval(argv):
var, isin, keygroup, key, commands = argv[:5]
if isin != 'in':
raise SyntaxError
if not es.exists('keygroup', keygroup):
raise NameError('keygroup', keygroup)
if not es.exists('key', keygroup, key):
raise NameError('key', '%s/%s' % (keygroup, key))
stack.setfor(var, list(getKeyGroup(keygroup)[key].keys()))
stack.insertrawblock(commands)
def testKeygroup(self):
es.keygroupcreate("justice")
x = es.keygroupgetpointer("justice")
self.keytest2(x)
es.keygroupdelete("justice2")
es.keygroupcreate("justice2")
x = es.keygroupgetpointer("justice2")
self.keytest3(x)
import keyvalues
y = keyvalues.getKeyGroup("justice2")
es.keygroupdelete("justice2")
def testKeygroup(self):
es.keygroupcreate("justice")
x = es.keygroupgetpointer("justice")
self.keytest2(x)
es.keygroupdelete("justice2")
es.keygroupcreate("justice2")
x = es.keygroupgetpointer("justice2")
self.keytest3(x)
import keyvalues
y = keyvalues.getKeyGroup("justice2")
es.keygroupdelete("justice2")
def keygroupsort_cmd(args):
if len(args) > 1:
keygroup = args[0]
if es.exists('keygroup', keygroup):
dc = {}
kv = keyvalues.getKeyGroup(keygroup)
sortfield = args[1]
if es.exists('keyvalue', keygroup, list(kv.keys())[0], sortfield) or keygroup == sortfield:
if len(args) > 3:
sortorder = 'asc' if args[2].lower() == 'asc' else 'des'
sorttype = '#alpha' if args[3].lower() == '#alpha' else '#numeric'
else:
sortorder = 'des'
sorttype = '#numeric'
for key in list(kv.keys()):
dc[key] = {}
for keyvalue in list(kv[key].keys()):
dc[key][keyvalue] = kv[key][keyvalue]
if keygroup == sortfield:
if sortorder == 'asc' and sorttype == '#alpha':
keylist = sorted(dc.keys())
elif sortorder == 'des' and sorttype == '#alpha':
keylist = sorted(list(dc.keys()), reverse=True)
elif sortorder == 'asc' and sorttype == '#numeric':
keylist = sorted(list(dc.keys()), key=lambda x: int(x) if str(x).isdigit() else x)
else:
keylist = sorted(list(dc.keys()), key=lambda x: int(x) if str(x).isdigit() else x, reverse=True)
else:
if sortorder == 'asc' and sorttype == '#alpha':
keylist = [x[0] for x in sorted(list(dc.items()), key=lambda x: x[1][sortfield])]
elif sortorder == 'des' and sorttype == '#alpha':
keylist = [x[0] for x in sorted(list(dc.items()), key=lambda x: x[1][sortfield], reverse=True)]
elif sortorder == 'asc' and sorttype == '#numeric':
keylist = [x[0] for x in sorted(list(dc.items()), key=lambda x: int(x[1][sortfield]) if str(x[1][sortfield]).isdigit() else x[1][sortfield])]
else:
keylist = [x[0] for x in sorted(list(dc.items()), key=lambda x: int(x[1][sortfield]) if str(x[1][sortfield]).isdigit() else x[1][sortfield], reverse=True)]
# Let's re-create our keygroup with classic ES commands
es.keygroupdelete(keygroup)
es.keygroupcreate(keygroup)
for key in keylist:
es.keycreate(keygroup, key)
for keyvalue in list(dc[key].keys()):
es.keysetvalue(keygroup, key, keyvalue, dc[key][keyvalue])
else:
es.dbgmsg(0, 'keygroupsort: Invalid field to sort provided: %s' % sortfield)
else:
es.dbgmsg(0, 'keygroupsort: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keygroupsort: Not enough arguments to keygroupsort. Syntax: keygroupsort <keygroup> <field to sort> [<des/asc #numeric/#alpha>]')
def keygroupsort_cmd(args):
if len(args) > 1:
keygroup = args[0]
if es.exists('keygroup', keygroup):
dc = {}
kv = keyvalues.getKeyGroup(keygroup)
sortfield = args[1]
if es.exists('keyvalue', keygroup, kv.keys()[0], sortfield) or keygroup == sortfield:
if len(args) > 3:
sortorder = 'asc' if args[2].lower() == 'asc' else 'des'
sorttype = '#alpha' if args[3].lower() == '#alpha' else '#numeric'
else:
sortorder = 'des'
sorttype = '#numeric'
for key in kv.keys():
dc[key] = {}
for keyvalue in kv[key].keys():
dc[key][keyvalue] = kv[key][keyvalue]
if keygroup == sortfield:
if sortorder == 'asc' and sorttype == '#alpha':
keylist = sorted(dc.keys())
elif sortorder == 'des' and sorttype == '#alpha':
keylist = sorted(dc.keys(), reverse=True)
elif sortorder == 'asc' and sorttype == '#numeric':
keylist = sorted(dc.keys(), key=lambda x: int(x) if str(x).isdigit() else x)
else:
keylist = sorted(dc.keys(), key=lambda x: int(x) if str(x).isdigit() else x, reverse=True)
else:
if sortorder == 'asc' and sorttype == '#alpha':
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: x[1][sortfield]))
elif sortorder == 'des' and sorttype == '#alpha':
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: x[1][sortfield], reverse=True))
elif sortorder == 'asc' and sorttype == '#numeric':
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: int(x[1][sortfield]) if str(x[1][sortfield]).isdigit() else x[1][sortfield]))
else:
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: int(x[1][sortfield]) if str(x[1][sortfield]).isdigit() else x[1][sortfield], reverse=True))
# Let's re-create our keygroup with classic ES commands
es.keygroupdelete(keygroup)
es.keygroupcreate(keygroup)
for key in keylist:
es.keycreate(keygroup, key)
for keyvalue in dc[key].keys():
es.keysetvalue(keygroup, key, keyvalue, dc[key][keyvalue])
else:
es.dbgmsg(0, 'keygroupsort: Invalid field to sort provided: %s' % sortfield)
else:
es.dbgmsg(0, 'keygroupsort: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keygroupsort: Not enough arguments to keygroupsort. Syntax: keygroupsort <keygroup> <field to sort> [<des/asc #numeric/#alpha>]')
def keyrand_cmd(args):
if len(args) > 1:
keygroup = args[1]
if es.exists('keygroup', keygroup):
kv = keyvalues.getKeyGroup(keygroup)
if not len(args) > 2:
es.ServerVar(args[0]).set(str(random.choice(list(kv.keys()))))
elif es.exists('key', keygroup, args[2]):
es.ServerVar(args[0]).set(str(random.choice(list(kv[args[2]].keys()))))
else:
es.dbgmsg(0, 'keyrand: Invalid key for keygroup "%s" provided: %s' % (keygroup, args[2]))
else:
es.dbgmsg(0, 'keyrand: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keyrand: Not enough arguments to keyrand. Syntax: keyrand <variable> <keygroup> [key]')
def keyfilter_cmd(args):
if len(args) > 3:
keygroup = args[0]
if es.exists('keygroup', keygroup):
key = args[1]
if es.exists('key', keygroup, key):
action = args[2]
if action in ['not', 'only']:
kv = keyvalues.getKeyGroup(keygroup)
keyfiltervar = args[3]
keyfilterlist = []
if len(args) > 4:
keyfiltervalue = args[4]
else:
keyfiltervalue = None
if action == 'not':
for keyvar in kv[key].keys():
if keyfiltervar in keyvar and (str(kv[key][keyvar]) == keyfiltervalue or not keyfiltervalue):
keyfilterlist.append(keyvar)
elif action == 'only':
for keyvar in kv[key].keys():
if not keyfiltervar in keyvar or (str(kv[key][keyvar]) != keyfiltervalue and keyfiltervalue):
keyfilterlist.append(keyvar)
for keyvar in keyfilterlist:
if keyvar in kv[key]:
kv[key][keyvar] = keyvalues.KeyValues(name=' ')
if keyfilterlist:
# Let's remove our deleted keys by reloading the keygroup with classic ES commands
es.keygroupsave(keygroup, '|corelib/keyfilter')
es.keygroupdelete(keygroup)
es.keygroupcreate(keygroup)
es.keygroupload(keygroup, '|corelib/keyfilter')
os.unlink(es.getAddonPath('corelib/keyfilter')+'/es_%s_db.txt'%keygroup)
else:
es.dbgmsg(0, 'keyfilter: Invalid action provided. Syntax: keyfilter <keygroup> <key> <not/only> <part-of-value-name> [value]')
else:
es.dbgmsg(0, 'keyfilter: Invalid key for keygroup "%s" provided: %s' % (keygroup, key))
else:
es.dbgmsg(0, 'keyfilter: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keyfilter: Not enough arguments to keyfilter. Syntax: <keygroup> <key> <not/only> <part-of-value-name> [value]')
def keygrouprand_cmd(args):
if len(args) > 0:
keygroup = args[0]
if es.exists('keygroup', keygroup):
if len(args) > 1:
target = args[1]
else:
target = '#all'
if target in ['#key', '#keyvalue', '#all']:
dc = {}
kv = keyvalues.getKeyGroup(keygroup)
if len(args) > 2 and args[2].isdigit():
keylimit = int(args[2])
else:
keylimit = len(list(kv.keys()))
for key in list(kv.keys()):
dc[key] = {}
for keyvalue in list(kv[key].keys()):
dc[key][keyvalue] = kv[key][keyvalue]
if target == '#all' or target == '#key':
keylist = random.sample(list(dc.keys()), keylimit)
else:
keylist = list(dc.keys())[:keylimit]
# Let's re-create our keygroup with classic ES commands
es.keygroupdelete(keygroup)
es.keygroupcreate(keygroup)
for key in keylist:
es.keycreate(keygroup, key)
if target == '#all' or target == '#keyvalue':
for keyvalue in random.sample(list(dc[key].keys()), len(dc[key])):
es.keysetvalue(keygroup, key, keyvalue, dc[key][keyvalue])
else:
for keyvalue in list(dc[key].keys()):
es.keysetvalue(keygroup, key, keyvalue, dc[key][keyvalue])
else:
es.dbgmsg(0, 'keygrouprand: Invalid target provided: %s' % target)
else:
es.dbgmsg(0, 'keygrouprand: Invalid keygroup provided: %s' % keygroup)
else:
es.dbgmsg(0, 'keygrouprand: Not enough arguments to keygrouprand. Syntax: keygrouprand <keygroup> [#key/#keyvalue/#all] [keylimit]')
def __init__(self, gKeymenuid, returnvar, block, keygroup, menudisplay, menureturn, titletext, update = None, backpopup = None):
#initialization of keymenu
self.name = gKeymenuid #keymenu name for backwards compatibility
self.keygroup = keygroup #keygroup that is used to create the menu
self.block = block #block/function that executes on menuselect
self.returnvar = returnvar #variable that contains the menu-return
self.titletext = titletext #title of the keymenu
self.menudisplay = menudisplay #indicator for the display key or keyvalue
self.menureturn = menureturn #indicator for the return key or keyvalue
self.popup = None #contains the popup object
self.backpopup = backpopup #contains the back popup object
self.keyvalues = None #contains the keyvalues object
self.pagecount = 0 #number of pages
self.linecount = 0 #number of options in the menu
#create the popup object
if es.exists("keygroup", self.keygroup) or isinstance(self.keygroup, keyvalues.KeyValues):
if "#" in self.menudisplay and "#" in self.menureturn:
self.menudisplay = self.menudisplay.split(" ")
self.menureturn = self.menureturn.split(" ")
if not len(self.menudisplay) > 1:
self.menudisplay.append('')
if not len(self.menureturn) > 1:
self.menureturn.append('')
if len(self.titletext) > 0:
self.popup = popuplib.easymenu("keymenu_"+str(self.name), self.returnvar, _keymenu_select)
self.popup.settitle(self.titletext)
self.popup.vguititle = self.titletext.replace('\\n', ' - ')
if not isinstance(self.keygroup, keyvalues.KeyValues):
self.keyvalues = keyvalues.getKeyGroup(self.keygroup)
else:
self.keyvalues = self.keygroup
self.keygroup = self.keyvalues.getName()
if self.menudisplay[0] == "#key" and self.menureturn[0] == "#key":
for key in self.keyvalues.keys():
self.popup.addoption(key, key)
self.linecount += 1
elif self.menudisplay[0] == "#key" and self.menureturn[0] == "#keyvalue":
for key in self.keyvalues.keys():
self.popup.addoption(self.keyvalues[key][self.menureturn[1]], key)
self.linecount += 1
elif self.menudisplay[0] == "#keyvalue" and self.menureturn[0] == "#key":
for key in self.keyvalues.keys():
self.popup.addoption(key, self.keyvalues[key][self.menudisplay[1]])
self.linecount += 1
elif self.menudisplay[0] == "#keyvalue" and self.menureturn[0] == "#keyvalue":
for key in self.keyvalues.keys():
self.popup.addoption(self.keyvalues[key][self.menureturn[1]], self.keyvalues[key][self.menudisplay[1]])
self.linecount += 1
if self.linecount:
self.popup.checklang('en')
else:
self.popup.delete()
self.popup = None
self.keyvalues = None
raise ValueError("Keymenulib: No keys or keyvalues found in %s"%keygroup)
else:
raise ArgumentError("Keymenulib: No titletext")
else:
raise ArgumentError("Keymenulib: No #key or #keyvalue found in the commandstring")
else:
raise ValueError("Keymenulib: The keygroup %s does not exists"%keygroup)
def sendVguiDialogKeygroup(userid, msgtype, keyname):
key = keyvalues.getKeyGroup(keyname)
if not id:
raise KeyError, keyname
es.sendkeypmsg(int(userid), int(msgtype), key['message']._id_)
def sendVguiDialogKeygroup(userid, msgtype, keyname):
key = keyvalues.getKeyGroup(keyname)
if not id:
raise KeyError, keyname
es.sendkeypmsg(int(userid), int(msgtype), key['message']._id_)
def keygroupsort_cmd(args):
if len(args) > 1:
keygroup = args[0]
if es.exists("keygroup", keygroup):
dc = {}
kv = keyvalues.getKeyGroup(keygroup)
sortfield = args[1]
if es.exists("keyvalue", keygroup, kv.keys()[0], sortfield) or keygroup == sortfield:
if len(args) > 3:
sortorder = "asc" if args[2].lower() == "asc" else "des"
sorttype = "#alpha" if args[3].lower() == "#alpha" else "#numeric"
else:
sortorder = "des"
sorttype = "#numeric"
for key in kv.keys():
dc[key] = {}
for keyvalue in kv[key].keys():
dc[key][keyvalue] = kv[key][keyvalue]
if keygroup == sortfield:
if sortorder == "asc" and sorttype == "#alpha":
keylist = sorted(dc.keys())
elif sortorder == "des" and sorttype == "#alpha":
keylist = sorted(dc.keys(), reverse=True)
elif sortorder == "asc" and sorttype == "#numeric":
keylist = sorted(dc.keys(), key=lambda x: int(x) if str(x).isdigit() else x)
else:
keylist = sorted(dc.keys(), key=lambda x: int(x) if str(x).isdigit() else x, reverse=True)
else:
if sortorder == "asc" and sorttype == "#alpha":
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: x[1][sortfield]))
elif sortorder == "des" and sorttype == "#alpha":
keylist = map(lambda x: x[0], sorted(dc.items(), key=lambda x: x[1][sortfield], reverse=True))
elif sortorder == "asc" and sorttype == "#numeric":
keylist = map(
lambda x: x[0],
sorted(
dc.items(),
key=lambda x: int(x[1][sortfield])
if str(x[1][sortfield]).isdigit()
else x[1][sortfield],
),
)
else:
keylist = map(
lambda x: x[0],
sorted(
dc.items(),
key=lambda x: int(x[1][sortfield])
if str(x[1][sortfield]).isdigit()
else x[1][sortfield],
reverse=True,
),
)
# Let's re-create our keygroup with classic ES commands
es.keygroupdelete(keygroup)
es.keygroupcreate(keygroup)
for key in keylist:
es.keycreate(keygroup, key)
for keyvalue in dc[key].keys():
es.keysetvalue(keygroup, key, keyvalue, dc[key][keyvalue])
else:
es.dbgmsg(0, "keygroupsort: Invalid field to sort provided: %s" % sortfield)
else:
es.dbgmsg(0, "keygroupsort: Invalid keygroup provided: %s" % keygroup)
else:
es.dbgmsg(
0,
"keygroupsort: Not enough arguments to keygroupsort. Syntax: keygroupsort <keygroup> <field to sort> [<des/asc #numeric/#alpha>]",
)
