コード例 #1
0
ファイル: main.py プロジェクト: edrijver/sps
 def get(self, domain_identifier, task_identifier):
     task = api.get_task(domain_identifier, task_identifier)
     if not task:
         self.error(404)
         return
     session = Session(writer='cookie',
                       wsgiref_headers=self.response.headers)
     user = api.get_user()
     domain = api.get_domain(domain_identifier)
     subtasks = api.get_all_subtasks(domain_identifier, task)
     parent_task = task.parent_task
     parent_identifier = parent_task.identifier() if parent_task else ""
     parent_title = parent_task.title() if parent_task else ""
     template_values = {
         'domain_name': domain.name,
         'domain_identifier': domain_identifier,
         'user_name': user.name,
         'user_identifier': user.identifier(),
         'messages': get_and_delete_messages(session),
         'task_title' : task.title(),
         'task_description': task.description_body(),
         'task_assignee': assignee_description(task),
         'task_identifier': task.identifier(),
         'task_can_assign_to_self': api.can_assign_to_self(task, user),
         'subtasks': _task_template_values(subtasks, user),
         'parent_identifier': parent_identifier,
         'parent_title': parent_title,
         }
     path = os.path.join(os.path.dirname(__file__),
                         'templates/taskdetail.html')
     self.response.out.write(template.render(path, template_values))
コード例 #2
0
ファイル: app.py プロジェクト: Robinjtu/CommonClarity
def login_user():
    user_to_login = json.loads(request.data)
    email = user_to_login.get("email")
    password = user_to_login.get("password")
    user_id = api.get_user(email, password)
    session['user'] = user_id
    return "Success"
コード例 #3
0
ファイル: workers.py プロジェクト: troberti/sps
 def txn():
     task = api.get_task(domain_identifier, task_identifier)
     if not task:
         logging.error("Task '%s/%s' does not exist", domain_identifier, task_identifier)
         return
     index = TaskIndex.get_by_key_name(task_identifier, parent=task)
     if not index:
         index = TaskIndex(parent=task, key_name=task_identifier)
     # Get all subtasks. The ancestor queries are strongly
     # consistent, so when propagating upwards through the
     # hierarchy the changes are reflected.
     subtasks = list(Task.all().ancestor(domain_key).filter("parent_task =", task.key()))
     if not subtasks:  # atomic task
         task.derived_completed = task.completed
         task.derived_size = 1
         task.derived_atomic_task_count = 1
         task.derived_has_open_tasks = task.open()
         assignee_identifier = task.assignee_identifier()
         if assignee_identifier:
             index.assignees = [assignee_identifier]
             if not DEV_SERVER:
                 # Uses a multi entity group transaction to get the name
                 # of the assignee. This is cached in the record for
                 # quick descriptions.
                 assignee = api.get_user(assignee_identifier)
                 name = assignee.name if assignee else "<Missing>"
             else:
                 name = "temp"
             task.derived_assignees[task.assignee_identifier()] = {
                 "id": task.assignee_identifier(),
                 "name": name,
                 "completed": int(task.is_completed()),
                 "all": 1,
             }
     else:  # composite task
         task.derived_completed = all(t.is_completed() for t in subtasks)
         task.derived_size = 1 + sum(t.derived_size for t in subtasks)
         task.derived_atomic_task_count = sum(t.atomic_task_count() for t in subtasks)
         task.derived_has_open_tasks = any(t.has_open_tasks() for t in subtasks)
         # Compute derived assignees, and sum the total of all
         # their assigned and completed subtasks.
         assignees = {}
         for subtask in subtasks:
             subtask_assignees = subtask.derived_assignees
             for id, record in subtask_assignees.iteritems():
                 if not id in assignees:
                     assignees[id] = {"id": id, "name": record["name"], "completed": 0, "all": 0}
                 assignees[id]["completed"] += record["completed"]
                 assignees[id]["all"] += record["all"]
         task.derived_assignees = assignees
         index.assignees = list(assignees.iterkeys())
     task.put()
     index.completed = task.is_completed()
     index.has_open_tasks = task.has_open_tasks()
     index.atomic = task.atomic()
     index.put()
     # Propagate further upwards
     if task.parent_task_identifier():
         UpdateTaskCompletion.enqueue(domain_identifier, task.parent_task_identifier(), transactional=True)
コード例 #4
0
ファイル: app.py プロジェクト: annieweng/twitter-app
def login_user():
    user_to_login = json.loads(request.data)
    logging.info(" called api/in with user")
    email = user_to_login.get("email")
    password = user_to_login.get("password")

    user_id = api.get_user(email, password)
    session["user"] = user_id
    login = True
    print login
    return "Success"
コード例 #5
0
ファイル: main.py プロジェクト: edrijver/sps
 def post(self):
     try:
         domain_id = self.request.get('domain')
         title = self.request.get('title')
     except (TypeError, ValueError):
         self.error(403)
         return
     user = api.get_user()
     domain = api.create_domain(domain_id, title, user)
     if not domain:
         self.response.out.write("Could not create domain")
         return
     self.response.out.write("Created domain '%s'" % domain.key().name())
