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
