def test_insert_bot(self): u = User(first_name='Anabel', last_name='Almaraz') u.set_user_secret('*****@*****.**') bot = Bot(name='botica-test', description='prueba', user=u) bot.set_bot_secret('botica-test') self.assertTrue(bot.user_id == u.id) self.assertTrue(bot.is_active == None)
def handle_client(sock, addr): """Send commands, receive responses and update database for a single bot""" try: b = Bot.query.filter_by(ip=addr[0]).one() except: b = Bot(ip=addr[0]) if not addr[0] in queue.keys(): queue.update({addr[0]:list()}) b.sleep_interval = None b.last_seen_time = datetime.now() if b.os == None and not "get os" in queue[addr[0]]: queue[addr[0]].append("get os") if b.sleep_interval == None and not "get sleep" in queue[addr[0]]: queue[addr[0]].append("get sleep") db.session.add(b) db.session.commit() inp = select([sock], [], [], 1) if inp[0]: action(sock.recv(4096), b) if addr[0] in queue.keys() and len(queue[addr[0]]) != 0: cmd = queue[addr[0]][0] queue[addr[0]].remove(cmd) sock.send(cmd) b.current_command = cmd db.session.add(b) db.session.commit() sock.close()
def initdb(): db.drop_all() db.create_all() bot = Bot("1234") bot.ip = 'asdfas' db.session.add(bot) db.session.commit()
def publish_bot(request): if request.is_ajax(): user_prof = UserProfile.objects.get(user=request.user) new_bot_code = json.loads(request.body)['msg'] if len(new_bot_code.strip('')) == 0: return HttpResponse("Can not publish an empty bot") # Get the last bot, and check delta try: latest_bot = Bot.objects.filter(owner=user_prof).latest('creation_date') if compare_bots(latest_bot.code, new_bot_code): error = "Can not publish this bot, looks like the previous one!" return HttpResponse(error) except ObjectDoesNotExist: # This is the first bot for this user pass bot = Bot() bot.owner = user_prof bot.code = new_bot_code bot.save() user_prof.current_bot = bot user_prof.my_buffer = new_bot_code user_prof.save() return HttpResponse(json.dumps({'success' : True}), mimetype='application/json')
def populate(): q=Channel.gql("WHERE id=:1", 'koan') channel=q.get() code=""" __author__ = 'peter' from application import settings import logging MSG_TYPE_TEXT = u'text' MSG_TYPE_LOCATION = u'location' MSG_TYPE_IMAGE = u'image' def process_text(remark, retort): if remark['content']: retort['content']='Bot Spawned!' retort['msgType']=MSG_TYPE_TEXT retort['funcFlag']=0 return retort def process_location(remark, retort): return retort def process_image(remark, retort): return retort """ bot=Bot(name=u'spawn', code=code, channel=channel.key) bot.put() return 'populated.'
def lookup_entity(query, exact=True): """ Searches for a Bot or User contained in the query """ if exact: try: return Bot.by_username(query, include_disabled=True) except Bot.DoesNotExist: pass try: return Bot.get(chat_id=int(query)) except ValueError: pass except Bot.DoesNotExist: pass try: return User.by_username(query) except User.DoesNotExist: pass try: return User.get(chat_id=query) except User.DoesNotExist: pass return None
def finish(self): # set last update self.channel.last_update = datetime.date.today() self._save_channel() new_bots = Bot.select_new_bots() if not self.silent and len(new_bots) > 0: self.notify_admin("Sending notifications to subscribers...") subscribers = Notifications.select().where(Notifications.enabled == True) notification_count = 0 for sub in subscribers: try: util.send_md_message(self.bot, sub.chat_id, messages.BOTLIST_UPDATE_NOTIFICATION.format( n_bots=len(new_bots), new_bots=Bot.get_new_bots_markdown())) notification_count += 1 sub.last_notification = datetime.date.today() sub.save() except TelegramError: pass self.sent['notifications'] = "Notifications sent to {} users.".format( notification_count) changes_made = len(self.sent) > 1 or len(self.sent['category']) > 0 if changes_made: text = util.success('{}{}'.format('BotList updated successfully:\n\n', mdformat.results_list(self.sent))) else: text = mdformat.none_action("No changes were necessary.") log.info(self.sent) self.bot.formatter.send_or_edit(self.chat_id, text, to_edit=self.message_id)
def post_bot(payload): body = request.get_json() count = Bot.query.count() try: record = Bot(id=body.get('id'), name=body.get('name'), active=body.get('active'), strategy_id=body.get('strategy_id'), timeframe=body.get('timeframe'), param_values=body.get('param_values').split(', ')) record.insert() response = { 'success': True, 'id': record.id, 'name': record.name, 'active': record.active, 'param_values': record.param_values, 'timeframe': record.timeframe, 'strategy_id': record.strategy_id } return jsonify(response), 200 except Exception: abort(400)
def mybots(request): user_prof = UserProfile.objects.get(user=request.user) if request.method == 'POST': form = BotBufferForm(request.POST) if not form.is_valid(): print "ERROR in form!" return new_code = form.cleaned_data['code'] user_prof.code = new_code if 'publish_buffer' in request.POST: bot = Bot() bot.owner = user_prof bot.code = new_code bot.save() validate_bot.delay(bot.id, new_code) user_prof.current_bot = bot user_prof.save() return redirect('/mybots') else: form = BotBufferForm(instance=user_prof) return render(request, "my_bots.html", { 'form': form, 'user_prof': user_prof, 'tab': 'mybots', 'my_bots': reversed(Bot.objects.filter(owner=user_prof)) })
def post(self): """Creates a bot""" error_status = 0 user = users.get_current_user() if not user: self.response.out.write("not registered in google") name = self.request.get('name') password = self.request.get('password') feed = self.request.get('feed') # Verify the account information gae_twitter = GAETwitter(username=name, password=password) verify_result = gae_twitter.verify() if (verify_result != True): error_status = error_status + 1 # Verify the feed URL d = feedparser.parse(feed) if (d.bozo > 0): error_status = error_status + 2 server_error = "" if (error_status == 0): bot = Bot(name=name, password=password, feed=feed) bot.user = user try: bot.put() except Exception, e: error_status |= 4 server_error = str(e)
def common_new(request): port = 6667 if request.POST: name = request.POST.get("name") server = request.POST.get("server") type = int(request.POST.get("type")) channels = request.POST.get("channels") port = request.POST.get("port") nick = name # Validate errors = {} if len(name) > 36 or len(name) < 1: errors["name"] = "Username must be 36 characters or less" # test name for invalid characters if Bot.objects.filter(name=name, server=server): errors["name"] = "Nick already taken on %s" % server if not isinstance(type, int): errors["type"] = "Invalid bot type" #TODO: Regex! if len(server) < 5: errors["server"] = "Invalid server name" #TODO: Better checking if len(channels) < 1: errors["channels"] = "Specify at least one channel" elif len(channels) > 2000: errors["channels"] = "Too many channels specified" if len(port) > 5: errors["port"] = "Invalid port number, 6667 is default" if not port: port = 6667 port = int(port) if not errors: bot = Bot(owner=request.user, name=name, nick=nick, server=server, port=port, type=type, channels=channels, status=0) bot.save() # args = (type, bot.owner_id, name, server, port, channels) args = (server, port, nick, channels) # Create the bot on the daemon bus = dbus.SessionBus() service = bus.get_object('com.excid3.bothost', '/com/excid3/bothost') new_bot = service.get_dbus_method('new_bot', 'com.excid3.bothost') new_bot(type, bot.id, args) #TODO: Display a "successfully created" message at the top of the dashboard return HttpResponseRedirect("/") locals().update(bottypes=BOT_TYPES) t = loader.get_template("common/new.html") c = RequestContext(request, locals()) return HttpResponse(t.render(c))
def delete_bot(bot, update, to_edit: Bot): username = to_edit.username to_edit.disable(Bot.DisabledReason.banned) to_edit.save() bot.formatter.send_or_edit(update.effective_user.id, "Bot has been disabled and banned.", to_edit=util.mid_from_update(update)) Statistic.of(update, 'disable', username, Statistic.IMPORTANT)
def _new_bots_text(): new_bots = Bot.select_new_bots() if len(new_bots) > 0: txt = "Fresh new bots since the last update š:\n\n{}".format( Bot.get_new_bots_markdown()) else: txt = 'No new bots available.' return txt
def create(): data = request.json bot = Bot(name=data['name'], strategy=data['strategy'], notation=data['notation']) db.session.add(bot) db.session.commit() os.system("gnome-terminal -e 'sh scripts/create_bot.sh %r'" % bot.id) return json.dumps(bot.to_dict())
def new(request): if request.method == 'POST': form = BotForm(request.POST) if form.is_valid(): bot = Bot(**form.cleaned_data) bot.save() return HttpResponseRedirect(bot.get_absolute_url()) else: form = BotForm() return render_to_response('bots/new.html', {'form': form}, context_instance=RequestContext(request))
def parse_bad_bots(self): """ Entry point """ # The threshold confidence of the bot. If the bot confidence score is equal or higher than the threshold, # block the bot. bot_confidence_threshold = 7 # Setup properties bot = Bot() bot.source_ip = str( self.event['requestContext']['identity']['sourceIp']) bot.source_ip_type = self.get_ip_type_by_address(bot.source_ip) bot.http_user_agent = str(self.event['headers']['User-Agent']) bot.http_method = str(self.event['httpMethod']) bot.http_body = str(self.event['body']) bot.http_query_string_parameters = str( self.event['queryStringParameters']) if bot.source_ip_type == self.SourceIPType.IPV4: bot.geolocation = self.get_geolocation(bot.source_ip) else: bot.geolocation = None # Do confidence check based on bot properties bot_confidence_score = self.check_bot_confidence(bot) # Was detected as bot? For diagnostics is_bot = False if bot_confidence_score >= bot_confidence_threshold: is_bot = True # Check the source IP type and then update the respective IP set if bot.source_ip_type == self.SourceIPType.IPV4: self.update_bad_bots_ip_set( self.SourceIPType.IPV4, [IPv4Network(bot.source_ip).with_prefixlen]) if bot.source_ip_type == self.SourceIPType.IPV6: self.update_bad_bots_ip_set( self.SourceIPType.IPV6, [IPv6Network(bot.source_ip).with_prefixlen]) bad_bots_output = { "source_ip": bot.source_ip, "source_ip_type": bot.source_ip_type.value, "is_bot": is_bot, "bot_confidence_score": bot_confidence_score } return bad_bots_output
def update_bot_details(self, to_check: BotModel, peer): """ Set basic properties of the bot """ if isinstance(peer, ResolvedPeer): peer = self.resolve_peer(peer.peer.user_id) elif isinstance(peer, InputPeerUser): pass else: peer = self.resolve_peer(peer.id) try: user = self.send(GetUsers([peer]))[0] except: traceback.print_exc() print("this peer does not work for GetUsers:") print(type(peer)) print(peer) return None if hasattr(user, 'bot') and user.bot is True: # Regular bot to_check.official = bool(user.verified) to_check.inlinequeries = bool(user.bot_inline_placeholder) to_check.name = user.first_name to_check.bot_info_version = user.bot_info_version else: # Userbot to_check.userbot = True to_check.name = helpers.format_name(user) # In any case to_check.chat_id = int(user.id) to_check.username = '******' + str(user.username)
def add_bot(self, channel, name): channel = channel.lower() name = name.lower() try: Bot.get(Bot.name == name) except peewee.DoesNotExist: pass # this seems really unpythonic somehow else: raise KeyError('Bot already exists') try: chan_o = Channel.get(Channel.name == channel) except peewee.DoesNotExist: chan_o = Channel.create(name=channel) Bot.create(name=name, channel=chan_o)
def _execute_command(self, command=None, bot_name=None, human=None, status=None): if command in COMMANDS: bot = Bot(self.config['bots'][bot_name]) if command == 'delete': bot.delete_status(status=status) else: api = self._get_api() api.send_direct_message( user_id=human, text="{0} command not found.".format(command))
def test_db(): """ Just a function used for debugging purposes. Ignore me!!! """ bot_ip = [ '10.1.1.2', '10.1.1.3', '10.1.1.4', '10.1.1.5', '10.1.1.6', '10.1.1.7', '10.1.1.8', '10.2.1.2', '10.2.1.3', '10.2.1.4', '10.2.1.5', '10.2.1.6', '10.2.1.7', '10.2.1.8', '10.3.1.2', '10.3.1.3', '10.3.1.4', '10.3.1.5', '10.3.1.6', '10.3.1.7', '10.3.1.8', '10.4.1.2', '10.4.1.3', '10.4.1.4', '10.4.1.5', '10.4.1.6', '10.4.1.7', '10.4.1.8', '10.5.1.2', '10.5.1.3', '10.5.1.4', '10.5.1.5', '10.5.1.6', '10.5.1.7', '10.5.1.8', '10.6.1.2', '10.6.1.3', '10.6.1.4', '10.6.1.5', '10.6.1.6', '10.6.1.7', '10.6.1.8', '10.7.1.2', '10.7.1.3', '10.7.1.4', '10.7.1.5', '10.7.1.6', '10.7.1.7', '10.7.1.8', '10.8.1.2', '10.8.1.3', '10.8.1.4', '10.8.1.5', '10.8.1.6', '10.8.1.7', '10.8.1.8', '10.9.1.2', '10.9.1.3', '10.9.1.4', '10.9.1.5', '10.9.1.6', '10.9.1.7', '10.9.1.8', '10.10.1.2', '10.10.1.3', '10.10.1.4', '10.10.1.5', '10.10.1.6', '10.10.1.7', '10.10.1.8' ] hostname = [ 'annebonny', 'williamkidd', 'calicojack', 'maryread', 'edwardteach', 'captaincrapo', 'canoot', 'nemo', 'gunner', 'laurellabonaire', 'lockelamora', 'hook' ] bot_user = [ 'root', 'whiteteam', 'Administrator', 'duder', 'NT Authority\SYSTEM' ] bot_pid = '5000' counter = 0 idx = 0 for ip in bot_ip: counter += 1 if counter % 8 == 0: idx += 1 bot = Bot(ip, hostname[idx], bot_user[random.randint(0, len(bot_user) - 1)], random.randint(100, 20000)) db.session.add(bot) db.session.commit() bot = Bot('10.1.1.2', 'annebonny', 'root', random.randint(100, 20000)) db.session.add(bot) bot = Bot('10.1.1.2', 'annebonny', 'root', random.randint(100, 20000)) db.session.add(bot) bot = Bot('10.1.1.2', 'annebonny', 'root', random.randint(100, 20000)) db.session.add(bot) db.session.commit()
def random_replay(keyboard, chat, type='chat'): """ when type=chat take create_message_response when type=callback_query take create_callback_query_response """ # select random answer print(keyboard[0]) #options = keyboard answer = random.choice(keyboard[0]) if 'text' in answer: answer = answer['text'] bot = Bot.get(chat['botname']) user = User.get(chat['username']) if type == 'chat': response = create_fake_message(user, bot, chat, answer) elif type == 'callback_query': text, data = answer['text'], answer['callback_data'] response = create_callback_query_response(user, bot, text, data) else: raise ValueError("type must be chat or callback_query") logger.info('random_replay[type=%s] response: %s' % (type, response)) # send random answer to the callback_url print(response) r = requests.post(bot['callback'], json=response) print(r.text)
def ping_bots_job(bot, job): bot_checker: BotChecker = job.context.get('checker') stop_event: threading.Event = job.context.get('stop') loop = bot_checker.event_loop all_bots = BotModel.select(BotModel).where( (BotModel.approved == True) & ((BotModel.disabled_reason == BotModel.DisabledReason.offline) | BotModel.disabled_reason.is_null()) ).order_by( BotModel.last_ping.asc() ) start = time.time() result = loop.run_until_complete(run(bot, bot_checker, all_bots, stop_event)) # type: Counter end = time.time() if not result: msg = "š BotChecker encountered problems." else: msg = "ā¹ļø BotChecker completed in {}s:\n".format(round(end - start)) for k, v in result.items(): msg += "\nā {} {}".format(v, k) bot.send_message(settings.BOTLIST_NOTIFICATIONS_ID, msg) log.info(msg)
def send_message(chat, message): bot, user = Bot.get(chat['botname']), User.get(chat['username']) response = create_fake_message(user, bot, chat, message) logger.info('send message to bot response: %s' % (response)) print(response) r = requests.post(bot['callback'], json=response) print(r.text)
def send_category(bot, update, chat_data, category): uid = util.uid_from_update(update) cid = update.effective_chat.id bots = Bot.of_category_without_new( category)[:settings.MAX_BOTS_PER_MESSAGE] bots_with_description = [b for b in bots if b.description is not None] detailed_buttons_enabled = len( bots_with_description) > 0 and util.is_private_message(update) callback = CallbackActions.SEND_BOT_DETAILS if detailed_buttons_enabled: buttons = [ InlineKeyboardButton( x.username, callback_data=util.callback_for_action(callback, {"id": x.id}), ) for x in bots_with_description ] else: buttons = [] menu = util.build_menu(buttons, 2) menu.insert( 0, [ InlineKeyboardButton( captions.BACK, callback_data=util.callback_for_action( CallbackActions.SELECT_CATEGORY), ), InlineKeyboardButton( "Show in BotList", url="http://t.me/botlist/{}".format( category.current_message_id), ), InlineKeyboardButton("Share", switch_inline_query=category.name), ], ) txt = "There are *{}* bots in the category *{}*:\n\n".format( len(bots), str(category)) if uid in settings.MODERATORS and util.is_private_message(update): # append admin edit buttons txt += "\n".join(["{} ā /edit{} š".format(b, b.id) for b in bots]) else: txt += "\n".join([str(b) for b in bots]) if detailed_buttons_enabled: txt += "\n\n" + util.action_hint( "Press a button below to get a detailed description.") reply_markup = InlineKeyboardMarkup(menu) reply_markup, callback = botlistchat.append_restricted_delete_button( update, chat_data, reply_markup) msg = bot.formatter.send_or_edit(cid, txt, to_edit=util.mid_from_update(update), reply_markup=reply_markup) callback(msg) Statistic.of(update, "menu", "of category {}".format(str(category)), Statistic.ANALYSIS)
def shutdown_and_redeploy(self): live_bots = self.fetch_live_bots() for bot in live_bots: allocation = bot.allocation name = Bot.get(id=bot.id).name self.shutdown_bot(name) self.start_bot(name, allocation)
def shutdown_bot(self, name): b = Bot.get(name=name) settings = BotSettings.get(id=b.id) subprocess.Popen(["kill", "-9", str(settings.pid)]) settings.bot_live = False settings.save() print("Killed bot: {}".format(name))
def send_footer(self): num_bots = Bot.select_approved().count() self.notify_admin('Sending footer...') # add footer as notification footer = '\n```' footer += '\n' + mdformat.centered("ā¢ @BotList ā¢\n{}\n{} bots".format( datetime.date.today().strftime("%Y-%m-%d"), num_bots)) footer += '```' if self.resend or not self.silent: try: self._delete_message(self.channel.footer_mid) except BadRequest as e: pass footer_to_edit = None else: footer_to_edit = self.channel.footer_mid footer_msg = self.bot.formatter.send_or_edit( self.channel.chat_id, footer, to_edit=footer_to_edit, timeout=120, disable_notifications=self.silent, reply_markup=self.portal_markup) if footer_msg: self.channel.footer_mid = footer_msg.message_id self.sent['footer'] = "Footer sent" self._save_channel()
def decorated_view(*args, **kwargs): channel=kwargs['channel'] bot=kwargs['bot'] bot=Bot.gql("WHERE name = :1", bot).get() if bot: kwargs['bot']=bot return func(*args, **kwargs) return redirect(url_for('qq.list_bots', channel=channel.id))
def create_bot(channel): form = BotForm() if form.validate_on_submit(): bot = Bot( name = form.name.data, activated = form.activated.data, code = form.code.data, channel = channel.key ) try: bot.put() flash(u'Bot %s successfully saved.' % bot.name, 'success') return redirect(url_for('qq.edit_bot', channel=channel.id, bot=bot.name)) except CapabilityDisabledError: flash(u'App Engine Datastore is currently in read-only mode.', 'info') return redirect(url_for('qq.list_bots', channel=channel.id)) return render_template("new_bot.html", channel=channel, form=form)
def test_new(client: BotIntegrationClient): uname = '@test__bot' try: try: b = Bot.get(username=uname) b.delete_instance() except Bot.DoesNotExist: pass res = client.send_command_await("new", [uname]) if client.get_me().id in settings.MODERATORS: assert 'is currently pending' in res.full_text.lower() assert res.inline_keyboards[0].find_button(r'.*Accept.*') else: assert re.search('you submitted.*for approval', res.full_text, re.IGNORECASE) finally: Bot.delete().where(Bot.username == uname)
def send_random_bot(bot, update): from components.explore import send_bot_details random_bot = (Bot.select().where( (Bot.approved == True, Bot.disabled == False), (Bot.description.is_null(False)), ).order_by(fn.Random()).limit(1)[0]) send_bot_details(bot, update, random_bot)
def get_status(bot_id): bot = Bot.query.get(bot_id) #set bot equal to var if not bot: #if doesnt exist then create new bot obj and add to db (new bot) bot = Bot(bot_id) info = request.get_json( ) #api call by post with json obj, update the db with the json obj print(info) if info: #updates bot info each time if 'platform' in info: bot.os = info['platform'] if 'hostname' in info: bot.hostname = info['hostname'] if 'username' in info: bot.username = info['username'] bot.ip = request.remote_addr #update ip address and last ping to now bot.last_ping = datetime.now() db.session.add(bot) db.session.commit() pending_cmd = '' #check if the bot has any commands pending, if so then delete it and return it cmd = bot.commands.order_by(Command.timestamp.desc()).first() if cmd: pending_cmd = cmd.cmd db.session.delete(cmd) db.session.commit() return pending_cmd
def _admin_buttons(send_botlist_button=False, logs_button=False): n_unapproved = len(Bot.select().where(Bot.approved == False, Bot.disabled == False)) n_suggestions = len(Suggestion.select_all()) n_pending = len(Bot.select_pending_update()) second_row = list() if n_unapproved > 0: second_row.append( KeyboardButton( captions.APPROVE_BOTS + " {}š".format(mdformat.number_as_emoji(n_unapproved)))) if n_suggestions > 0: second_row.append( KeyboardButton( captions.APPROVE_SUGGESTIONS + " {}āļø".format(mdformat.number_as_emoji(n_suggestions)))) buttons = [ [KeyboardButton(captions.EXIT), KeyboardButton(captions.REFRESH)], [ KeyboardButton(captions.FIND_OFFLINE), KeyboardButton(captions.SEND_CONFIG_FILES), ], ] update_row = list() if n_pending > 0: update_row.append( KeyboardButton(captions.PENDING_UPDATE + " {}{}".format( mdformat.number_as_emoji(n_pending), captions.SUGGESTION_PENDING_EMOJI, ))) if send_botlist_button: update_row.append(KeyboardButton(captions.SEND_BOTLIST)) if logs_button: update_row.append(KeyboardButton(captions.SEND_ACTIVITY_LOGS)) if len(update_row) > 0: buttons.insert(1, update_row) if len(second_row) > 0: buttons.insert(1, second_row) return buttons
def get(self): key = self.request.get('key') bot = Bot.get(key) template_values = { 'bot': bot, 'logout_url': users.create_logout_url("/"), } path = template_path("edit") self.response.out.write(template.render(path, template_values))
def apply_all_changes(bot, update, chat_data, to_edit): user = User.from_update(update) user_suggestions = Suggestion.select_all_of_user(user) for suggestion in user_suggestions: suggestion.apply() refreshed_bot = Bot.get(id=to_edit.id) edit_bot(bot, update, chat_data, refreshed_bot) Statistic.of(update, "apply", refreshed_bot.username)
def random_bot(): """ Returns a random bot from the BotList. By default, only "interesting" bots with description and tags are shown. Use the parameter `?all=True` to receive _all_ possible choices. """ show_all = bool(request.args.get("all", False)) if show_all: random_bot = Bot.select().order_by(fn.Random()).limit(1)[0] else: random_bot = random.choice(Bot.explorable_bots()) data = random_bot.serialize if data: res = jsonify({'search_result': data, 'meta': {'url': request.url}}) res.status_code = 200 else: res = _error("No bot found.") return res
def start_chat(chat): bot, user = Bot.get(chat['botname']), User.get(chat['username']) print(bot) #response = create_message_response(user, bot, "/start") response = create_fake_message(user, bot, chat, "/start") logger.info('send START message to bot response: %s' % (response)) print(response) r = requests.post(bot['callback'], json=response) print(r.text)
def bots(page): q = request.args.get('q', '', type=str) page = 1 if page is None else int(page) if q: bots, total = Bot.search(f'(user_id:{current_user.id}) AND {q}*', page, current_app.config['BOTS_PER_PAGE']) bots.total = total else: bots = get_bots(page) return render_template("fragments/bots.html", bots=bots)
def explore(bot, update, chat_data): cid = update.effective_chat.id uid = update.effective_user.id mid = util.mid_from_update(update) explorable_bots = Bot.explorable_bots() chat_data["explored"] = chat_data.get("explored", list()) # don't explore twice for explored in chat_data["explored"]: explorable_bots.remove(explored) if len(explorable_bots) == 0: util.send_md_message( bot, cid, mdformat.none_action( "You have explored all the bots. Congratulations, you might be the first š" ), ) return random_bot = random.choice(explorable_bots) buttons = [ [ InlineKeyboardButton( captions.ADD_TO_FAVORITES, callback_data=util.callback_for_action( CallbackActions.ADD_TO_FAVORITES, {"id": random_bot.id}), ), InlineKeyboardButton(captions.SHARE, switch_inline_query=random_bot.username), ], [ InlineKeyboardButton( random_explore_text(), callback_data=util.callback_for_action( CallbackActions.EXPLORE_NEXT), ) ], ] markup = InlineKeyboardMarkup(buttons) text = random_bot.detail_text if uid in settings.MODERATORS and util.is_private_message(update): text += "\n\nš /edit{}".format(random_bot.id) msg = bot.formatter.send_or_edit(cid, text, to_edit=mid, reply_markup=markup) chat_data["explored"].append(random_bot)
def edit_bot(bot, update, chat_data, to_edit=None): uid = util.uid_from_update(update) message_id = util.mid_from_update(update) user = User.from_update(update) if not to_edit: if update.message: command = update.message.text if "edit" in command: b_id = re.match(r"^/edit(\d+)$", command).groups()[0] elif "approve" in command: b_id = re.match(r"^/approve(\d+)$", command).groups()[0] else: raise ValueError("No 'edit' or 'approve' in command.") try: to_edit = Bot.get(id=b_id) except Bot.DoesNotExist: update.message.reply_text( util.failure("No bot exists with this id.")) return else: bot.formatter.send_failure(uid, "An unexpected error occured.") return # if not to_edit.approved: # return approve_bots(bot, update, override_list=[to_edit]) pending_suggestions = Suggestion.pending_for_bot(to_edit, user) reply_markup = InlineKeyboardMarkup( _edit_bot_buttons(to_edit, pending_suggestions, uid in settings.MODERATORS)) pending_text = ("\n\n{} Some changes are pending approval{}.".format( captions.SUGGESTION_PENDING_EMOJI, "" if user.chat_id in settings.MODERATORS else " by a moderator", ) if pending_suggestions else "") meta_text = ("\n\nDate added: {}\nMember since revision {}\n" "Submitted by {}\nApproved by {}".format( to_edit.date_added, to_edit.revision, to_edit.submitted_by, to_edit.approved_by, )) bot.formatter.send_or_edit( uid, "š Edit {}{}{}".format( to_edit.detail_text, meta_text if user.id in settings.MODERATORS else "", pending_text, ), to_edit=message_id, reply_markup=reply_markup, )
def update_new_bots_list(self): text = self._read_file(self.NEW_BOTS_FILE) # insert spaces and the name of the bot new_bots_joined = Bot.get_new_bots_markdown() text = text.format(new_bots_joined) msg = self.send_or_edit(text, self.channel.new_bots_mid) self.sent['new_bots_list'] = "List of new bots sent" if msg: self.channel.new_bots_mid = msg.message_id self._save_channel()
def chant(remark): retort = {"toUser": remark["fromUser"], "fromUser": remark["toUser"], "createTime": int(time.time())} channel = remark["channel"] q = Bot.gql("WHERE channel = :1 AND activated = True", channel.key) for bot in q: module = LoadBot(channel, bot) retort = { MSG_TYPE_TEXT: module.process_text, MSG_TYPE_IMAGE: module.process_image, MSG_TYPE_LOCATION: module.process_location, MSG_TYPE_LINK: module.process_link, MSG_TYPE_EVENT: module.process_event, }[remark["msgType"]](remark, retort) retort["message"] = render_template("message.xml", message=retort) logging.info(retort["message"]) return retort
def list_bots(channel): """List channel bots""" bots = Bot.query(Bot.channel==channel.key) return render_template('list_bots.html', channel=channel, bots = bots)
def newbot(request): bot = Bot(name=request.GET['n']) bot.save() return HttpResponse("successfully created bot named '{1}' with id: {0}".format(bot.id, bot.name))
def ReloadAllBots(channel, bot): # Get the list of modules from the database and load them all q = Bot.gql("WHERE channel = :1 AND activated = True", channel.key) for bot in q: ReloadBot(channel, bot)