コード例 #6
0
ファイル: main.py プロジェクト: edrijver/sps
 def get(self):
     user = api.get_user()
     domains = api.get_all_domains_for_user(user)
     session = Session(writer='cookie',
                       wsgiref_headers=self.response.headers)
     template_values = {
         'username' : user.name,
         'domains' : [{ 'identifier': domain.identifier(),
                        'name': domain.name }
                      for domain in domains],
         'messages': get_and_delete_messages(session),
         }
     path = os.path.join(os.path.dirname(__file__),
                     'templates/landing.html')
     self.response.out.write(template.render(path, template_values))
コード例 #7
0
ファイル: main.py プロジェクト: edrijver/sps
 def post(self):
     try:
         domain_id = self.request.get('domain')
         title = self.request.get('title')
     except (TypeError, ValueError):
         self.error(403)
         return
     user = api.get_user()
     domain = api.create_domain(domain_id, title, user)
     if not domain:
         self.response.out.write("Could not create domain")
         return
     session = Session(writer='cookie',
                       wsgiref_headers=self.response.headers)
     add_message(session, "Created domain '%s'" % domain.key().name())
     self.redirect('/d/%s/' % domain.key().name())
コード例 #8
0
ファイル: responder.py プロジェクト: cjhenck/outline-bots
def mail_responder(event, _):
    """
    Main entry point to handle the feedback form
    :param event: information about the email
    :return: True when successful, False otherwise
    """
    logger.info('%s: Request received:%s', __name__,
                str(event['Records'][0]['eventSource']))

    try:
        (source_email,
         recipient) = parse_ses_notification(event['Records'][0]['ses'])
    except Exception:
        logger.error('Error parsing received Email')
        return False

    LANG = CONFIG['LANG']

    logger.debug('Source Email {} recipient {}'.format(source_email,
                                                       recipient))

    if recipient == CONFIG['TEST_EMAIL']:
        feedback.send_email(CONFIG['REPLY_EMAIL'], source_email,
                            TEMPLATES['EMAIL_SUBJECT'], 'a', 'a', '', None,
                            CONFIG['FEEDBACK_EMAIL'])
        return True

    elif recipient == CONFIG['TEST_EMAIL_NEW']:
        email_key(source_email, 'https://example.com')
        return True

    elif recipient == CONFIG['REPLY_EMAIL']:
        logger.info('Response to no-reply ignored')
        return True

    elif recipient == CONFIG['DELETE_USER_EMAIL']:
        try:
            deleted = api.delete_user(user_id=source_email)
        except Exception:
            email(source_email, 'try_again.j2')
            return False
        if deleted:
            email(source_email, 'unsubscribed.j2')
            return False

    elif recipient == CONFIG['GET_EMAIL']:
        try:
            user_exist = api.get_user(source_email)
        except Exception:
            logger.error('API error when checking {}'.format(source_email))
            email(source_email, 'try_again.j2')
            return False

        if not user_exist:
            try:
                api.create_user(source_email, 'EM')
            except Exception:
                logger.error('API error when Creating {}'.format(source_email))
                email(source_email, 'try_again.j2')
                return False

        try:
            new_key = api.get_new_key(user_id=source_email)
        except Exception:
            logger.error(
                'API error when getting key fo {}'.format(source_email))
            email(source_email, 'try_again.j2')
            return False

        if not new_key:
            email(source_email, 'no_key.j2')
            return False

        awsurl = ((CONFIG['OUTLINE_AWS_URL']).format(
            urllib.parse.quote(new_key)))

        email_key(source_email, awsurl)

    return True
コード例 #9
0
def account(user_id):
    user = get_user(user_id)
    orders = get_user_orders(user_id)
    return render_template('account.html', user=user, orders=orders)
