async def _add(ctx, user: User, reason: str, days: int=None): user.blacklisted_on.add( ctx.db_guild, properties={'UTC': time.time(), 'reason': utils.escaped(reason), 'days': days, 'guild': ctx.guild.id} ) user.push() if days is not None: for_days = ctx.translate("for [days] days").format(days) else: for_days = "" conf_msg = ctx.translate("user blacklisted").format(for_days) member: discord.Member = ctx.guild.get_member(user.id) try: await member.send(ctx.translate("[user] just blacklisted you").format(str(ctx.author), str(ctx.guild), reason)) except discord.Forbidden: warning_note = ctx.translate("but user doesn't allow direct messages") conf_msg = f"{conf_msg}\n{warning_note}" await ctx.send(conf_msg) await ctx.db_guild.log(ctx.translate("[user] blacklisted [user] [reason]").format( str(ctx.author), str(member), utils.escaped(reason) ))
def signup_user(request): request_dic = json.loads(request.body) fullname = '' user_email = request_dic["email"] response_from_hunter_api = mock_hunter_api_for_checking_email_verifier( user_email) if response_from_hunter_api != "deliverable": return HttpResponse(bool(False)) response_from_enrichment_api = mock_enrichment_api_for_getting_additional_data( user_email) if response_from_enrichment_api['person'] is not None: fullname = response_from_enrichment_api['person']['name']['fullname'] create_user = User(user_id=request_dic["user_id"], email=request_dic["email"], password=request_dic["password"], name=fullname) create_user.save() encoded_jwt = jwt.encode({ 'user_id': request_dic["user_id"] }, 'secret', algorithm='HS256').decode("UTF-8") return HttpResponse(encoded_jwt)
def update_user_in_database(self, user_id): user = self.session.query(User).filter(User.id == user_id).first() time = datetime.now() if user is None: user = User(id=user_id, date_started=time, date_last_used=time) else: user.update_time(time) self.session.add(user) self.session.commit()
def _create_user(telegram_user): username = telegram_user.username if username == '': username = '******' user = User(id=telegram_user.id, first_name=telegram_user.first_name, username=username) new_user_action(user) user.save() return user
def create_admin(): admin_user = User.query.filter_by(username="******").one_or_none() if not admin_user: admin_user = User(username="******") db.session.add(admin_user) admin_user.password_hash = generate_password_hash( app.config['ADMIN_PASSWORD']) admin_user.admin = True admin_user.disabled = False db.session.commit()
async def create_user(**kwargs): user = User(**kwargs) user_dict = asdict(user) data = {"fields": user_dict} get_user = await AirtableAPI.get_user(user.tg_id) if ( get_user["records"] and get_user["records"][0]["fields"]["tg_id"] == user.tg_id ): logger.info("User already exists") return try: async with aiohttp.ClientSession() as cs: async with cs.post( AirtableConfig.USERS, json=data, headers=AirtableConfig.HEADERS ) as r: resp = await r.json() except (aiohttp.ClientResponseError, aiohttp.ClientConnectorError): logger.exception("Problem when sending request") raise else: if "error" in resp: logger.error("Error response from adding participant to airtable") raise AirtableRequestError(resp["error"]["message"]) else: logger.info("Succesfully added user in Airtable") return resp
def check_exist_transaction(self, session): user = User.get_user_by_telegram_user_id(session, self.telegram_user_id) consumption = session.query(Consumption).filter( Consumption.user_id == user.id, Consumption.id == self.transaction_id).first() return True if consumption else False
def add_user_in_db(update, session): user = update.message.from_user username = getattr(user, 'username', sqlalchemy.null()) session.add(User(telegram_username=username, telegram_user_id=user.id, first_name=user.first_name, last_name=user.last_name, date_registration=datetime.datetime.now(), last_activity=datetime.datetime.now())) session.commit()
async def _list(ctx, user: User = None): """ Shows a list of tickets on the server/of a specific user. """ guild = ctx.db_guild tickets_emb = discord.Embed(title=ctx.translate("active support tickets"), color=Defaults.COLOR) tickets_emb.set_footer(text=ctx.translate( "to see all properties of a ticket use the ticket show command")) if user is not None: tickets_emb.description = ctx.translate( "all open tickets of the given user") tickets_emb.set_author( name=f"{user.discord.name}#{user.discord.discriminator}", icon_url=user.discord.avatar_url) ticket_list = user.get_tickets() else: tickets_emb.description = ctx.translate( "all open tickets of this guild") tickets_emb.set_author(name=guild.discord.name, icon_url=guild.discord.icon_url) ticket_list = guild.get_tickets() ticket_list = list( filter(lambda t: t.state_enum != enums.State.CLOSED, ticket_list)) ticket_list.reverse() if not ctx.may_fully_access: def scope_check(t): c = t.scope_enum == enums.Scope.LOCAL or ( t.scope_enum == enums.Scope.CHANNEL and ctx.channel == t.channel) return c ticket_list = list(filter(scope_check, ticket_list)) # check scope permissions if len(ticket_list) == 0: await ctx.send(ctx.translate("there are no active support tickets")) return None sub_lists = EmbedPaginator.generate_sub_lists(ticket_list) pages = [] for sub_list in sub_lists: page = deepcopy(tickets_emb) # copy by value not reference for ticket in sub_list: page.add_field(name=f"#{ticket.id} || {ticket.title}", value=ticket.description or "|", inline=False) pages.append(page) paginator = EmbedPaginator(ctx, pages) await paginator.run()
def post_signup(): username = request.json.get("username", None) password = request.json.get("password", None) confirm_password = request.json.get("confirm_password", None) if not username or len(username) > 64: return "Username must be at most 64 characters", 400 if not password or len(password) < 8: return "Password must be at least 8 characters", 400 if password != confirm_password: return "Passwords do not match", 400 user = User.query.filter_by(username=username).one_or_none() if user: return "User with that name already exists", 400 user = User(username=username, password_hash=generate_password_hash(password)) db.session.add(user) db.session.commit() access_token = create_access_token(identity=user.id) response = jsonify(id=user.id, username=user.username, admin=user.admin, disabled=user.disabled) set_access_cookies(response, access_token) response.headers.add("Access-Control-Allow-Origin", "*") return response
async def on_member_join(member): db_guild = Guild.from_discord_guild(member.guild) db_user = User.from_discord_user(member) db_guild.joined_users.add(db_user, properties={'UTC': time.time()}) db_guild.push()
async def _delete(ctx, t: Ticket): """ This is to delete a ticket. """ utc = time.time() conf = Confirmation(ctx) await conf.confirm(ctx.translate("you are attempting to delete ticket [ticket]").format(t.id)) if conf.confirmed: author = User.from_discord_user(ctx.author) t.state_enum = enums.State.DELETED t.deleted_by.add(author, properties={'UTC': utc}) t.push() for resp in t.get_responses(): resp.deleted = True resp.deleted_by.add(author, properties={'UTC': utc}) resp.push() await conf.display(ctx.translate("ticket deleted")) if t.scope_enum == enums.Scope.CHANNEL: channel = t.channel if channel is not None: await channel.delete(reason=ctx.translate("ticket has been deleted")) await t.guild.log(ctx.translate("[user] deleted ticket [ticket]").format(ctx.author, t.id)) else: await conf.display((ctx.translate("canceled")))
def cmd_inv(self, _, update): user = User.from_tg(update.message.from_user) if user.in_battle is not None: update.message.reply_text('user is in a battle', quote=True) return items = user.items.select()[:] if not items: update.message.reply_text('no items', quote=True) return res = '' keyboard = [] for item in items: res += '%s %s x%s\n' % (item.item.icon, item.item.name, item.count if item.count >= 0 else '\u221e') #if can_use: # keyboard.append([ # InlineKeyboardButton( # '%s %s' % (icon, name), # callback_data='iuse %s' % id_ # ) # ]) if not keyboard: keyboard = None else: keyboard = InlineKeyboardMarkup(keyboard) update.message.reply_text(res, quote=True, reply_markup=keyboard)
def create_user(self, user_id, dm_channel_id): """Creates a new user with given Discord id and DM channel id. Does nothing if user already exists.""" user = self._user_id_to_user.get(user_id) if user is None: user = User(user_id, dm_channel_id) self.users.append(user) self._user_id_to_user[user_id] = user
async def _create(ctx, t: Ticket, content: str): """ This is to create new responses/to answer tickets. """ if t.scope_enum == enums.Scope.CHANNEL and ctx.channel != t.channel and not ctx.may_fully_access( t): await ctx.send(ctx.translate("the related ticket is channel scope")) return None elif t.scope_enum == enums.Scope.PRIVATE and not ctx.may_fully_access(t): await ctx.send(ctx.translate("this is a private ticket")) return None elif t.state_enum == enums.State.CLOSED: await ctx.send(ctx.translate("this ticket is closed")) return None if t.scope_enum == enums.Scope.PRIVATE: try: await ctx.message.delete() except discord.Forbidden: pass utc = time.time() resp = Response() author = User.from_discord_user(ctx.author) resp.created_by.add(author, properties={'UTC': utc}) resp.located_on.add(ctx.db_guild) resp.refers_to.add(t) resp.content = escaped(content) resp.deleted = False resp.updated = utc highest_id = graph.run( "MATCH (r:Response)-[:REFERS_TO]->(t:Ticket {uuid: '%s'}) RETURN max(r.id)" % t.uuid).evaluate() if highest_id is None: highest_id = 0 resp.id = highest_id + 1 resp.uuid = uuid.uuid4().hex graph.create(resp) await ctx.send(ctx.translate("response created").format(resp.full_id)) resp_msg = ctx.translate( "[user] just responded to your ticket [ticket]").format( ctx.author.name, ctx.author.discriminator, t.id) await notify_author(ctx, resp_msg, t, embed=response_embed(ctx, resp)) await resp.guild.log( ctx.translate("[user] created response [response]").format( ctx.author, f"{resp.ticket.id}-{resp.id}"))
def check_exist_transaction(self, session): user = User.get_user_by_telegram_user_id(session, self.telegram_user_id) earning = session.query(Earning).filter( Earning.user_id == user.id, Earning.id == self.transaction_id ).first() return True if earning else False
def make_text_list_categories(session, telegram_user_id): user = User.get_user_by_telegram_user_id(session, telegram_user_id) categories_text = CategoryEarning.get_all_categories_by_text( session=session, user_id=user.id) result = '' for index, text in enumerate(categories_text): result += f'{index+1}. {text}\n' return result
def cb_iuse(self, _, update): user = check_callback_user(update) if user is None: return user = User.from_tg(user) if user.in_battle is not None: return item = update.callback_query.data update.callback_query.message.edit_text('use item "%s"' % item)
def to_main_menu(update, context): user = User.get_user_by_telegram_user_id(session, update.message.from_user.id) limits = session.query(Limit).filter(Limit.user_id == user.id).all() update.message.reply_text(text=text_main_menu(session, limits, datetime.datetime.now()), reply_markup=get_keyboard_main_menu(limits), parse_mode=telegram.ParseMode.HTML) return States.TO_MAIN_MENU
def add_example_user(session): session.add( User(telegram_username=example_user['telegram_username'], telegram_user_id=example_user['telegram_user_id'], first_name=example_user['first_name'], last_name=example_user['last_name'], last_activity=example_user['last_activity'], date_registration=example_user['date_registration'])) session.commit()
def write_stats(msg): if msg.content: db.connect(reuse_if_open=True) db.create_tables([User, Message]) user_q = User.select().where(User.user_id == msg.user['id']) users = [user for user in user_q] if len(users) == 0: is_telegram = True if msg.is_telegram else False user = User.create(user_id=msg.user['id'], is_telegram=is_telegram, username=msg.user['name']) user.save() else: user = users[0] msg = Message.create(user=user, message=msg.content, timestamp=round(datetime.now().timestamp())) msg.save()
def handler(update: Update, context: CallbackContext): with session_scope() as session: user = User.get_user_by_telegram_user_id(session, update.message.from_user.id) text = make_text_today(session, datetime.datetime.now(), user) bot.send_message( chat_id=update.message.from_user.id, text=text, parse_mode=telegram.ParseMode.HTML, )
def to_edit_category(update, context): context.user_data['back_func'] = to_choose_action_edit user = User.get_user_by_telegram_user_id(session, update.message.from_user.id) categories = session.query(CategoryConsumption).filter( CategoryConsumption.user_id == user.id).all() update.message.reply_text( text=text_choose_edit_category(), reply_markup=get_keyboard_category_limit(categories)) return States.TO_EDIT_CATEGORY
def to_add_category(update: Update, context: CallbackContext): context.user_data['back_func'] = to_add_limit user = User.get_user_by_telegram_user_id(session, update.message.from_user.id) categories = CategoryConsumption.get_all_categories(session, user.id) update.message.reply_text( text=text_choose_category(), reply_markup=get_keyboard_category_limit(categories), parse_mode=telegram.ParseMode.HTML) return States.TO_CHOOSE_ADD_CATEGORY_LIMIT
def create_member(dmem): user_sql = q(User).filter_by(id=str(dmem.id)).first() if user_sql: print("Use already exists in database") return None new_user = User(id=str(dmem.id)) session.add(new_user) session.commit() return new_user
def send_message_choose_limit(update, context): user = User.get_user_by_telegram_user_id(session, update.message.from_user.id) limits = session.query(Limit).filter(Limit.user_id == user.id).all() text, ids_limits = make_text_and_dict_limits(session, limits) context.user_data['ids_limits'] = ids_limits update.message.reply_text( text=text, reply_markup=make_keyboard_choose_limits(ids_limits), parse_mode=telegram.ParseMode.HTML)
async def setup_chat(data: dict, user: types.User, chat: Optional[types.Chat] = None): user_id = int(user.id) chat_id = int(chat.id) chat_type = chat.type if chat else "private" session: AsyncSession = data["session"] if not (user := await session.get(User, user_id)): session.add(user := User(id=user_id))
def add_database(telegram_id): """Функция добавляющая пользователя телеграм в базу данных бота. Это нуждо чтобы отслеживать подписки пользователей на бота""" user_info = session.query(User).filter_by(telegram_id=telegram_id).first() if user_info is None: user_info = User(telegram_id=telegram_id, sub_status=False) session.add(user_info) session.commit()
def cb_mmove(self, _, update): user = check_callback_user(update) if user is None: return user = User.from_tg(user) args = update.callback_query.data.split() pid = int(args[0]) if args else None action = args[1] if len(args) > 1 else None res = '' if not pid: return pokemon = user.pokemon.select(lambda p: p.id == pid)[:1] if pokemon: pokemon = pokemon[0] else: return if action is not None: if user.in_battle is not None: return move_id = int(action[1:]) try: if action[0] == '-': pokemon.delete_move(move_id) else: pokemon.add_move(move_id) except ValueError as ex: res = '\n\n%s' % str(ex) moves = pokemon.get_available_moves() used = set(m.move.id for m in pokemon.moves) res = pokemon.info_full + res back = [InlineKeyboardButton('back', callback_data='mon %d' % pid)] keyboard = [ InlineKeyboardButton( '%s%s %s' % ('-' if move.move.id in used else '+', move.move.name, move.move.pp), callback_data='mmove %d %s%d' % (pid, '-' if move.move.id in used else '+', move.move.id)) for move in moves ] keyboard = list(chunks(keyboard, 2)) keyboard.append(back) keyboard = InlineKeyboardMarkup(keyboard) update.callback_query.message.edit_text(res, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard)
def _save_user(self): # Create or get the user that sent the link user, was_created = User.get_or_create( id=self.update.message.from_user.id, defaults={ 'username': self.update.message.from_user.username, 'first_name': self.update.message.from_user.first_name }) if was_created: Logger.log_db_operation(Logger.DBOperation.CREATE, user) return user