def question_1_handler(update: Update, context: CallbackContext) -> int:
text = messageTextProvider.get_question_1_state_text()
reply_keyboard = [['1', '2'], ['3', 'Больше трех']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
helpers.get_message(update).reply_text(text, reply_markup=keyboard_markup)
return states.QUESTION_1_STATE
def survey_finish_handler(update: Update, context: CallbackContext) -> int:
text = messageTextProvider.get_survey_finish_state_text()
reply_keyboard = [['Да', 'Нет']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
helpers.get_message(update).reply_text(text, reply_markup=keyboard_markup)
context.user_data['state'] = states.SURVEY_FINISH_STATE
return states.SURVEY_FINISH_STATE
def start_state_handler(update: Update, context: CallbackContext) -> int:
# TODO: проверить, проходил ли юзер раньше этот опрос. если проходил то надо предупредить что ответы перезапишутся
text = messageTextProvider.get_start_state_text()
reply_keyboard = [['Начнем']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
helpers.get_message(update).reply_text(text, reply_markup=keyboard_markup)
return states.START_STATE
def part_2_question_1_handler(update: Update, context: CallbackContext) -> int:
context.user_data['part_number'] = 2
keys = [f'question{i+1}' for i in range(7)]
for key in keys:
answerHelper.set_empty_answer(context.user_data, key)
text = '*Для чего* учите новый язык?'
helpers.get_message(update).reply_text(text, parse_mode='Markdown')
return states.PART_2_QUESTION_1_STATE
def part_3_question_1_handler(update: Update, context: CallbackContext) -> int:
context.user_data['part_number'] = 3
keys = [str(i + 1)
for i in range(7)] + ['4_1', '4_2', '4_3', '5_1', '5_2', '5_3']
keys.sort()
keys = [f'question{key}' for key in keys]
for key in keys:
answerHelper.set_empty_answer(context.user_data, key)
text = 'Какие техники/приложения использовали для запоминания новых слов?'
helpers.get_message(update).reply_text(text)
return states.PART_3_QUESTION_1_STATE
def total_finish_handler(update: Update, context: CallbackContext) -> int:
if context.user_data['state'] == states.PLANS_INFO_STATE:
answerHelper.save_answer(update.message, context, 'final1')
else:
answerHelper.set_empty_answer(context.user_data, 'final1')
answerHelper.save_user_answers_to_file(update.effective_user,
context.user_data)
text = 'Теперь точно всё :) Спасибо и до скорых встреч!'
helpers.get_message(update).reply_text(text,
reply_markup=ReplyKeyboardRemove())
return ConversationHandler.END
def part_1_question_1_handler(update: Update, context: CallbackContext) -> int:
context.user_data['part_number'] = 1
keys = [f'question{i+1}' for i in range(4)]
for key in keys:
answerHelper.set_empty_answer(context.user_data, key)
text = 'Вы же как-то ищете перевод/смысл иностранных слов?'
reply_keyboard = [['Да', 'Нет']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
helpers.get_message(update).reply_text(text, reply_markup=keyboard_markup)
context.user_data['state'] = states.PART_1_QUESTION_1_STATE
return states.PART_1_QUESTION_1_STATE
def admin_state_handler(update: Update, context: CallbackContext,
admin_ids) -> int:
user = helpers.get_message(update).from_user
logger.info(f'@{user.username} tried to log in to the admin area')
if user.id not in admin_ids:
return states.START_STATE
text = 'Вы вошли в админку.'
reply_keyboard = [['Получить список проголосовавших'],
['Экспорт результатов в HTML']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
helpers.get_message(update).reply_text(text, reply_markup=keyboard_markup)
return states.ADMIN_STATE
def part_4_question_4_1_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question4')
text = 'Как находили правильный перевод?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_4_1_STATE
def part_4_question_12_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question11')
text = 'Что вас *мотивирует* изучать новый язык?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_12_STATE
def part_3_question_5_2_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question5_1')
text = 'Как думаете, вам поможет знание двух языков в изучении третьего? Если да, то чем?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_3_QUESTION_5_2_STATE
def part_1_question_3_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question2')
text = 'Как убеждаетесь в правильном смысле перевода? Бывает ли так, что уместный перевод не сразу находится?'
message.reply_text(text)
context.user_data['state'] = states.PART_1_QUESTION_3_STATE
return states.PART_1_QUESTION_3_STATE
def part_4_question_10_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question9')
text = 'Как отслеживаете свой *текущий уровень* в изучении нового языка?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_10_STATE
def part_3_question_4_1_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question4')
text = 'Сколько примерно слов сейчас знаете?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_3_QUESTION_4_1_STATE
def admin_export_state_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
user = message.from_user
logger.info(f'@{user.username} exported survey results')
export_dir_path = export.Export().export_to_html(
user.id, should_remove_original_files=False)
export_dir_path = os.path.normpath(export_dir_path)
archive_file_name = os.path.split(export_dir_path)[-1]
zip_file = shutil.make_archive(
archive_file_name,
'zip',
root_dir=export_dir_path,
base_dir='.',
)
reply_keyboard = [['Вернуться в главное меню админки']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
with open(zip_file, 'rb') as f:
message.reply_document(f,
reply_markup=keyboard_markup,
reply_to_message_id=message.message_id)
os.remove(zip_file)
return states.ADMIN_EXPORT_RESULT_STATE
def part_3_question_5_1_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question5')
text = 'Что вас мотивирует, а что останавливает?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_3_QUESTION_5_1_STATE
def part_3_question_4_2_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question4_1')
text = 'Чем пользовались чтобы узнать это число?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_3_QUESTION_4_2_STATE
def part_4_question_11_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question10')
text = 'Отслеживаете текущее количество известных слов? Если да, то как?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_11_STATE
def part_1_question_4_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question1')
text = 'Эх, тогда вопросов больше нет :) Расскажите, на ваш взгляд, как эффективней запоминать слова иностранного язык?'
message.reply_text(text)
context.user_data['state'] = states.PART_1_QUESTION_4_STATE
return states.PART_1_QUESTION_4_STATE
def part_4_question_4_2_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question4_1')
text = 'Что помогает найти правильный смысл слова?'
message.reply_text(text, parse_mode='Markdown')
context.user_data['state'] = states.PART_4_QUESTION_4_2_STATE
return states.PART_4_QUESTION_4_2_STATE
def part_4_question_8_yes_1_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question8')
text = 'Чем полезно проверять перевод нового слова сразу на несколько языков?'
message.reply_text(text, parse_mode='Markdown')
context.user_data['state'] = states.PART_4_QUESTION_8_YES_1_STATE
return states.PART_4_QUESTION_8_YES_1_STATE
def part_4_question_8_no_1_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question8')
text = 'Как узнаете смысл слова? Переводите обычно только на свой родной язык или как-то иначе?'
message.reply_text(text, parse_mode='Markdown')
context.user_data['state'] = states.PART_4_QUESTION_8_NO_1_STATE
return states.PART_4_QUESTION_8_NO_1_STATE
def part_3_question_4_3_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question4_2')
text = 'Продолжаете набирать словарный запас?'
message.reply_text(text, parse_mode='Markdown')
context.user_data['state'] = states.PART_3_QUESTION_4_3_STATE
return states.PART_3_QUESTION_4_3_STATE
def part_3_question_5_3_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question5_2')
text = 'С чего начнёте учить новый язык?'
message.reply_text(text, parse_mode='Markdown')
context.user_data['state'] = states.PART_3_QUESTION_5_3_STATE
return states.PART_3_QUESTION_5_3_STATE
def part_4_question_5_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
if context.user_data['state'] == states.PART_4_QUESTION_4_STATE:
answerHelper.save_answer(message, context, 'question4')
elif context.user_data['state'] == states.PART_4_QUESTION_4_2_STATE:
answerHelper.save_answer(message, context, 'question4_2')
text = 'Какие *методики/приложения* используете чтобы запоминать новые слова?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_5_STATE
def part_3_question_4_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question3')
text = 'Когда-нибудь проверяли сколько вы знаете слов?'
reply_keyboard = [['Да', 'Нет']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
message.reply_text(text, reply_markup=keyboard_markup)
context.user_data['state'] = states.PART_3_QUESTION_4_STATE
return states.PART_3_QUESTION_4_STATE
def part_4_question_8_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question7')
text = 'Проверяете ли значение нового слова переводя на разные известные вам языки?'
reply_keyboard = [['Да', 'Нет']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
message.reply_text(text, reply_markup=keyboard_markup)
context.user_data['state'] = states.PART_4_QUESTION_8_STATE
return states.PART_4_QUESTION_8_STATE
def part_4_question_9_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
if context.user_data['state'] == states.PART_4_QUESTION_8_YES_1_STATE:
answerHelper.save_answer(message, context, 'question8_yes_1')
elif context.user_data['state'] == states.PART_4_QUESTION_8_NO_1_STATE:
answerHelper.save_answer(message, context, 'question8_no_1')
text = 'Что бы хотели улучшить, *сделать более эффективным*, в процессе изучения языка?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_4_QUESTION_9_STATE
def part_3_question_6_handler(update: Update, context: CallbackContext) -> int:
message = helpers.get_message(update)
if context.user_data['state'] == states.PART_3_QUESTION_5_3_STATE:
answerHelper.save_answer(message, context, 'question5_3')
elif context.user_data['state'] == states.PART_3_QUESTION_5_STATE:
answerHelper.save_answer(message, context, 'question5')
text = 'Какой мотивации не хватает чтобы начать изучать новый язык?'
message.reply_text(text, parse_mode='Markdown')
return states.PART_3_QUESTION_6_STATE
def part_3_survey_finish_handler(update: Update,
context: CallbackContext) -> int:
message = helpers.get_message(update)
answerHelper.save_answer(message, context, 'question6')
text = messageTextProvider.get_survey_finish_state_text()
reply_keyboard = [['Да', 'Нет']]
keyboard_markup = ReplyKeyboardMarkup(reply_keyboard,
one_time_keyboard=True)
message.reply_text(text, reply_markup=keyboard_markup)
context.user_data['state'] = states.SURVEY_FINISH_STATE
return states.SURVEY_FINISH_STATE
def wsdl_parse(self, url, cache=False):
"Parse Web Service Description v1.1"
log.debug("wsdl url: %s" % url)
# Try to load a previously parsed wsdl:
force_download = False
if cache:
# make md5 hash of the url for caching...
filename_pkl = "%s.pkl" % hashlib.md5(url).hexdigest()
if isinstance(cache, basestring):
filename_pkl = os.path.join(cache, filename_pkl)
if os.path.exists(filename_pkl):
log.debug("Unpickle file %s" % (filename_pkl,))
f = open(filename_pkl, "r")
pkl = pickle.load(f)
f.close()
# sanity check:
if pkl["version"][:-1] != __version__.split(" ")[0][:-1] or pkl["url"] != url:
import warnings
warnings.warn("version or url mismatch! discarding cached wsdl", RuntimeWarning)
log.debug("Version: %s %s" % (pkl["version"], __version__))
log.debug("URL: %s %s" % (pkl["url"], url))
force_download = True
else:
self.namespace = pkl["namespace"]
self.documentation = pkl["documentation"]
return pkl["services"]
soap_ns = {
"http://schemas.xmlsoap.org/wsdl/soap/": "soap11",
"http://schemas.xmlsoap.org/wsdl/soap12/": "soap12",
}
wsdl_uri = "http://schemas.xmlsoap.org/wsdl/"
xsd_uri = "http://www.w3.org/2001/XMLSchema"
xsi_uri = "http://www.w3.org/2001/XMLSchema-instance"
get_local_name = lambda s: s and str((":" in s) and s.split(":")[1] or s)
get_namespace_prefix = lambda s: s and str((":" in s) and s.split(":")[0] or None)
# always return an unicode object:
REVERSE_TYPE_MAP[u"string"] = unicode
# Open uri and read xml:
xml = fetch(url, self.http, cache, force_download, self.wsdl_basedir)
# Parse WSDL XML:
wsdl = SimpleXMLElement(xml, namespace=wsdl_uri)
# detect soap prefix and uri (xmlns attributes of <definitions>)
xsd_ns = None
soap_uris = {}
for k, v in wsdl[:]:
if v in soap_ns and k.startswith("xmlns:"):
soap_uris[get_local_name(k)] = v
if v == xsd_uri and k.startswith("xmlns:"):
xsd_ns = get_local_name(k)
# Extract useful data:
self.namespace = wsdl["targetNamespace"]
self.documentation = unicode(wsdl("documentation", error=False) or "")
services = {}
bindings = {} # binding_name: binding
operations = {} # operation_name: operation
port_type_bindings = {} # port_type_name: binding
messages = {} # message: element
elements = {} # element: type def
for service in wsdl.service:
service_name = service["name"]
if not service_name:
continue # empty service?
log.debug("Processing service %s" % service_name)
serv = services.setdefault(service_name, {"ports": {}})
serv["documentation"] = service["documentation"] or ""
for port in service.port:
binding_name = get_local_name(port["binding"])
operations[binding_name] = {}
address = port("address", ns=soap_uris.values(), error=False)
location = address and address["location"] or None
soap_uri = address and soap_uris.get(address.get_prefix())
soap_ver = soap_uri and soap_ns.get(soap_uri)
bindings[binding_name] = {
"name": binding_name,
"service_name": service_name,
"location": location,
"soap_uri": soap_uri,
"soap_ver": soap_ver,
}
serv["ports"][port["name"]] = bindings[binding_name]
for binding in wsdl.binding:
binding_name = binding["name"]
soap_binding = binding("binding", ns=soap_uris.values(), error=False)
transport = soap_binding and soap_binding["transport"] or None
port_type_name = get_local_name(binding["type"])
bindings[binding_name].update({"port_type_name": port_type_name, "transport": transport, "operations": {}})
if port_type_name not in port_type_bindings:
port_type_bindings[port_type_name] = []
port_type_bindings[port_type_name].append(bindings[binding_name])
for operation in binding.operation:
op_name = operation["name"]
op = operation("operation", ns=soap_uris.values(), error=False)
action = op and op["soapAction"]
d = operations[binding_name].setdefault(op_name, {})
bindings[binding_name]["operations"][op_name] = d
d.update({"name": op_name})
d["parts"] = {}
# input and/or ouput can be not present!
input = operation("input", error=False)
body = input and input("body", ns=soap_uris.values(), error=False)
d["parts"]["input_body"] = body and body["parts"] or None
output = operation("output", error=False)
body = output and output("body", ns=soap_uris.values(), error=False)
d["parts"]["output_body"] = body and body["parts"] or None
header = input and input("header", ns=soap_uris.values(), error=False)
d["parts"]["input_header"] = header and {"message": header["message"], "part": header["part"]} or None
header = output and output("header", ns=soap_uris.values(), error=False)
d["parts"]["output_header"] = header and {"message": header["message"], "part": header["part"]} or None
if action:
d["action"] = action
# check axis2 namespace at schema types attributes
self.namespace = dict(wsdl.types("schema", ns=xsd_uri)[:]).get("targetNamespace", self.namespace)
imported_schemas = {}
# process current wsdl schema:
for schema in wsdl.types("schema", ns=xsd_uri):
preprocess_schema(
schema,
imported_schemas,
elements,
xsd_uri,
self.__soap_server,
self.http,
cache,
force_download,
self.wsdl_basedir,
)
postprocess_element(elements)
for message in wsdl.message:
log.debug("Processing message %s" % message["name"])
for part in message("part", error=False) or []:
element = {}
element_name = part["element"]
if not element_name:
# some implementations (axis) uses type instead
element_name = part["type"]
type_ns = get_namespace_prefix(element_name)
type_uri = wsdl.get_namespace_uri(type_ns)
if type_uri == xsd_uri:
element_name = get_local_name(element_name)
fn = REVERSE_TYPE_MAP.get(unicode(element_name), None)
element = {part["name"]: fn}
# emulate a true Element (complexType)
messages.setdefault((message["name"], None), {message["name"]: OrderedDict()}).values()[0].update(
element
)
else:
element_name = get_local_name(element_name)
fn = elements.get(make_key(element_name, "element"))
if not fn:
# some axis servers uses complexType for part messages
fn = elements.get(make_key(element_name, "complexType"))
element = {message["name"]: {part["name"]: fn}}
else:
element = {element_name: fn}
messages[(message["name"], part["name"])] = element
for port_type in wsdl.portType:
port_type_name = port_type["name"]
log.debug("Processing port type %s" % port_type_name)
for binding in port_type_bindings[port_type_name]:
for operation in port_type.operation:
op_name = operation["name"]
op = operations[str(binding["name"])][op_name]
op["documentation"] = unicode(operation("documentation", error=False) or "")
if binding["soap_ver"]:
# TODO: separe operation_binding from operation (non SOAP?)
if operation("input", error=False):
input_msg = get_local_name(operation.input["message"])
input_header = op["parts"].get("input_header")
if input_header:
header_msg = get_local_name(input_header.get("message"))
header_part = get_local_name(input_header.get("part"))
# warning: some implementations use a separate message!
header = get_message(messages, header_msg or input_msg, header_part)
else:
header = None # not enought info to search the header message:
op["input"] = get_message(messages, input_msg, op["parts"].get("input_body"))
op["header"] = header
else:
op["input"] = None
op["header"] = None
if operation("output", error=False):
output_msg = get_local_name(operation.output["message"])
op["output"] = get_message(messages, output_msg, op["parts"].get("output_body"))
else:
op["output"] = None
# dump the full service/port/operation map
# log.debug(pprint.pformat(services))
# Save parsed wsdl (cache)
if cache:
f = open(filename_pkl, "wb")
pkl = {
"version": __version__.split(" ")[0],
"url": url,
"namespace": self.namespace,
"documentation": self.documentation,
"services": services,
}
pickle.dump(pkl, f)
f.close()
return services
