Commit Graph

12 Commits

Author SHA1 Message Date
f18cd78ad5 merge branch 'main' into security
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-07 14:22:43 +09:00
86f7c65697 Merge branch 'main' into security
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-07 14:22:04 +09:00
929d2face6 select_target fixsync def select_target(update: Update, context:
Some checks failed
continuous-integration/drone/push Build is failing
ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
        if not query:
	        return ConversationHandler.END
		    await query.answer()

		        data = (query.data or "")
			    async with AsyncSessionLocal() as session:
			            chat_id: str | None = None
				            markup: InlineKeyboardMarkup
					    | None = None
					            selected_title: str
						    | None = None
						            btns = []

							            if
								    data.startswith('channel_'):
								                channel_id
										=
										int(data.split('_',
										1)[1])

										            #
											    ACL:
											    право
											    постинга
											    в
											    канал
											                me
													=
													await
													get_or_create_admin(session,
													update.effective_user.id)
													            allowed
														    =
														    await
														    has_scope_on_channel(session,
														    me.id,
														    channel_id,
														    SCOPE_POST)
														                if
																not
																allowed:
																                await
																		query.edit_message_text("У
																		вас
																		нет
																		права
																		постить
																		в
																		этот
																		канал.")
																		                return
																				ConversationHandler.END

																				            channel
																					    =
																					    (await
																					    session.execute(sa_select(Channel).where(Channel.id
																					    ==
																					    channel_id))).scalar_one_or_none()
																					                if
																							not
																							channel:
																							                await
																									query.edit_message_text("Канал
																									не
																									найден.")
																									                return
																											ConversationHandler.END

																											            chat_id
																												    =
																												    (channel.link
																												    or
																												    "").strip()
																												                selected_title
																														=
																														channel.name

																														            #
																															    Кнопки
																															    канала
																															                btns
																																	=
																																	(await
																																	session.execute(sa_select(Button).where(Button.channel_id
																																	==
																																	channel_id))).scalars().all()
																																	            if
																																		    btns:
																																		                    rows
																																				    =
																																				    [[InlineKeyboardButton(str(b.name),
																																				    url=str(b.url))]
																																				    for
																																				    b
																																				    in
																																				    btns]
																																				                    markup
																																						    =
																																						    InlineKeyboardMarkup(rows)

																																						            elif
																																							    data.startswith('group_'):
																																							                group_id
																																									=
																																									int(data.split('_',
																																									1)[1])

																																									            group
																																										    =
																																										    (await
																																										    session.execute(sa_select(Group).where(Group.id
																																										    ==
																																										    group_id))).scalar_one_or_none()
																																										                if
																																												not
																																												group:
																																												                await
																																														query.edit_message_text("Группа
																																														не
																																														найдена.")
																																														                return
																																																ConversationHandler.END

																																																            chat_id
																																																	    =
																																																	    (group.link
																																																	    or
																																																	    "").strip()
																																																	                selected_title
																																																			=
																																																			group.name

																																																			            #
																																																				    Кнопки
																																																				    группы
																																																				                btns
																																																						=
																																																						(await
																																																						session.execute(sa_select(Button).where(Button.group_id
																																																						==
																																																						group_id))).scalars().all()
																																																						            if
																																																							    btns:
																																																							                    rows
																																																									    =
																																																									    [[InlineKeyboardButton(str(b.name),
																																																									    url=str(b.url))]
																																																									    for
																																																									    b
																																																									    in
																																																									    btns]
																																																									                    markup
																																																											    =
																																																											    InlineKeyboardMarkup(rows)

																																																											        if
																																																												not
																																																												chat_id
																																																												or
																																																												not
																																																												(chat_id.startswith('@')
																																																												or
																																																												chat_id.startswith('-')):
																																																												        await
																																																													query.edit_message_text('Ошибка:
																																																													ссылка
																																																													должна
																																																													быть
																																																													username
																																																													(@channel)
																																																													или
																																																													числовой
																																																													ID
																																																													(-100...)')
																																																													        return
																																																														ConversationHandler.END

																																																														    #
																																																														    DEBUG:
																																																														    сколько
																																																														    кнопок
																																																														    нашли
																																																														    и
																																																														    есть
																																																														    ли
																																																														    markup
																																																														        print(f"[DEBUG]
																																																															send
																																																															->
																																																															chat_id={chat_id}
																																																															title={selected_title!r}
																																																															buttons={len(btns)}
																																																															has_markup={bool(markup)}")

																																																															    #
																																																															    Текст
																																																															    и
																																																															    entities
																																																															    (без
																																																															    parse_mode)
																																																															        ud
																																																																=
																																																																context.user_data
																																																																or
																																																																{}
																																																																    text:
																																																																    str
																																																																    =
																																																																    ud.get("text",
																																																																    "")
																																																																    or
																																																																    ""
																																																																        entities:
																																																																	List[MessageEntity]
																																																																	=
																																																																	ud.get("entities",
																																																																	[])
																																																																	or
																																																																	[]
																																																																	    entities
																																																																	    =
																																																																	    _strip_broken_entities(entities)
																																																																	        entities
																																																																		=
																																																																		_split_custom_emoji_by_utf16(text,
																																																																		entities)

																																																																		    #
																																																																		    Всегда
																																																																		    ручная
																																																																		    отправка
																																																																		    (send_*),
																																																																		    чтобы
																																																																		    гарантированно
																																																																		    приклеить
																																																																		    inline-клавиатуру
																																																																		        try:
																																																																			        sent_msg
																																																																				=
																																																																				None
																																																																				        if
																																																																					"photo"
																																																																					in
																																																																					ud:
																																																																					            sent_msg
																																																																						    =
																																																																						    await
																																																																						    context.bot.send_photo(
																																																																						                    chat_id=chat_id,
																																																																								                    photo=ud["photo"],
																																																																										                    caption=(text
																																																																												    or
																																																																												    None),
																																																																												                    caption_entities=(entities
																																																																														    if
																																																																														    text
																																																																														    else
																																																																														    None),
																																																																														                    reply_markup=markup,
																																																																																                )
																																																																																		        elif
																																																																																			"animation"
																																																																																			in
																																																																																			ud:
																																																																																			            sent_msg
																																																																																				    =
																																																																																				    await
																																																																																				    context.bot.send_animation(
																																																																																				                    chat_id=chat_id,
																																																																																						                    animation=ud["animation"],
																																																																																								                    caption=(text
																																																																																										    or
																																																																																										    None),
																																																																																										                    caption_entities=(entities
																																																																																												    if
																																																																																												    text
																																																																																												    else
																																																																																												    None),
																																																																																												                    reply_markup=markup,
																																																																																														                )
																																																																																																        elif
																																																																																																	"video"
																																																																																																	in
																																																																																																	ud:
																																																																																																	            sent_msg
																																																																																																		    =
																																																																																																		    await
																																																																																																		    context.bot.send_video(
																																																																																																		                    chat_id=chat_id,
																																																																																																				                    video=ud["video"],
																																																																																																						                    caption=(text
																																																																																																								    or
																																																																																																								    None),
																																																																																																								                    caption_entities=(entities
																																																																																																										    if
																																																																																																										    text
																																																																																																										    else
																																																																																																										    None),
																																																																																																										                    reply_markup=markup,
																																																																																																												                )
																																																																																																														        elif
																																																																																																															"document"
																																																																																																															in
																																																																																																															ud:
																																																																																																															            sent_msg
																																																																																																																    =
																																																																																																																    await
																																																																																																																    context.bot.send_document(
																																																																																																																                    chat_id=chat_id,
																																																																																																																		                    document=ud["document"],
																																																																																																																				                    caption=(text
																																																																																																																						    or
																																																																																																																						    None),
																																																																																																																						                    caption_entities=(entities
																																																																																																																								    if
																																																																																																																								    text
																																																																																																																								    else
																																																																																																																								    None),
																																																																																																																								                    reply_markup=markup,
																																																																																																																										                )
																																																																																																																												        elif
																																																																																																																													"audio"
																																																																																																																													in
																																																																																																																													ud:
																																																																																																																													            sent_msg
																																																																																																																														    =
																																																																																																																														    await
																																																																																																																														    context.bot.send_audio(
																																																																																																																														                    chat_id=chat_id,
																																																																																																																																                    audio=ud["audio"],
																																																																																																																																		                    caption=(text
																																																																																																																																				    or
																																																																																																																																				    None),
																																																																																																																																				                    caption_entities=(entities
																																																																																																																																						    if
																																																																																																																																						    text
																																																																																																																																						    else
																																																																																																																																						    None),
																																																																																																																																						                    reply_markup=markup,
																																																																																																																																								                )
																																																																																																																																										        elif
																																																																																																																																											"voice"
																																																																																																																																											in
																																																																																																																																											ud:
																																																																																																																																											            sent_msg
																																																																																																																																												    =
																																																																																																																																												    await
																																																																																																																																												    context.bot.send_voice(
																																																																																																																																												                    chat_id=chat_id,
																																																																																																																																														                    voice=ud["voice"],
																																																																																																																																																                    caption=(text
																																																																																																																																																		    or
																																																																																																																																																		    None),
																																																																																																																																																		                    caption_entities=(entities
																																																																																																																																																				    if
																																																																																																																																																				    text
																																																																																																																																																				    else
																																																																																																																																																				    None),
																																																																																																																																																				                    reply_markup=markup,
																																																																																																																																																						                )
																																																																																																																																																								        elif
																																																																																																																																																									"sticker"
																																																																																																																																																									in
																																																																																																																																																									ud:
																																																																																																																																																									            sent_msg
																																																																																																																																																										    =
																																																																																																																																																										    await
																																																																																																																																																										    context.bot.send_sticker(
																																																																																																																																																										                    chat_id=chat_id,
																																																																																																																																																												                    sticker=ud["sticker"],
																																																																																																																																																														                    reply_markup=markup,
																																																																																																																																																																                )
																																																																																																																																																																		            if
																																																																																																																																																																			    text:
																																																																																																																																																																			                    await
																																																																																																																																																																					    context.bot.send_message(chat_id=chat_id,
																																																																																																																																																																					    text=text,
																																																																																																																																																																					    entities=entities)
																																																																																																																																																																					            else:
																																																																																																																																																																						                sent_msg
																																																																																																																																																																								=
																																																																																																																																																																								await
																																																																																																																																																																								context.bot.send_message(
																																																																																																																																																																								                chat_id=chat_id,
																																																																																																																																																																										                text=text,
																																																																																																																																																																												                entities=entities,
																																																																																																																																																																														                reply_markup=markup,
																																																																																																																																																																																            )

																																																																																																																																																																																	            #
																																																																																																																																																																																		    Страховка:
																																																																																																																																																																																		    если
																																																																																																																																																																																		    вдруг
																																																																																																																																																																																		    Telegram
																																																																																																																																																																																		    проглотил
																																																																																																																																																																																		    клаву
																																																																																																																																																																																		    —
																																																																																																																																																																																		    доклеим
																																																																																																																																																																																		    её
																																																																																																																																																																																		            if
																																																																																																																																																																																			    markup
																																																																																																																																																																																			    and
																																																																																																																																																																																			    getattr(sent_msg,
																																																																																																																																																																																			    "message_id",
																																																																																																																																																																																			    None):
																																																																																																																																																																																			                t
2025-09-06 13:54:24 +09:00
2bcf07f6a9 script update
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 13:38:55 +09:00
297af93fff select_target -> disabled COPY using send_
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 13:18:42 +09:00
a22ba094db inline keyboard fix
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 12:27:17 +09:00
5c81aae29c ACL, channel_charing
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 10:57:10 +09:00
405e663da4 migrations fixes
Some checks failed
continuous-integration/drone/push Build is failing
admin check-in
2025-09-06 08:41:28 +09:00
b987031410 Emoji - compatible fix
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 08:32:41 +09:00
9793648ee3 security, audit, fom features
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-06 05:03:45 +09:00
d17f0f5507 async refactor & docker deploy environment
Some checks failed
continuous-integration/drone/push Build is failing
2025-09-05 12:04:58 +09:00
aca280b64d init commit
Some checks failed
continuous-integration/drone Build is failing
2025-09-04 01:51:59 +09:00