コード例 #10
0
def bot_handler(event, _):
    """
    Main entry point to handle the bot

    param event: information about the chat
    :param _: information about the telegram message (unused)
    """
    logger.info("%s:%s Request received:%s", __name__, str(time.time()),
                str(event))

    try:
        default_language = event["lang"]
        logger.info("Language is %s", event["lang"])
    except KeyError:
        default_language = "fa"
        logger.info("Language is not defined!")

    try:
        token = event['token']
    except KeyError:
        logger.error("Token is not defined!")
        return None

    try:
        tmsg = TelegramMessage(event, default_language)
        logger.info("TMSG object: {}".format(tmsg))
    except Exception as exc:
        logger.error('Error in Telegram Message parsing {} {}'.format(
            event, str(exc)))
        return None

    preferred_lang = dynamodb.get_user_lang(table=CONFIG["DYNAMO_TABLE"],
                                            chat_id=tmsg.chat_id)
    if (preferred_lang is None
            or preferred_lang not in CONFIG['SUPPORTED_LANGUAGES']):
        preferred_lang = default_language
    current_language = CONFIG['SUPPORTED_LANGUAGES'].index(preferred_lang)
    logger.info('User language is {}'.format(preferred_lang))

    change_lang(preferred_lang)
    tmsg.lang = preferred_lang

    if tmsg.body == globalvars.lang.text('MENU_BACK_HOME'):
        telegram.send_keyboard(token, tmsg.chat_id,
                               globalvars.lang.text('MSG_HOME_ELSE'),
                               globalvars.HOME_KEYBOARD)
        save_chat_status(tmsg.chat_id, STATUSES['HOME'])
        return

    if tmsg.command == CONFIG['TELEGRAM_START_COMMAND'] and len(
            tmsg.command_arg) > 0:
        tmsg.command = ""
        tmsg.body = base64.urlsafe_b64decode(tmsg.command_arg)

    # Check for commands (starts with /)
    if tmsg.command == CONFIG["TELEGRAM_START_COMMAND"]:
        dynamodb.create_chat_status(CONFIG['DYNAMO_TABLE'], tmsg.chat_id,
                                    STATUSES['START'])
        telegram.send_message(
            token, tmsg.chat_id,
            globalvars.lang.text("MSG_INITIAL_SCREEN").format(
                CONFIG['VERSION']))
        keyboard = make_language_keyboard()
        telegram.send_keyboard(token, tmsg.chat_id,
                               globalvars.lang.text('MSG_SELECT_LANGUAGE'),
                               keyboard)
        save_chat_status(tmsg.chat_id, STATUSES['SET_LANGUAGE'])
        return None
    elif tmsg.command == CONFIG['TELEGRAM_ADMIN_COMMAND']:
        chat_status = int(
            dynamodb.get_chat_status(table=CONFIG["DYNAMO_TABLE"],
                                     chat_id=tmsg.chat_id))
        if not admin_menu(token, tmsg, chat_status):
            telegram.send_keyboard(token, tmsg.chat_id,
                                   globalvars.lang.text('MSG_HOME'),
                                   globalvars.HOME_KEYBOARD)
        return None

    # non-command texts
    elif tmsg.command == '':  # This is a message not started with /
        chat_status = int(
            dynamodb.get_chat_status(table=CONFIG["DYNAMO_TABLE"],
                                     chat_id=tmsg.chat_id))

        if chat_status >= STATUSES['ADMIN_SECTION_HOME']:
            if not admin_menu(token, tmsg, chat_status):
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME'),
                                       globalvars.HOME_KEYBOARD)
            return None

        elif chat_status == STATUSES['SET_LANGUAGE']:
            if (tmsg.body is None or tmsg.body
                    not in globalvars.lang.text('SUPPORTED_LANGUAGES')):
                message = globalvars.lang.text('MSG_LANGUAGE_CHANGE_ERROR')
            else:
                new_lang = CONFIG['SUPPORTED_LANGUAGES'][globalvars.lang.text(
                    'SUPPORTED_LANGUAGES').index(tmsg.body)]
                dynamodb.save_user_lang(table=CONFIG["DYNAMO_TABLE"],
                                        chat_id=tmsg.chat_id,
                                        language=new_lang)
                change_lang(new_lang)
                message = globalvars.lang.text('MSG_LANGUAGE_CHANGED').format(
                    tmsg.body)
            telegram.send_message(token, tmsg.chat_id, message)

            try:
                user_exist = api.get_user(tmsg.user_uid)
            except Exception:
                telegram.send_message(token, tmsg.chat_id,
                                      globalvars.lang.text('MSG_ERROR'))
                return None

            if not user_exist:
                choices, a, b = get_choice(table=CONFIG["DYNAMO_TABLE"],
                                           chat_id=tmsg.chat_id)
                if choices:
                    keyboard = telegram.make_keyboard(choices, 2, '')
                    telegram.send_keyboard(
                        token, tmsg.chat_id, "{}\n{} + {}:".format(
                            globalvars.lang.text("MSG_ASK_CAPTCHA"), a, b),
                        keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['FIRST_CAPTCHA'])
            else:
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['HOME'])
            return None

        elif chat_status == STATUSES['FIRST_CAPTCHA']:
            check = check_captcha(table=CONFIG["DYNAMO_TABLE"],
                                  chat_id=tmsg.chat_id,
                                  sum=int(tmsg.body))
            if check:
                tos = get_tos_link()
                pp = get_pp_link()
                if tos is not None:
                    telegram.send_message(token, tmsg.chat_id, tos)
                if pp is not None:
                    telegram.send_message(token, tmsg.chat_id, pp)
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text("MSG_OPT_IN"),
                                       globalvars.OPT_IN_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['OPT_IN'])
            else:
                telegram.send_message(
                    token, tmsg.chat_id,
                    globalvars.lang.text('MSG_WRONG_CAPTCHA'))
                choices, a, b = get_choice(table=CONFIG["DYNAMO_TABLE"],
                                           chat_id=tmsg.chat_id)
                if choices:
                    keyboard = telegram.make_keyboard(choices, 2, '')
                    telegram.send_keyboard(
                        token, tmsg.chat_id, "{}\n{} + {}:".format(
                            globalvars.lang.text("MSG_ASK_CAPTCHA"), a, b),
                        keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['FIRST_CAPTCHA'])
            return None

        elif chat_status == STATUSES['OPT_IN']:
            if tmsg.body == globalvars.lang.text(
                    'MENU_PRIVACY_POLICY_CONFIRM'):
                try:
                    api.create_user(user_id=tmsg.user_uid)
                except Exception:
                    telegram.send_message(token, tmsg.chat_id,
                                          globalvars.lang.text('MSG_ERROR'))
                    return None
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME'),
                                       globalvars.HOME_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['HOME'])
            else:
                telegram.send_keyboard(
                    token, tmsg.chat_id,
                    globalvars.lang.text('MSG_PRIVACY_POLICY_DECLINE'),
                    globalvars.OPT_IN_DECLINED_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['OPT_IN_DECLINED'])
            return None

        elif chat_status == STATUSES['OPT_IN_DECLINED']:
            if tmsg.body == globalvars.lang.text('MENU_BACK_PRIVACY_POLICY'):
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text("MSG_OPT_IN"),
                                       globalvars.OPT_IN_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['OPT_IN'])
            elif tmsg.body == globalvars.lang.text(
                    'MENU_HOME_CHANGE_LANGUAGE'):
                keyboard = make_language_keyboard()
                telegram.send_keyboard(
                    token, tmsg.chat_id,
                    globalvars.lang.text('MSG_SELECT_LANGUAGE'), keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['SET_LANGUAGE'])
            return None

        elif chat_status == STATUSES['HOME']:
            if tmsg.body == globalvars.lang.text('MENU_HOME_EXISTING_KEY'):
                try:
                    user_exist = api.get_user(tmsg.user_uid)
                except Exception:
                    telegram.send_message(token, tmsg.chat_id,
                                          globalvars.lang.text('MSG_ERROR'))
                    return None

                if not user_exist:
                    telegram.send_message(
                        token,
                        tmsg.chat_id,
                        globalvars.lang.text('MSG_NO_ACCOUNT'),
                        parse='MARKDOWN')
                    telegram.send_message(token, tmsg.chat_id, '/start')
                    return None
                elif not user_exist['outline_key']:
                    telegram.send_message(
                        token, tmsg.chat_id,
                        globalvars.lang.text('MSG_NO_EXISTING_KEY'))
                else:
                    awsurl = (CONFIG['OUTLINE_AWS_URL'].format(
                        urllib.parse.quote(user_exist['outline_key'])))
                    telegram.send_message(
                        token,
                        tmsg.chat_id,
                        globalvars.lang.text('MSG_EXISTING_KEY_A').format(
                            awsurl),
                        parse='MARKDOWN')
                    telegram.send_message(
                        token,
                        tmsg.chat_id,
                        globalvars.lang.text('MSG_EXISTING_KEY_B'),
                        parse='MARKDOWN')
                    telegram.send_message(token, tmsg.chat_id,
                                          user_exist['outline_key'])

                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['HOME'])
                return None
            elif tmsg.body == globalvars.lang.text('MENU_CHECK_STATUS'):
                blocked = False
                banned = False
                try:
                    user_info = api.get_outline_user(tmsg.user_uid)
                    vpnuser = api.get_user(tmsg.user_uid)
                except Exception:
                    telegram.send_message(token, tmsg.chat_id,
                                          globalvars.lang.text('MSG_ERROR'))
                    return None
                banned = vpnuser['banned']
                telegram.send_message(
                    token,
                    tmsg.chat_id,
                    globalvars.lang.text('MSG_ACCOUNT_INFO_BANNED') \
                        if banned else globalvars.lang.text('MSG_ACCOUNT_INFO_OK')
                )
                if not banned:
                    if user_info is not None:
                        try:
                            serverinfo = api.get_outline_server_info(
                                user_info['server'])

                        except Exception:
                            telegram.send_message(
                                token, tmsg.chat_id,
                                globalvars.lang.text('MSG_ERROR'))
                            return None

                    if serverinfo is not None:
                        blocked = serverinfo['is_blocked']
                    telegram.send_message(
                        token,
                        tmsg.chat_id,
                        globalvars.lang.text('MSG_SERVER_INFO_BLOCKED') \
                            if blocked else globalvars.lang.text('MSG_SERVER_INFO_OK')
                    )
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                return None
            elif tmsg.body == globalvars.lang.text('MENU_HOME_NEW_KEY'):
                try:
                    user_exist = api.get_user(tmsg.user_uid)
                except Exception:
                    telegram.send_message(token, tmsg.chat_id,
                                          globalvars.lang.text('MSG_ERROR'))
                    return None

                if not user_exist:
                    logger.info("New user: {}".format(tmsg.user_uid))
                    telegram.send_message(
                        token,
                        tmsg.chat_id,
                        globalvars.lang.text('MSG_NO_ACCOUNT'),
                        parse='MARKDOWN')
                    telegram.send_message(token, tmsg.chat_id, '/start')
                    return None
                elif not user_exist['outline_key']:
                    create_new_key(tmsg, token)
                    telegram.send_keyboard(
                        token, tmsg.chat_id,
                        globalvars.lang.text('MSG_HOME_ELSE'),
                        globalvars.HOME_KEYBOARD)
                    save_chat_status(tmsg.chat_id, STATUSES['HOME'])
                    return None

                issues_dict = api.get_issues(tmsg.lang)
                issues = list(issues_dict.values())
                keyboard = telegram.make_keyboard(issues, 2, '')
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text("MSG_ASK_ISSUE"),
                                       keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['ASK_ISSUE'])
                return None

            elif tmsg.body == globalvars.lang.text('MENU_HOME_FAQ'):
                telegram.send_message(token, tmsg.chat_id,
                                      globalvars.lang.text('MSG_FAQ_URL'))
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                return None

            elif tmsg.body == globalvars.lang.text('MENU_HOME_INSTRUCTION'):
                photo_name = ""
                with open(photo_name, 'rb') as photofile:
                    telegram.send_photo(token, tmsg.chat_id, photofile.read(),
                                        "instructions")
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                return None

            elif tmsg.body == globalvars.lang.text(
                    'MENU_HOME_CHANGE_LANGUAGE'):
                keyboard = make_language_keyboard()
                telegram.send_keyboard(
                    token, tmsg.chat_id,
                    globalvars.lang.text('MSG_SELECT_LANGUAGE'), keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['SET_LANGUAGE'])
                return None

            elif tmsg.body == globalvars.lang.text('MENU_HOME_PRIVACY_POLICY'):
                telegram.send_message(token, tmsg.chat_id, get_pp_link())
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                return None

            elif tmsg.body == globalvars.lang.text('MENU_HOME_SUPPORT'):
                telegram.send_message(token, tmsg.chat_id,
                                      globalvars.lang.text("MSG_SUPPORT_BOT"))
                telegram.send_message(token, tmsg.chat_id,
                                      CONFIG["SUPPORT_BOT"])
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                return None

            elif tmsg.body == globalvars.lang.text('MENU_HOME_DELETE_ACCOUNT'):
                keyboard = telegram.make_keyboard(
                    globalvars.lang.text('MENU_DELETE_REASONS'), 2,
                    globalvars.lang.text('MENU_BACK_HOME'))
                telegram.send_keyboard(
                    token, tmsg.chat_id,
                    globalvars.lang.text("MSG_ASK_DELETE_REASONS"), keyboard)
                save_chat_status(tmsg.chat_id,
                                 STATUSES['DELETE_ACCOUNT_REASON'])
                return None

        elif chat_status == STATUSES['ASK_ISSUE']:
            issues_dict = api.get_issues(tmsg.lang)
            issue_ids = [
                key for (key, value) in issues_dict.items()
                if value == tmsg.body
            ]
            if not issue_ids:
                telegram.send_message(
                    token, tmsg.chat_id,
                    globalvars.lang.text("MSG_UNSUPPORTED_COMMAND"))
            else:
                create_new_key(tmsg, token, issue_ids[0])

            telegram.send_keyboard(token, tmsg.chat_id,
                                   globalvars.lang.text('MSG_HOME_ELSE'),
                                   globalvars.HOME_KEYBOARD)
            save_chat_status(tmsg.chat_id, STATUSES['HOME'])
            return None

        elif chat_status == STATUSES['DELETE_ACCOUNT_REASON']:
            if tmsg.body in globalvars.lang.text('MENU_DELETE_REASONS'):
                reason_id = globalvars.lang.text('MENU_DELETE_REASONS').index(
                    tmsg.body)
                logger.debug(
                    'user {} wants to delete her account because {}'.format(
                        tmsg.user_uid, tmsg.body))
                try:
                    deleted = api.delete_user(user_id=tmsg.user_uid)
                except Exception:
                    telegram.send_keyboard(token, tmsg.chat_id,
                                           globalvars.lang.text('MSG_ERROR'),
                                           globalvars.HOME_KEYBOARD)
                    return None
                if deleted:
                    telegram.send_keyboard(
                        token, tmsg.chat_id,
                        globalvars.lang.text("MSG_DELETED_ACCOUNT"),
                        globalvars.BACK_TO_HOME_KEYBOARD)
                    save_chat_status(tmsg.chat_id,
                                     STATUSES['DELETE_ACCOUNT_CONFIRM'])
                return None

        else:  # unsupported message from user
            telegram.send_message(
                token, tmsg.chat_id,
                globalvars.lang.text("MSG_UNSUPPORTED_COMMAND"))

            try:
                user_exist = api.get_user(tmsg.user_uid)
            except Exception:
                telegram.send_message(token, tmsg.chat_id,
                                      globalvars.lang.text('MSG_ERROR'))
                return None
            if not user_exist:  # start from First step
                keyboard = make_language_keyboard()
                telegram.send_keyboard(
                    token, tmsg.chat_id,
                    globalvars.lang.text('MSG_SELECT_LANGUAGE'), keyboard)
                save_chat_status(tmsg.chat_id, STATUSES['SET_LANGUAGE'])
                return None
            else:
                telegram.send_keyboard(token, tmsg.chat_id,
                                       globalvars.lang.text('MSG_HOME_ELSE'),
                                       globalvars.HOME_KEYBOARD)
                save_chat_status(tmsg.chat_id, STATUSES['HOME'])
            return None
