async def pirata(self, ctx):
em = discord.Embed(
title='pirata',
description='Arrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr',
color=ctx.message.author.color)
em.add_field(name=get_string(ctx, 'sintassi'),
value=get_string(ctx, 'v_pirate'))
em.add_field(name='alias', value=get_string(ctx, 'nessuno'))
await ctx.send(embed=em)
def player_join(update: Update, context: CallbackContext):
query = update.callback_query
chat_data = context.chat_data
first_name = update.effective_user.first_name
user_id = update.effective_user.id
chat_id = update.effective_chat.id
# somehow, this callback button is there, but we aren't in join mode, so we handle this now :D
if "message" not in chat_data:
group_helpers.no_game(update, context, "join_no_game_running")
return
starter = mention_html(chat_data["starter"]["user_id"],
chat_data["starter"]["first_name"])
remove = False
for player in chat_data["players"]:
player_id = player["user_id"]
# player leaves
if user_id == player_id:
chat_data["players"].remove({
"user_id": user_id,
"first_name": first_name
})
# we need them in here so we can mention them later. Looks stupid, I know
chat_data["left_players"][user_id] = first_name
query.answer(get_string(chat_data["lang"], "player_leaves_query"))
remove = True
break
if not remove:
# if they left and rejoined before the timer run through, they are still in this dict. If not, nothing happens
chat_data["left_players"].pop(user_id, None)
chat_data["players"].append({
"user_id": user_id,
"first_name": first_name
})
query.answer(get_string(chat_data["lang"], "player_joins_query"))
players = group_helpers.players_mentions(chat_data["players"])
job = context.job_queue.get_jobs_by_name(chat_id)[0]
job.context["players"] = chat_data["players"]
job.context["left_players"] = chat_data["left_players"]
text = get_string(chat_data["lang"],
"start_game").format(starter, players,
*chat_data["settings"])
if len(chat_data["players"]) == MAX_PLAYERS:
query.edit_message_text(text, parse_mode=ParseMode.HTML)
payload = job.context
job.schedule_removal()
new_context = context
setattr(new_context, "job",
Job(timer, interval=42, name=chat_id, context=payload))
timer(context)
return
button = [[
InlineKeyboardButton(get_string(chat_data["lang"], "start_button"),
callback_data="join")
]]
query.edit_message_text(text,
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(button))
async def emoji_animate(self, ctx):
emoji = []
for k, v in self.dic.items():
if isinstance(v, str) and re.match(animated_emoji_pattern, v):
emoji.append(k)
em = discord.Embed(title=get_string(ctx, 'em_an'),
description=get_string(ctx, 'd_em_an'))
em.add_field(name='Lista', value=emoji)
await ctx.send(embed=em)
def deck(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(update.effective_user.id)
lang = user_data["lang"]
here = get_string(lang, "here")
decks_link = f"<a href=\"{DECKS_LINK}\">{here}</a>"
group_link = f"<a href=\"{TRANSLATION_CHAT_LINK}\">{here}</a>"
update.effective_message.reply_html(get_string(lang, "deck").format(decks_link, group_link))
def yes_game(context, data, chat_id, dp):
chat_data = dp.chat_data[chat_id]
lang = data["lang"]
group_settings = data["group_settings"]
deck = Deck(*group_settings["deck"].split("_"))
chameleon = random.choice(list(data["players"]))
random.shuffle(data["players"])
game_id = ''.join(random.choices(string.ascii_lowercase, k=10))
chat_data.update({"chameleon": chameleon, "secret": deck.secret, "players": data["players"], "lang": lang,
"starter": data["starter"], "words": deck.words, "game_id": game_id,
"fewer": group_settings["fewer"], "tournament": group_settings["tournament"],
"more": group_settings["more"], "pin": group_settings["pin"], "restrict": {},
"deck": group_settings["deck"], "tutorial": data["tutorial"],
"exclamation": group_settings["exclamation"]})
text = get_string(lang, "game_succeed").format(deck.topic, deck.word_list)
button = InlineKeyboardMarkup([[InlineKeyboardButton(get_string(lang, "play_button"),
callback_data="word" + game_id)]])
message = context.bot.send_message(chat_id, text, reply_to_message_id=data["message"], reply_markup=button,
parse_mode=ParseMode.HTML)
chat = None
if group_settings["pin"] or group_settings["restrict"]:
chat = context.bot.get_chat(chat_id)
if group_settings["pin"]:
pinned_message = chat.pinned_message
if pinned_message:
chat_data["pin"] = pinned_message.message_id
try:
context.bot.pin_chat_message(chat_id, message.message_id, True)
except BadRequest as e:
if e.message == "Not enough rights to pin a message":
chat_data["pin"] = False
database.insert_group_pin(chat_id)
e.message += "handled in ghelper L48"
raise e
user = data["players"][0]
text = get_string(lang, "first_player_say_word").format(mention_html(user["user_id"], user["first_name"]))
if not group_settings["restrict"]:
if group_settings["exclamation"]:
text += "\n\n" + get_string(lang, "exclamation_activated")
else:
text += "\n\n" + get_string(lang, "exclamation_deactivated")
context.bot.send_message(chat_id, text, reply_to_message_id=message.message_id, parse_mode=ParseMode.HTML)
if group_settings["restrict"]:
chat_data["restrict"]["initial_permissions"] = chat.permissions
try:
context.bot.set_chat_permissions(chat_id, ChatPermissions(can_send_messages=False))
if not is_admin(context.bot, user["user_id"], chat):
context.bot.promote_chat_member(chat_id, user["user_id"], can_invite_users=True)
chat_data["restrict"]["skip"] = False
else:
chat_data["restrict"]["skip"] = True
except BadRequest as e:
chat_data["restrict"] = False
database.insert_group_restrict(chat_id)
e.message += "handled in ghelper L68"
raise e
chat_data["word_list"] = message.message_id
def editor(m):
try:
langs = {'24': '#py', '5': '#py2', '8': '#php'}
uid = m.from_user.id
cid = m.chat.id
request_id = m.message_id
data = json.loads(
f.open('./codes/{}/{}/{}_code.json'.format(cid, uid, request_id),
'r').read())
lang = data['lang']
response_id = data['response_id']
code = m.text.replace('{}\n'.format(langs[str(lang)]), '', 1)
modified = modify_the_code(code)
code = modified[0]
k = types.InlineKeyboardMarkup()
b = types.InlineKeyboardButton(text="Info",
callback_data="info_{}/{}/{}".format(
cid, uid, request_id))
k.add(b)
try:
bot.send_chat_action(cid, 'typing')
compiled = run(lang, code)
if len(str(compiled.result)) <= 3000:
if compiled.success:
bot.edit_message_text(chat_id=cid,
message_id=response_id,
text=get_string('output').format(
html_converter(compiled.result)),
parse_mode='html',
reply_markup=k)
else:
bot.edit_message_text(
chat_id=cid,
message_id=response_id,
text=get_string('output_error').format(
html_converter(compiled.errors)),
parse_mode='html',
reply_markup=k)
else:
bot.edit_message_text(chat_id=cid,
message_id=response_id,
text=get_string('output_too_large'),
parse_mode='html',
reply_markup=k)
data = {
"response_id": response_id,
"stats": compiled.stats,
"lang": lang
}
f.open('./codes/{}/{}/{}_code.json'.format(cid, uid, request_id),
'w').write(json.dumps(data))
except Exception as e:
log(e)
except Exception as e:
log(e)
async def cancella_insulto_dalla_lista(self, ctx):
em = discord.Embed(
title='Cancella insulto dalla lista',
description=
'Cancella un insulto dal database, comando lungo apposta per essere certi di quello che si fa',
color=ctx.message.author.color)
em.add_field(name=get_string(ctx, 'sintassi'),
value='$cancella_insulto_dalla_lista [id]')
em.add_field(name='alias', value=get_string(ctx, 'nessuno'))
await ctx.send(embed=em)
def addDeclaration(self, _document):
# title 'Confidential'
pDeclarationTitle = P(stylename='deckblatt.deklaration',
text=get_string(6, self._language))
_document.text.addElement(pDeclarationTitle)
# declaration
pDeclaration = P(stylename='deckblatt.deklaration.klein',
text=get_string(5, self._language))
_document.text.addElement(pDeclaration)
def edit(query, chat_id, lang, refresh_id=0):
buttons = group_settings_helpers.group_settings_buttons(
get_string(lang, "group_setting_buttons"), chat_id, refresh_id)
chat_details = database.get_group_title(chat_id)
chat_link = helpers.chat_link(chat_details["title"], chat_details["link"])
text = get_string(lang, "group_setting_text").format(chat_link)
query.edit_message_text(text,
reply_markup=InlineKeyboardMarkup(buttons),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
def tournament(update: Update, context: CallbackContext):
query = update.callback_query
chat_id = int(query.data.split("_")[1])
lang = context.user_data["lang"]
tournament_setting = database.insert_group_tournament(chat_id)
if tournament_setting:
query.answer(get_string(lang, "group_setting_tournament_activate"))
else:
query.answer(get_string(lang, "group_setting_tournament_deactivate"))
edit(query, chat_id, lang)
def addDeclaration(self, _document):
# title 'Confidential'
pDeclarationTitle = P(stylename='deckblatt.deklaration',
text=get_string(6, self._language))
_document.text.addElement(pDeclarationTitle)
# declaration
pDeclaration = P(stylename='deckblatt.deklaration.klein',
text=get_string(5, self._language))
_document.text.addElement(pDeclaration)
def settings_help(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(
update.effective_user.id)
lang = user_data["lang"]
buttons = private_helpers.help_buttons(
get_string(lang, "group_setting_buttons"), None)
update.effective_message.reply_text(
get_string(lang, "settings_help"),
reply_markup=InlineKeyboardMarkup(buttons))
def setFooterData(self, _document):
# footer
fs = FooterStyle()
headerFooterProp = HeaderFooterProperties(minheight="0cm",
marginleft="0cm",
marginright="0cm",
margintop="0.499cm")
fs.addElement(headerFooterProp)
self._pl.addElement(fs)
f = Footer()
self._mp.addElement(f)
# styles in 'footer'
sf = Style(name="Footer",
family="paragraph",
attributes={'class': "extra"})
text = TextProperties(color=curesecOrange,
fontfamily=curesecFont,
fontsize="9pt")
sf.addElement(text)
_document.styles.addElement(sf)
# copyright
pCopyright = P(stylename=sf, text=get_string(12, self._language))
f.addElement(pCopyright)
# page number/count styles
ps = Style(name="MP5", family="paragraph", parentstylename=sf)
_document.styles.addElement(ps)
pageStyle = ParagraphProperties(textalign="right")
ps.addElement(pageStyle)
pPage = P(stylename=ps)
f.addElement(pPage)
# linebreak
lb = LineBreak()
pPage.addElement(lb)
# 'Seite'
wordingPage = Span(text=get_string(8, self._language) + " ")
pPage.addElement(wordingPage)
# current page
currentPage = PageNumber(selectpage="current")
pPage.addElement(currentPage)
# slash
slash = Span(text="/")
pPage.addElement(slash)
# page count
pageCount = PageCount()
pPage.addElement(pageCount)
def translation(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(update.effective_user.id)
lang = user_data["lang"]
here = get_string(lang, "here")
translations_link = f"<a href=\"{TRANSLATIONS_LINK}\">{here}</a>"
html_style_link = f"<a href=\"{HTML_STYLE_LINK}\">{here}</a>"
group_link = f"<a href=\"{TRANSLATION_CHAT_LINK}\">{here}</a>"
update.effective_message.reply_html(get_string(lang, "translation").format(translations_link, html_style_link,
group_link))
def who_wins(context, chat_id, unmasked_id):
chat_data = context.chat_data
players = chat_data["players"]
lang = chat_data["lang"]
buttons = word_buttons(chat_data["words"])
if unmasked_id == chat_data["chameleon"]["user_id"]:
text = None
chat_data["guesses"] = 1
if len(players) == 3:
if chat_data["fewer"]:
text = get_string(lang, "chameleon_found_fewer")
chat_data["guesses"] = 2
elif len(players) > 5:
if chat_data["more"]:
text = get_string(lang, "chameleon_found_more")
context.bot.edit_message_text(
get_string(lang,
"game_succeed").format("hidden", "hidden"),
chat_id, chat_data["word_list"])
buttons = None
if not text:
text = get_string(lang, "chameleon_found")
chameleon_found = True
else:
text = get_string(lang, "chameleon_not_found")
chameleon_found = False
chameleon_id = chat_data["chameleon"]["user_id"]
chameleon_mention = mention_html(chameleon_id,
chat_data["chameleon"]["first_name"])
if chameleon_found:
if buttons:
context.bot.send_message(chat_id,
text.format(chameleon_mention),
reply_markup=ReplyKeyboardMarkup(
buttons,
selective=True,
resize_keyboard=True),
parse_mode=ParseMode.HTML)
else:
context.bot.send_message(chat_id,
text.format(chameleon_mention),
parse_mode=ParseMode.HTML)
else:
vote_mention = None
for player in players:
if player["user_id"] == unmasked_id:
vote_mention = mention_html(unmasked_id, player["first_name"])
break
text = text.format(vote_mention, chameleon_mention,
chat_data["secret"])
game_end(context, text, chat_id, chameleon_id, [chameleon_id], lang)
def exclamation(update: Update, context: CallbackContext):
query = update.callback_query
data = query.data.split("_")
chat_id = int(data[1])
refresh_id = 1
if int(data[3]) != 0:
refresh_id = 0
lang = context.user_data["lang"]
exclamation_setting = database.insert_group_exclamation(chat_id)
if exclamation_setting:
query.answer(get_string(lang, "group_setting_exclamation_activate"))
else:
query.answer(get_string(lang, "group_setting_exclamation_deactivate"))
edit(query, chat_id, lang, refresh_id)
def settings_help_edit(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(update.effective_user.id)
lang = user_data["lang"]
query = update.callback_query
data = query.data.split("_")
chosen = data[1]
refresh_id = 1
if int(data[2]) != 0:
refresh_id = 0
buttons = private_helpers.help_buttons(get_string(lang, "group_setting_buttons"), chosen, refresh_id)
query.edit_message_text(get_string(lang, f"{chosen}_help"), reply_markup=InlineKeyboardMarkup(buttons),
parse_mode=ParseMode.HTML, disable_web_page_preview=True)
def modify_the_code(data):
changed = False
human = get_string('zen')
odamgarchilik = get_string('zen_uz')
patterns = ['import\s+human', 'import\s+odamgarchilik']
origin_code = [human, odamgarchilik]
for pattern in patterns:
found = re.findall(pattern, data)
for i in found:
changed = True
data = data.replace(
i,
'print("""{}""")'.format(origin_code[patterns.index(pattern)]))
return data, changed
def handle_help(message):
if str(message.chat.id) in languages_db.keys():
bot.send_message(
message.chat.id,
strings.get_string(languages_db[str(message.chat.id)], 'help'))
else:
handle_start(message, True)
def help_message(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(
update.effective_user.id)
update.effective_message.reply_text(
get_string(user_data["lang"], "help_private"))
def login(login, password):
method = "login"
try:
data = json.loads(
r.post(base_url + method,
json={
"username": login,
"pswd": password
},
timeout=5).text)
lms = LMS(login, password)
if lms.check_credentials():
current_semester = lms.get_current_semester_id()
current_month = int(datetime.now().strftime("%m"))
current_year = int(datetime.now().strftime("%Y"))
if current_month < 9:
freshman_year = current_year - (current_semester // 4 + 1)
else:
freshman_year = current_year - (current_semester // 4)
data['freshman_year'] = freshman_year
except Exception as e:
raise Exception(e)
logger.log(e)
return {'ok': False, 'desc': get_string('reg_fatal_error')}
# try:
# data = json.loads(data.text)
# except:
# data = {'ok': False, 'desc': get_string('reg_fatal_error')}
return data
async def lang(ctx: discord.Message, language: str):
# Controllo lingua selezionata e inserimento nel database dopo cancellamento
# con un thread per mandare il messaggio prima
if language == 'it':
Thread(target=lambda: [
use_database(f"DELETE FROM lang WHERE ch_id = {ctx.guild.id}",
commit=True),
use_database(f"INSERT INTO lang VALUES({ctx.guild.id}, 'it')",
commit=True),
reload_lang()
]).start()
await ctx.channel.send('Lingua messa in italiano!')
elif language == 'en':
Thread(target=lambda: [
use_database(f"DELETE FROM lang WHERE ch_id = {ctx.guild.id}",
commit=True),
use_database(f"INSERT INTO lang VALUES({ctx.guild.id}, 'en')",
commit=True),
reload_lang()
]).start()
await ctx.channel.send('Language set to english!')
elif language == 'OwO':
Thread(target=lambda: [
use_database(f"DELETE FROM lang WHERE ch_id = {ctx.guild.id}",
commit=True),
use_database(f"INSERT INTO lang VALUES({ctx.guild.id}, 'OwO')",
commit=True),
reload_lang()
]).start()
await ctx.channel.send('Language set to OwO!')
else:
await ctx.channel.send(get_string(ctx, 'no_ling'))
async def google(event):
inp = event.pattern_match.group(1)
if not inp:
return await event.edit("`Give something to search..`")
x = await eor(event, get_string("com_2"))
gs = GoogleSearch()
try:
res = await gs.async_search(f"{inp}", cache=False)
except GoglError as e:
return await eor(event, str(e))
out = ""
try:
for i in range(len(res["links"])):
text = res["titles"][i]
url = res["links"][i]
des = res["descriptions"][i]
out += f" 👉🏻 [{text}]({url})\n`{des}`\n\n"
except TypeError:
return await eod(event, f"`Can't find anything about {inp}`")
omk = f"**Google Search Query:**\n`{inp}`\n\n**Results:**\n{out}"
opn = []
for bkl in range(0, len(omk), 4095):
opn.append(omk[bkl:bkl + 4095])
for bc in opn:
await event.respond(bc, link_preview=False)
await x.delete()
opn.clear()
async def clean(ctx, arg):
await check_admin(ctx)
def check_member(ctx, arg):
return ctx.author == arg
try:
# Se si vuole cancellare oltre 5000 messaggi no
if int(arg) > 5000:
if ctx.message.author.id != int(creator_id):
await ctx.channel.send(get_string(ctx, 'canc_errore'))
return
except:
try:
# Se e' un membro cancella messaggi suoi
converter = commands.MemberConverter()
member = await converter.convert(ctx, arg)
await ctx.channel.purge(
check=lambda ctx: check_member(ctx, member))
except errors.MemberNotFound:
# Altrimenti cancella il numero indicato
await ctx.channel.purge(limit=int(arg))
m = await ctx.channel.send(
f'{get_string(ctx, "costo")} {ra.randint(10, 200)}$')
await m.add_reaction('🧹')
await asyncio.sleep(4)
await m.delete()
def start(update: Update, context: CallbackContext):
user_data = context.user_data
if "lang" not in user_data:
user_data["lang"] = database.get_language_player(update.effective_user.id)
if context.args:
return
update.effective_message.reply_text(get_string(user_data["lang"], "greeting_private"))
def setFooterData(self, _document):
# footer
fs = FooterStyle()
headerFooterProp = HeaderFooterProperties(minheight="0cm", marginleft="0cm", marginright="0cm", margintop="0.499cm")
fs.addElement(headerFooterProp)
self._pl.addElement(fs)
f = Footer()
self._mp.addElement(f)
# styles in 'footer'
sf = Style(name="Footer", family="paragraph", attributes={'class':"extra"})
text = TextProperties(color=curesecOrange, fontfamily=curesecFont, fontsize="9pt")
sf.addElement(text)
_document.styles.addElement(sf)
# copyright
pCopyright = P(stylename=sf, text=get_string(12, self._language))
f.addElement(pCopyright)
# page number/count styles
ps = Style(name="MP5", family="paragraph", parentstylename=sf)
_document.styles.addElement(ps)
pageStyle = ParagraphProperties(textalign="right")
ps.addElement(pageStyle)
pPage = P(stylename=ps)
f.addElement(pPage)
# linebreak
lb = LineBreak()
pPage.addElement(lb)
# 'Seite'
wordingPage = Span(text=get_string(8, self._language) + " ")
pPage.addElement(wordingPage)
# current page
currentPage = PageNumber(selectpage="current")
pPage.addElement(currentPage)
# slash
slash = Span(text="/")
pPage.addElement(slash)
# page count
pageCount = PageCount()
pPage.addElement(pageCount)
def handle_ilikethisbot(message):
if str(message.chat.id) in languages_db.keys():
bot.send_message(message.chat.id,
strings.get_string(languages_db[str(message.chat.id)],
'rate'),
parse_mode='Markdown')
else:
handle_start(message, True)
def addTitle(self, _document):
# title of document
pTitle = P(stylename='deckblatt.title',
text=get_string(15, self._language))
_document.text.addElement(pTitle)
# projectName
pProjekt = P(stylename='deckblatt.projekt')
_document.text.addElement(pProjekt)
getUfProjekt = UserFieldGet(name=self._ufProjekt)
pProjekt.addElement(getUfProjekt)
# version
pVersion = P(stylename='deckblatt.projekt')
_document.text.addElement(pVersion)
sVersion = Span(text=get_string(9, self._language) + ": ")
pVersion.addElement(sVersion)
getUfVersion = UserFieldGet(name=self._ufVersion)
pVersion.addElement(getUfVersion)
# empty line
self.addLines(_document, 1)
# clientName
pClient = P(stylename='deckblatt.title')
_document.text.addElement(pClient)
getUfClientName = UserFieldGet(name=self._ufClientName)
pClient.addElement(getUfClientName)
# zeitraum
pRange = P(stylename='deckblatt.projekt')
_document.text.addElement(pRange)
getUfStart = UserFieldGet(name=self._ufDatumStart)
pRange.addElement(getUfStart)
sSeperator = Span(text="-")
pRange.addElement(sSeperator)
getUfEnd = UserFieldGet(name=self._ufDatumEnd)
pRange.addElement(getUfEnd)
# datum
pDatum = P(stylename='deckblatt.projekt')
_document.text.addElement(pDatum)
sDatum = Span(text=get_string(10, self._language) + ": ")
pDatum.addElement(sDatum)
getUfDatum = UserFieldGet(name=self._ufDatum)
pDatum.addElement(getUfDatum)
def greeting(update: Update, context: CallbackContext):
new_chat_members = update.effective_message.new_chat_members
if new_chat_members:
if context.bot.id not in [user.id for user in new_chat_members]:
return
lang = database.get_language_chat(update.effective_chat.id)
context.chat_data["lang"] = lang
update.effective_message.reply_text(get_string(lang, "greeting"))
def addTitle(self, _document):
# title of document
pTitle = P(stylename='deckblatt.title',
text=get_string(15, self._language))
_document.text.addElement(pTitle)
# projectName
pProjekt = P(stylename='deckblatt.projekt')
_document.text.addElement(pProjekt)
getUfProjekt = UserFieldGet(name=self._ufProjekt)
pProjekt.addElement(getUfProjekt)
# version
pVersion = P(stylename='deckblatt.projekt')
_document.text.addElement(pVersion)
sVersion = Span(text=get_string(9, self._language) + ": ")
pVersion.addElement(sVersion)
getUfVersion = UserFieldGet(name=self._ufVersion)
pVersion.addElement(getUfVersion)
# empty line
self.addLines(_document, 1)
# clientName
pClient = P(stylename='deckblatt.title')
_document.text.addElement(pClient)
getUfClientName = UserFieldGet(name=self._ufClientName)
pClient.addElement(getUfClientName)
# zeitraum
pRange = P(stylename='deckblatt.projekt')
_document.text.addElement(pRange)
getUfStart = UserFieldGet(name=self._ufDatumStart)
pRange.addElement(getUfStart)
sSeperator = Span(text="-")
pRange.addElement(sSeperator)
getUfEnd = UserFieldGet(name=self._ufDatumEnd)
pRange.addElement(getUfEnd)
# datum
pDatum = P(stylename='deckblatt.projekt')
_document.text.addElement(pDatum)
sDatum = Span(text=get_string(10, self._language)+ ": ")
pDatum.addElement(sDatum)
getUfDatum = UserFieldGet(name=self._ufDatum)
pDatum.addElement(getUfDatum)
async def morracinese(self, ctx):
em = discord.Embed(title='morra cinese',
description='Sfida il bot a morra cinese!',
color=ctx.message.author.color)
em.add_field(name=get_string(ctx, 'sintassi'),
value='$morracinese [scelta]')
em.add_field(name='alias', value='mc')
await ctx.send(embed=em)
async def insulta(self, ctx):
em = discord.Embed(title='Insulta',
description='Insulta una persona',
color=ctx.message.author.color)
em.add_field(name=get_string(ctx, 'sintassi'),
value='$insulta <persona>')
em.add_field(name='alias', value='$i')
await ctx.send(embed=em)
def inline(call):
if call.data == "entry":
array = newparser.get_word_of_the_day()
bot.send_message(call.message.chat.id,
newparser.search(
array[0],
strings.get_string(
languages_db[str(call.message.chat.id)],
'wrong')),
parse_mode='Markdown')
else:
chat_id = call.message.chat.id
languages_db[str(chat_id)] = call.data
bot.send_message(
chat_id,
strings.get_string(languages_db[str(call.message.chat.id)],
'saved'))
def addAuftragsnehmer(self, _document):
_level = 1
# header
header = H(outlinelevel=_level,
stylename='header.1',
text=get_string(13, self._language))
_document.text.addElement(header)
# clientAddress
pNehmer = P(stylename="vertragspartner.kunde")
_document.text.addElement(pNehmer)
getUfNehmer = UserFieldGet(name=self._ufAuthorAddress)
pNehmer.addElement(getUfNehmer)
def addTableOfContent(self, _document):
# create table of content main node
tableOfContent = TableOfContent(protected="true",
name=get_string(14, self._language))
_document.text.addElement(tableOfContent)
# source of table of content
tocSource = TableOfContentSource(outlinelevel=str(outlinelevel))
tableOfContent.addElement(tocSource)
# index table template
indexTemplate = IndexTitleTemplate()
tocSource.addElement(indexTemplate)
# content entries for table of content
# entries have to following layout:
# <number><chapter title> .... <page>
for i in range(outlinelevel):
entry = TableOfContentEntryTemplate(outlinelevel=str(i+1), stylename="Entry"+str(i+1))
tocSource.addElement(entry)
chapter = IndexEntryChapter()
entry.addElement(chapter)
linkStart = IndexEntryLinkStart()
entry.addElement(linkStart)
text = IndexEntryText()
entry.addElement(text)
linkEnd = IndexEntryLinkEnd()
entry.addElement(linkEnd)
dots = IndexEntryTabStop(type="right", leaderchar=".")
entry.addElement(dots)
pageNumber = IndexEntryPageNumber()
entry.addElement(pageNumber)
# add index body
indexBody = IndexBody()
tableOfContent.addElement(indexBody)
# add page break
self.addPagebreak(_document)
def setHeaderData(self, _document, projekt, datum, version):
# header
hs = HeaderStyle()
headerFooterProp = HeaderFooterProperties(minheight="0cm",
marginleft="0cm",
marginright="0cm",
marginbottom="0.499cm")
hs.addElement(headerFooterProp)
self._pl.addElement(hs)
h = Header()
self._mp.addElement(h)
# styles in 'header'
sh = Style(name="Header",
family="paragraph",
attributes={'class':"extra"})
text = TextProperties(color=curesecOrange,
fontfamily=curesecFont,
fontsize="9pt")
sh.addElement(text)
_document.styles.addElement(sh)
# add user fields
userfieldDecls = UserFieldDecls()
h.addElement(userfieldDecls)
userfieldProjekt = UserFieldDecl(valuetype="string",
stringvalue=projekt,
name=self._ufProjekt)
userfieldDecls.addElement(userfieldProjekt)
userfieldDatum = UserFieldDecl(valuetype="string",
stringvalue=datum,
name=self._ufDatum)
userfieldDecls.addElement(userfieldDatum)
userfieldVersion = UserFieldDecl(valuetype="string",
stringvalue=version,
name=self._ufVersion)
userfieldDecls.addElement(userfieldVersion)
# Paragaph settings in header
mp1 = Style(name="MP1", family="paragraph", parentstylename=sh)
paragraph = ParagraphProperties(marginleft="0cm",
marginright="0cm",
lineheight="100%",
textalign="start",
justifysingleword="false",
textindent="0cm",
autotextindent="false",
pagenumber="auto",
backgroundcolor="transparent",
shadow="none",
numberlines="false",
linenumber="0")
bi = BackgroundImage()
paragraph.addElement(bi)
mp1.addElement(paragraph)
text = TextProperties(color=curesecOrange,
fontfamily=curesecFont,
fontsize="9pt")
mp1.addElement(text)
_document.automaticstyles.addElement(mp1)
# header: projekt
_sep = ": "
pProjekt = P(stylename=mp1)
h.addElement(pProjekt)
sProjekt = Span(text=get_string(11, self._language) + _sep)
pProjekt.addElement(sProjekt)
sUserfieldProjekt = Span()
pProjekt.addElement(sUserfieldProjekt)
getUserfieldProjekt = UserFieldGet(name=self._ufProjekt)
sUserfieldProjekt.addElement(getUserfieldProjekt)
# header: datum
pDatum = P(stylename=mp1)
h.addElement(pDatum)
sDatum = Span(text=get_string(10, self._language) + _sep)
pDatum.addElement(sDatum)
sUserfieldDatum = Span()
pDatum.addElement(sUserfieldDatum)
getUserfieldDatum = UserFieldGet(name=self._ufDatum)
sUserfieldDatum.addElement(getUserfieldDatum)
# header: version
pVersion = P(stylename=mp1)
h.addElement(pVersion)
sVersion = Span(text=get_string(9, self._language) + _sep)
pVersion.addElement(sVersion)
sUserfieldVersion = Span()
pVersion.addElement(sUserfieldVersion)
getUserfieldVersion = UserFieldGet(name=self._ufVersion)
sUserfieldVersion.addElement(getUserfieldVersion)
# empty 1
pEmpty = P(stylename="MP4")
h.addElement(pEmpty)
# empty 2
pEmpty = P(stylename="MP4")
h.addElement(pEmpty)
# curesec logo style in header
ps = Style(name="Mfr1", family="graphic")
_document.styles.addElement(ps)
graphic = GraphicProperties(horizontalpos="right",
horizontalrel="paragraph",
mirror="none",
clip="rect(0cm, 0cm, 0cm, 0cm)",
luminance="0%",
contrast="0%",
red="0%",
green="0%",
blue="0%",
gamma="100%",
colorinversion="false",
imageopacity="100%",
colormode="standard")
ps.addElement(graphic)
# curesc logo in header
photoframe = Frame(stylename=ps,
width="4.902cm",
height="1.457cm",
x="12.167cm",
y="0.058cm",
anchortype="paragraph")
pProjekt.addElement(photoframe)
href = _document.addPicture(picture)
photoframe.addElement(Image(href=href,
type="simple",
show="embed",
actuate="onLoad"))