コード例 #11
0
def get_user(username):
    # For testing
    return jsonify(api.get_user(username)._user_data)
コード例 #12
0
 def test_get_bio(self):
     user = api.get_user('jawkneelin')
     self.assertIsNotNone(user.get_bio())
コード例 #13
0
def user(username):
    return api.get_user(username)
コード例 #14
0
 def openprofile(self):
     profileroot = Toplevel()
     rantapp = profileview.profileview(profileroot,api.get_user(self.rant["rant"]["user_id"]))
     profileview.mainloop()
コード例 #15
0
ファイル: workers.py プロジェクト: wadevries/sps
 def txn():
     task = api.get_task(domain_identifier, task_identifier)
     if not task:
         logging.error("Task '%s/%s' does not exist", domain_identifier,
                       task_identifier)
         return
     index = TaskIndex.get_by_key_name(task_identifier, parent=task)
     if not index:
         index = TaskIndex(parent=task, key_name=task_identifier)
     # Get all subtasks. The ancestor queries are strongly
     # consistent, so when propagating upwards through the
     # hierarchy the changes are reflected.
     subtasks = list(Task.all().ancestor(domain_key).filter(
         'parent_task =', task.key()))
     if not subtasks:  # atomic task
         task.derived_completed = task.completed
         task.derived_size = 1
         task.derived_atomic_task_count = 1
         task.derived_has_open_tasks = task.open()
         assignee_identifier = task.assignee_identifier()
         if assignee_identifier:
             index.assignees = [assignee_identifier]
             if not DEV_SERVER:
                 # Uses a multi entity group transaction to get the name
                 # of the assignee. This is cached in the record for
                 # quick descriptions.
                 assignee = api.get_user(assignee_identifier)
                 name = assignee.name if assignee else '<Missing>'
             else:
                 name = 'temp'
             task.derived_assignees[task.assignee_identifier()] = {
                 'id': task.assignee_identifier(),
                 'name': name,
                 'completed': int(task.is_completed()),
                 'all': 1
             }
     else:  # composite task
         task.derived_completed = all(t.is_completed()
                                      for t in subtasks)
         task.derived_size = 1 + sum(t.derived_size for t in subtasks)
         task.derived_atomic_task_count = sum(t.atomic_task_count()
                                              for t in subtasks)
         task.derived_has_open_tasks = any(t.has_open_tasks()
                                           for t in subtasks)
         # Compute derived assignees, and sum the total of all
         # their assigned and completed subtasks.
         assignees = {}
         for subtask in subtasks:
             subtask_assignees = subtask.derived_assignees
             for id, record in subtask_assignees.iteritems():
                 if not id in assignees:
                     assignees[id] = {
                         'id': id,
                         'name': record['name'],
                         'completed': 0,
                         'all': 0
                     }
                 assignees[id]['completed'] += record['completed']
                 assignees[id]['all'] += record['all']
         task.derived_assignees = assignees
         index.assignees = list(assignees.iterkeys())
     task.put()
     index.completed = task.is_completed()
     index.has_open_tasks = task.has_open_tasks()
     index.atomic = task.atomic()
     index.put()
     # Propagate further upwards
     if task.parent_task_identifier():
         UpdateTaskCompletion.enqueue(domain_identifier,
                                      task.parent_task_identifier(),
                                      transactional=True)
コード例 #16
0
 def test_get_num_followers(self):
     user = api.get_user('jawkneelin')
     self.assertIsNotNone(user.get_num_followers())
コード例 #17
0
 def testGetUser(self):
     email = "*****@*****.**"
     password = "******"
     self.assertEqual(api.get_user(email, password), 84)
コード例 #18
0
 def testGetUserFail(self):
     email = "*****@*****.**"
     password = "******"
     self.assertEqual(api.get_user(email, password), "User does not exist.")
コード例 #19
0
ファイル: test.py プロジェクト: ViRb3/devpost-api
import api
import json
import sys
import scrapers.shared as shared

test_userdata_file = 'test-userdata.json'
test_projectdata_file = 'test-projectdata.json'

userdata = api.get_user('vala')
projectdata = api.get_project('cat-house')

def compare_data(filename, data):
    with open(filename) as file:
        testdata = json.load(file)
        a, b = json.dumps(testdata, sort_keys=True), json.dumps(data, sort_keys=True)
        if a != b:
            print(a)
            print(b)
            return False
    return True

def dump_data():
    test_userdata = json.dumps(userdata, indent=4, sort_keys=True)
    test_projectdata = json.dumps(projectdata, indent=4, sort_keys=True)
    with open(test_userdata_file, 'w') as file:
        file.write(test_userdata)
    with open(test_projectdata_file, 'w') as file:
        file.write(test_projectdata)
    sys.exit(0)

# dump_data()
コード例 #20
0
async def recommend_map(ch, username):
    if '(' in username:
        username = username[:username.index('(')].strip()

    api.refresh_token()

    counter = 0
    user = None
    while counter < 3:
        try:
            user = api.get_user(username)
            break
        except:
            counter += 1

    if not user:
        await send_error_message(ch, f'User **{username}** not found.')
        return

    scores = None
    while counter < 3:
        try:
            scores = api.get_scores(user['id'], limit=50)
            break
        except:
            counter += 1

    if not scores:
        await send_error_message(
            ch,
            f'Error fetching scores for user **{username}**. Please try again later.'
        )
        return

    counter = 0
    score_index = 0
    sim = None
    while counter < 5:
        score_index = random.randrange(min(25, len(scores)))
        sim = similarity_srs.get_similar(scores[score_index]['beatmap']['id'],
                                         100, scores[score_index]['mods'])
        if sim:
            break

        counter += 1

    if not sim:
        await send_error_message(
            ch,
            f'Error finding map recommendations for user **{username}**. Please try again later.'
        )
        return

    score_ids = set(score['beatmap']['id'] for score in scores)

    farm_maps = []
    for i in range(len(sim)):
        map_id = file_to_id(sim[i][0])
        if not map_id or int(map_id) in score_ids:
            continue
        if map_freq.get(map_id, 0) >= 150:  # frequency threshold
            farm_maps.append(i)

    if not farm_maps:
        index = 0
    else:
        index = farm_maps[random.randrange(0, min(len(farm_maps), 50))]

    color = discord.Color.from_rgb(100, 255, 100)
    modstr = ' +' + ''.join(
        scores[score_index]['mods']) if scores[score_index]['mods'] else ''
    description = f'**{sim[index][0]}**{modstr}\n{file_to_link(sim[index][0])}'
    embed = discord.Embed(description=description, color=color)
    embed.set_footer(text=f'Recommended map for {user["username"]}')
    await ch.send(embed=embed)
コード例 #21
0
ファイル: table.py プロジェクト: jvanz/jade_swagger_poc
	def refresh_data(self):
		self.data = get_user()
		self.total_pages = len(self.data) / Table.rows_per_page
		self.page = 0
コード例 #22
0
async def start_quiz(ch, au, params):
    if ch.id in active_quizzes:
        return

    active_quizzes[ch.id] = {}
    q = active_quizzes[ch.id]

    q['first'] = 'first' in params
    q['diff'] = 'diff' in params

    pool = []
    difficulties = []
    if q['diff']:
        easy, medium, hard, impossible, iceberg = easy_diffs, medium_diffs, hard_diffs, impossible_diffs, iceberg_diffs
    else:
        easy, medium, hard, impossible, iceberg = easy_sets, medium_sets, hard_sets, impossible_sets, iceberg_sets

    if 'topplays' in params and not q['diff']:
        usernames = None

        i = params.index('topplays')
        if i + 8 < len(params):
            bracket = params[i + 8]
            brackets = {'(': ')', '[': ']', '{': '}'}
            if bracket in brackets:
                usernames = params[i + 9:]
                if brackets[bracket] not in usernames:
                    active_quizzes.pop(ch.id)
                    return
                usernames = usernames[:usernames.index(brackets[bracket]
                                                       )].split(',')
                for i in range(len(usernames)):
                    usernames[i] = usernames[i].strip()

        api.refresh_token()

        if not usernames:
            username = au.display_name
            if '(' in username:
                username = username[:username.index('(')].strip()
            usernames = [username]

        users = []
        for username in usernames:
            try:
                user = api.get_user(username)
                users.append(user)
            except:
                await send_error_message(ch, f'User **{username}** not found.')
                active_quizzes.pop(ch.id)
                return

        for i in range(len(users)):
            user = users[i]
            try:
                scores = api.get_scores(user['id'], limit=50,
                                        offset=0) + api.get_scores(
                                            user['id'], limit=50, offset=50)
            except:
                await send_error_message(
                    ch,
                    f'Error fetching scores for user **{usernames[i]}**. Please try again later.'
                )
                active_quizzes.pop(ch.id)
                return

            score_ids = list(
                set(score['beatmap']['beatmapset_id'] for score in scores))

            pool.extend(score_ids)

        difficulties.append('Top plays')
    else:
        if 'easy' in params:
            pool.extend(easy)
            difficulties.append('Easy')
        if 'medium' in params:
            pool.extend(medium)
            difficulties.append('Medium')
        if 'hard' in params:
            pool.extend(hard)
            difficulties.append('Hard')
        if 'impossible' in params:
            pool.extend(impossible)
            difficulties.append('Impossible')
        if 'iceberg' in params:
            pool.extend(iceberg)
            difficulties.append('Iceberg')

    if not pool:
        pool = easy
        difficulties = ['Easy']

    mapset_ids = []
    while len(mapset_ids) < 10:
        selected = pool[random.randrange(len(pool))]
        if selected not in mapset_ids:
            mapset_ids.append(selected)

    api.refresh_token()
    mapset_infos = []
    i = 0
    while i < len(mapset_ids):
        try:
            if q['diff']:
                mapset_infos.append(api.get_beatmap(mapset_ids[i]))
            else:
                mapset_infos.append(api.get_beatmapset(mapset_ids[i]))

            i += 1
        except:
            continue

    answers = []
    images = []
    for mi in mapset_infos:
        name = mi['beatmapset']['title'] if q['diff'] else mi['title']
        namesplit = name.split(' ')
        for i in range(1, len(namesplit)):
            if any(namesplit[i].startswith(c) for c in '~([-<') \
                    or any(alphanumeric(namesplit[i].lower()) == s for s in ['ft', 'feat', 'featuring']) \
                    or any(namesplit[i].lower().startswith(s) for s in ['ft.', 'feat.', 'featuring.']) \
                    or 'tv' in namesplit[i].lower():
                name = ''.join(namesplit[:i])
                break
            if any(c in namesplit[i] for c in '~([<'):
                for c in '~([<':
                    if c in namesplit[i]:
                        namesplit[i] = namesplit[i][:namesplit[i].index(c)]
                name = ''.join(namesplit[:i + 1])
                break
        answers.append(alphanumeric(name.lower()))

        images.append(
            f'**[{mi["version"]}]**' if q['diff'] else mi['covers']['cover'])

    q['answers'] = answers
    q['scores'] = {}

    guess_time = 10

    if q['diff']:
        await ch.send(
            'Welcome to the osu! beatmap quiz! You will be given a series of difficulty names; try to type '
            'the title of the beatmap as quickly as possible.\n\n'
            f"Current settings: {'+'.join(difficulties)}, 10 songs, {guess_time}s guess time, {'first-guess' if q['first'] else 'time-based'} scoring\n\n"
            'First difficulty name will appear in 5 seconds!')
    else:
        await ch.send(
            'Welcome to the osu! beatmap quiz! You will be given a series of beatmap backgrounds; try to type '
            'the title of the beatmap as quickly as possible.\n\n'
            f"Current settings: {'+'.join(difficulties)}, 10 songs, {guess_time}s guess time, {'first-guess' if q['first'] else 'time-based'} scoring\n\n"
            'First background will appear in 5 seconds!')

    await asyncio.sleep(5)

    if ch.id not in active_quizzes:
        return

    for i in range(len(answers)):
        q['index'] = i
        q['window'] = (time.time(), time.time() + guess_time)
        q['curr_scores'] = {}

        await ch.send(images[i])

        if q['first']:
            for _ in range(guess_time):
                if q['curr_scores']:
                    break
                await asyncio.sleep(1)
        else:
            await asyncio.sleep(guess_time)

        if ch.id not in active_quizzes:
            return

        output = f"The answer was: {mapset_infos[i]['beatmapset']['title'] if q['diff'] else mapset_infos[i]['title']}\n"
        if q['curr_scores']:
            output += '\n' + '\n'.join(
                f"{au.display_name}: {q['curr_scores'][au]}"
                for au in q['curr_scores']) + '\n'
        if i < len(answers) - 1:
            output += '\nNext question in 5 seconds.\n'
        output += '-' * 20
        await ch.send(output)

        for au in q['curr_scores']:
            if au not in q['scores']:
                q['scores'][au] = 0
            q['scores'][au] += q['curr_scores'][au]

        if i < len(answers) - 1:
            await asyncio.sleep(5)

        if ch.id not in active_quizzes:
            return

    scores = list(q['scores'].items())
    scores.sort(key=lambda s: -s[1])
    output = 'Final standings:\n'
    icons = {0: ':first_place:', 1: ':second_place:', 2: ':third_place:'}
    output += '\n'.join(
        f"{icons.get(i, '')}{scores[i][0].display_name}: {scores[i][1]}"
        for i in range(len(scores)))
    await ch.send(output)

    active_quizzes.pop(ch.id)
コード例 #23
0
ファイル: endpoints.py プロジェクト: jbkoh/genie-brickified
def get_current_user():
    user_email = request.args['user_email']
    access_token = session['google_token']
    jwt_token = get_token(access_token)
    user = get_user(user_email, jwt_token)
    return json_response({'value': user})
コード例 #24
0
    def put(self):
        uuid = self.request.get('group_uuid')
        name = self.request.get('name')
        admin_ids = self.request.get_all('admin_uuid')
        member_ids = self.request.get_all('member_uuid')
        public = self.request.get('public')

        if not uuid:
            api.write_error(self.response, 400, 'Missing required parameter, group_uuid')
            return

        user = api.get_user(self.request)
        if not user:
            api.write_error(self.response, 403, 'Unknown or missing user')
            return

        group = Group.query(Group.uuid == uuid).get()
        if not group:
            api.write_error(self.response, 404, 'Unknown or missing group')
            return

        if not user.key in group.admins:
            api.write_error(self.response, 403, 'User not allowed to update group')
            return

        if name:
            group.name = name
        if 'public' in self.request.params and not public == '':
            group.public = public.lower() in ("yes", "true", "t", "1", "on")

        for admin_id in admin_ids:
            remove_user = False
            if admin_id and admin_id[0] == '-':
                remove_user = True
                admin_id = admin_id[1:]
            admin = User.query(User.uuid == admin_id).get()
            if admin:
                if remove_user and admin.key in group.admins:
                    if len(group.admins) > 1:
                        group.admins.remove(admin.key)
                    else:
                        api.write_error(self.response, 403, 'Cannot remove last admin')
                        return
                elif not admin.key in group.admins:
                    group.admins.append(admin.key)
            else:
                logging.warn('Unknown user %s' % (admin_id))

        for member_id in member_ids:
            remove_user = False
            if member_id and member_id[0] == '-':
                remove_user = True
                member_id = member_id[1:]
            member = User.query(User.uuid == member_id).get()
            if member:
                if remove_user and member.key in group.members:
                    group.members.remove(member.key)
                elif not member.key in group.members:
                    group.members.append(member.key)
            else:
                logging.warn('Unknown user %s' % (member_id))
        group.put()
        if group.public:
            api.search.update_public_index(group)
        else:
            api.search.update_private_index(group, user.uuid)

        api.write_message(self.response, 'Updated group',
                          extra={'groups' : [ get_group_json(group) ]})