def __init__(self): self.client = zulip.Client(site="https://fazeup.zulipchat.com/api/") self.subscribe_all() self.hacknews = Hackernews() self.trans = Translate() self.movie = Movie() self.lyrics = Lyrics() self.holiday = Holiday() self.currency = Currency() self.cricket = Cricket() # self.chatbot.train("chatterbot.corpus.english") self.crypto = Crypto() self.trans = Translate() self.g = Giphy() self.w = WikiPedia() # self.tw = Twimega() # self.motivate = Motivate() self.shortenedurl = Urlshortener() self.geo = Geocode() self.weather = Weather() self.dict_ = Dictionary() self.joke = Joke() self.pnr = Pnr() self.mustread = Mustread() self.ss = Ss() self.cricket = Cricket() self.poll = Poll() print("done init") self.subkeys = [ "crypto", "translate", "define", "joke", "weather", "giphy", "pnr", "mustread", "poll", "hackernews", "hn", "HN", "motivate", "twitter", "screenshot", "memo", "cricnews", "help", "shorturl", "movie", "currency", "holiday", "lyrics" ]
async def get_config_from_user(self, ctx, poll: Poll, new_poll=False): # protected, number of choices per vote, max votes per poll await ctx.send( f'Thanks for making a poll! Do you want this poll to be private? **({random.choice(YES)}/{random.choice(NO)})**\n' + 'This means **only you** can see the results, but everyone can still vote.' ) def check(msg): return msg.author.id == ctx.author.id and msg.channel == ctx.channel r = await self.bot.wait_for('message', check=check) while True: if r.content.lower() in YES: poll.protected = True break elif r.content.lower() in NO: poll.protected = False break else: await ctx.send( f'I didn\'t quite catch that. Respond with **{random.choice(YES)}** or **{random.choice(NO)}**.' ) r = await self.bot.wait_for('message', check=check) print(f'set poll {poll.title} to protected={poll.protected}')
def handler(event, contest): logger.info("Start!") executor = ThreadPoolExecutor(max_workers=1000) main_loop = asyncio.new_event_loop() main_loop.set_default_executor(executor) asyncio.set_event_loop(main_loop) poll = Poll(main_loop) cal = poll.cal update_and_delete = UpdateAndDelete(main_loop, executor) table = event['table'] queue_url = event['queueUrl'] message_count = event['messageCount'] poll.messages(sqs, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count)) update_and_delete.execute(sqs_client, db, queue_url, table, cal.stats) logger.info("Update API count: {}".format(update_and_delete.update_count)) logger.info("Delete API count: {}".format(update_and_delete.delete_count)) logger.info("Delete Message count: {}".format( update_and_delete.deleted_message_count)) main_loop.close() executor.shutdown() return "Lambda job finished successfully."
def handle_request(self, request): args = {} for k, v in request.args.items(): args.update({k: v[0]},) if len(request.postpath[0]) and not args.get('callback'): request.setResponseCode(400) return HTML if 'register' in request.postpath: register = Register(request, args) return register.response() if 'login' in request.postpath: login = Login(request, args) return login.response() if 'poll' in request.postpath: poll = Poll(request, args) return poll.response() if 'message' in request.postpath: message = Message(request, args) return message.response() if 'join' in request.postpath: join = Join(request, args) return join.response() else: return """
def getUserPoll(self, pollId, formated=True): p = Poll(pollId) if formated: return p.formated() return p
def hasAnsweredPoll(self, pollId): p = Poll(pollId) if p.pollExists(pollId): return not p.hasUserAnswer(self.getUserId()) return False
def test_add_option(self): poll = Poll("test", "fake id") poll.add_option(None, ["option #1", "This is the first option"]) self.assertEqual( str(poll), r"test{'option #1': {'id': 'option #1', 'description'" r": 'This is the first option', 'voters': [], 'index'" r": 0}}{}fake id")
def ExtractPollsFromTable(table, riding_number, riding_name): polls = [] rows = table.find_all('tr') date_column, sample_size_column, party_columns = FindColumnHeaders(rows[0]) for row in rows[1:]: columns = row.find_all('td') date_string = columns[date_column].find('span', '').get_text() parsed_date = datetime.datetime.strptime(date_string, '%B %d, %Y') sample_size_string = columns[sample_size_column].get_text().strip() if sample_size_string: sample_size = float(sample_size_string.replace(',', '')) else: sample_size = 0 poll = Poll(parsed_date, sample_size, riding_number, riding_name) for party_name, party_index in party_columns.items(): if party_index >= 0: number_string = columns[party_index].get_text() try: support = float(number_string) / 100 except: support = 0 party_code = party_names[party_name] poll.party_support[party_code] = support polls.append(poll) return polls
def __init__(self): self.client = zulip.Client(site="https://chunkzz.zulipchat.com/api/") self.subscribe_all() self.chatbot = ChatBot( "Omega", trainer='chatterbot.trainers.ChatterBotCorpusTrainer') self.chatbot.train("chatterbot.corpus.english") self.crypto = Crypto() self.trans = Translate() self.g = Giphy() self.w = WikiPedia() self.tw = Twimega() self.motivate = Motivate() self.shortenedurl = Urlshortener() self.hacknews = Hackernews() self.geo = Geocode() self.weather = Weather() self.dict_ = Dictionary() self.joke = Joke() self.pnr = Pnr() self.mustread = Mustread() self.ss = Ss() self.cricket = Cricket() self.poll = Poll() self.subkeys = [ "crypto", "translate", "define", "joke", "weather", "giphy", "pnr", "mustread", "poll", "hackernews", "hn", "HN", "motivate", "twitter", "screenshot", "memo", "cricnews", "help", "shorturl" ]
def __init__(self, curr_directory, output_directory, max_file_size, plugins_file, es_url): """Initializes the Efetch Helper""" # Setup directory references self.curr_dir = curr_directory self.resource_dir = self.curr_dir + os.path.sep + u'resources' + os.path.sep self.icon_dir = self.resource_dir + u'icons' + os.path.sep self.output_dir = output_directory self.max_file_size = max_file_size if not os.path.isdir(self.icon_dir): logging.error(u'Could not find icon directory ' + self.icon_dir) self.pathspec_helper = PathspecHelper(output_directory, max_file_size) # Create plugin manager and begin polling for changes to plugins self.plugin_manager = EfetchPluginManager(plugins_file, self.curr_dir) self.poll = Poll(self.plugin_manager) self.poll.start() self.standard_office_2007_extensions = [ 'xlsx', 'docx', 'pptx', 'dotx', 'docm', 'doct', 'xlsm', 'xltx', 'xltm', 'pptx', 'pptm', 'potx', 'ppam', 'ppsx', 'ppsm', 'sldx', 'sldm' ] # Elastic Search DB setup if es_url: self.db_util = DBUtil() else: self.db_util = DBUtil(es_url)
def handler(event, contest): logger.info("Start!") main_loop = IOLoop.instance() poll = Poll(main_loop) cal = poll.cal delete = Delete() update_and_delete = UpdateAndDelete(main_loop, delete) table = event['table'] queue_url = event['queueUrl'] message_count = event['messageCount'] poll.messages(sqs_receive_message, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count)) update_and_delete.execute(sqs_delete_message_batch, db_update_item, queue_url, table, cal.stats) logger.info("Update API count: {}".format(update_and_delete.update_count)) logger.info("Delete API count: {}".format(delete.delete_count)) logger.info("Delete Message count: {}".format(delete.message_count)) return "Lambda job finished successfully."
def prepare_songs_for_poll(client: WebClient, poll: Poll, request_form: dict, songs: list) -> None: """ Function that create and save poll in storage. """ # If previous steps are good, do ... poll.number_of_songs = len(songs) poll.storage.data['is_started'] = True # As slack message allows having only < 50 songs in the message, so next code # seperate all the songs on 30 songs chunks and put each chunk in its message. messages = [] if len(songs) > 30: chunks = poll.divide_all_songs_into_chunks([songs]) else: chunks = [songs] send_msg_to_chat(client, request_form, "Please, vote for the next song to play 🎶") for songs_chunk in chunks: message_blocks = poll.create_poll_blocks(songs_chunk) response = send_msg_to_chat(client, request_form, '', blocks=message_blocks) messages.append({'id': response.get('ts'), 'songs': songs_chunk}) poll.storage.data['messages'] = messages poll.storage.save()
def test_load_invalid(): with pytest.raises(InvalidPollError): Poll.load('bla') with pytest.raises(InvalidPollError): poll = Poll.create('user0123', 'Spam?', 'en', ['Yes', 'Maybe', 'No'], secret=True, public=True, max_votes=2) Poll(poll.connection, 'user3210')
def test_submit_vote(self): poll = Poll("test", "fake id") poll.add_option(None, ["option #1", "This is the first option"]) poll.add_option(None, ["option #2", "This is the second option"]) poll.start_poll() poll.submit_vote("test pollr id", "test name", ["1"]) self.assertEqual( str(poll.voters), r"{'test pollr id': test pollr id " r"test name option #1}")
def gmail(): if request.method == "GET": return render_template("email.html") elif request.method == "POST": form = request.form something = form["something"] p = Poll(something=something) p.save() return render_template("email.html")
def poll_for_tests(): poll = Poll() poll.storage = Mock() poll.storage.data = { 'is_started': False, 'is_music_upload': False, 'messages': [] } return poll
def main(): p = Poll(LOGIN, PASSWORD) post_url = 'https://vk.com/wall-25232578_4482001' results = p.get_results(post_url) print results return 0
def getAPoll(self,pollquestion): connection=dbapi2.connect(current_app.config['dsn']) cursor=connection.cursor() cursor.execute("""SELECT VOTENUMBER,CHOICENUMBER FROM POLLS WHERE POLLQUESTION=%s""",(pollquestion,)) temp2=cursor.fetchone() votenumber=temp2[0] choicenumber=temp2[1] poll=Poll(pollquestion,creatorname) poll.votenumber=votenumber poll.choicenumber=choicenumber return poll
async def poll(self, ctx, title: str): """Create a poll with a one-word title!""" # add check for poll with existing name poll = Poll(title, ctx.guild.id, ctx.channel.id, ctx.author.id) await self.get_config_from_user(ctx, poll, new_poll=True) entries = await self.get_entries_from_user(ctx) poll.add_entries( entries[:poll.max_entries]) # TODO add feedback for max entries if not self.add_poll(poll): await ctx.send('Couldn\'t create poll') return await ctx.send('Poll created!', embed=self.make_poll_embed(poll, ctx))
def test_load(): poll = Poll.create('user0123', 'Spam?', 'en', ['Yes', 'Maybe', 'No'], secret=True, public=True, max_votes=2, bars=True) # because of :memory: database, load() cannot be used directly poll2 = Poll(poll.connection, poll.id) assert poll.creator_id == poll2.creator_id assert poll.message == poll2.message assert poll.secret == poll2.secret assert poll.public == poll2.public assert poll.max_votes == poll2.max_votes assert poll.vote_options == poll2.vote_options assert poll.bars == poll2.bars
def handler(event, contest): logger.info("Start!") main_loop = IOLoop.instance() poll = Poll(main_loop) queue_url = event['queueUrl'] message_count = event['messageCount'] poll.messages(sqs_receive_message, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count))
def test_get_polls_with_options_returns_poll_with_correct_options(self): test_poll = Poll("options_test") test_poll.add_options_from_list( [PollOption("first"), PollOption("second"), PollOption("third")]) test_poll2 = Poll("second_test") test_poll2.add_options_from_list( [PollOption("fourth"), PollOption("fifth"), PollOption("sixth")]) self.db.add_poll(test_poll) self.db.add_poll(test_poll2) output = self.db.get_polls_with_name("options_test") self.assertEqual(len(output), 1) self.assertEqual(len(output[0].poll_options), len(test_poll.poll_options)) for actual, expected in zip(output[0].poll_options, test_poll.poll_options): self.assertEqual(actual.name, expected.name) output = self.db.get_polls_with_name("second_test") self.assertEqual(len(output), 1) self.assertEqual(len(output[0].poll_options), len(test_poll2.poll_options)) for actual, expected in zip(output[0].poll_options, test_poll2.poll_options): self.assertEqual(actual.name, expected.name)
def autoRun(userName, password): miui_url = 'http://www.miui.com/member.php?mod=logging&action=miuilogin' geek_url = 'http://geek.miui.com/index.php?m=member&c=index&a=login' opener = login(miui_url, userName, password) dailySignIn(opener) #geek community;1) first take the task; 2)login geek section geekSignIn(opener) geek_opener = login(geek_url, userName, password) geekDraw(opener) poller = Poll(opener) poller.autoPoll()
def handler(event, contest): logger.info("Start!") main_loop = IOLoop.instance() poll = Poll(main_loop) queue_url = event["queueUrl"] message_count = event["messageCount"] poll.messages(sqs_receive_message, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count))
def getPoll(self,pollquestion,creatorname): connection=dbapi2.connect(current_app.config['dsn']) cursor=connection.cursor() cursor.execute("""SELECT ID FROM USERS WHERE USERNAME=%s""",(creatorname,)) temp=cursor.fetchone() creatorid=temp cursor.execute("""SELECT VOTENUMBER,CHOICENUMBER FROM POLLS WHERE POLLQUESTION=%s AND CREATORID=%s""",(pollquestion,creatorid)) poll=Poll(pollquestion,creatorname) array=[(temp2[0],temp2[1]) for temp2 in cursor] for votenumber,choicenumber in array: poll.votenumber=votenumber poll.choicenumber=choicenumber cursor.close() connection.close() return poll
def delete_poll(poll_id, delete_key): try: poll = Poll.get_poll(poll_id) if poll is None: flask.abort(404) if poll.delete_key != delete_key: flask.abort(403) delete_form = forms.DeleteForm() if delete_form.validate_on_submit(): poll.key.delete() import time time.sleep(0.5) flask.flash('Poll deleted successfully.', 'success') events.poll_deleted_event(poll) return flask.redirect('/', code=302) # Redirect back to home page form = forms.ResponseForm() return flask.render_template('poll.html', title=poll.title, poll=poll, responses=poll.get_responses(), form=form, delete_form=delete_form, delete=True) except: # Poll.get_poll() with an invalid ID can return one of many exceptions so leaving this for general case # More info see: https://github.com/googlecloudplatform/datastore-ndb-python/issues/143 flask.abort(404)
def start_lightsoff(client: WebClient, poll: Poll, request_form: dict) -> None: """ Function, that is invoked when we run /lightsoff command. Finish the last poll and give the song. """ send_msg_to_chat(client, request_form, 'The poll is finished. The winner is ...') winner = poll.find_the_winner_song() if poll.is_music_upload: upload_song(client, request_form, winner) else: send_msg_to_chat( client, request_form, f"{winner['artist']} - {winner['title']} with {len(winner['voted_users'])} votes !!!" ) # Reset poll status poll.storage.data['is_music_upload'] = False poll.storage.data['is_started'] = False poll.storage.save() # Delete message(s) from chat channel_id = request_form.get('channel_id') for message_id in poll.storage.get_all_messages_id(): delete_msg_in_chat(client, channel_id, message_id)
def test_vote(): poll = Poll.create('user0123', 'Spam?', ['Yes', 'Maybe', 'No']) assert poll.num_votes() == 0 assert poll.count_votes(0) == 0 assert poll.count_votes(1) == 0 assert poll.count_votes(2) == 0 assert poll.count_votes(3) == 0 poll.vote('user0', 0) poll.vote('user1', 2) poll.vote('user2', 2) assert poll.num_votes() == 3 assert poll.count_votes(0) == 1 assert poll.count_votes(1) == 0 assert poll.count_votes(2) == 2 assert poll.count_votes(3) == 0 poll.vote('user0', 0) poll.vote('user0', 0) assert poll.num_votes() == 3 assert poll.count_votes(0) == 1 assert poll.count_votes(1) == 0 assert poll.count_votes(2) == 2 assert poll.count_votes(3) == 0 poll.vote('user2', 1) assert poll.num_votes() == 3 assert poll.count_votes(0) == 1 assert poll.count_votes(1) == 1 assert poll.count_votes(2) == 1 assert poll.count_votes(3) == 0
def end_poll(): """Ends the poll. Called by the 'End Poll' actions. Only the user that created the poll is allowed to end it. All other user will receive an ephemeral error message. """ json = request.get_json() user_id = json['user_id'] poll_id = json['context']['poll_id'] try: poll = Poll.load(poll_id) except InvalidPollError: return jsonify({ 'ephemeral_text': "This poll is not valid anymore.\n" "Sorry for the inconvenience." }) app.logger.info('Ending poll "%s"', poll_id) if user_id == poll.creator_id: # only the creator may end a poll poll.end() return jsonify({ 'update': { 'props': get_poll(poll) } }) return jsonify({ 'ephemeral_text': "Error:你不能关闭这个投票" })
def poll_view(poll_id): try: poll = Poll.get_poll(poll_id) if poll is None: flask.abort(404) form = forms.ResponseForm() if form.validate_on_submit(): rs = form.response.data # Check if the the response has been posted before if not poll.check_duplicate(rs): flask.flash( "That response has already been submitted, why don't you upvote it?", 'warning') # Check the response actually has content elif not poll.check_valid_response(rs): flask.flash( "That response is invalid, a good valid response is one that's more than a few characters and adds value to the poll.", 'warning') else: Response.add(poll, rs) return flask.redirect('/poll/' + poll.get_id(), code=302) return flask.render_template( 'poll.html', title=poll.title, poll=poll, responses=poll.get_responses(), form=form, cookie=flask.request.cookies.get('voteData')) except: # Poll.get_poll() with an invalid ID can return one of many exceptions so leaving this for general case # More info see: https://github.com/googlecloudplatform/datastore-ndb-python/issues/143 flask.abort(404)
def inline_query(bot: Bot, update: Update): inline_query: InlineQuery = update.inline_query query: str = inline_query.query polls: List[Poll] = Poll.query(inline_query.from_user.id, query) results = [] for poll in polls: results.append( InlineQueryResultArticle( id=str(uuid4()), title=poll.topic, input_message_content=InputTextMessageContent( message_text=str(poll), parse_mode=None, disable_web_page_preview=True), description=" / ".join(answer.text for answer in poll.answers()), reply_markup=inline_keyboard_markup_answers(poll))) inline_query.answer(results, is_personal=True, cache_time=30, switch_pm_text="Create new poll", switch_pm_parameter="new_poll")
def poll_vote(poll_id, vote_type): # Check for cookie when voting, and create a cookie if there isn't one if 'voteData' in flask.request.cookies: cookie = flask.request.cookies.get('voteData') else: cookie = str(uuid.uuid4()) # Generate cookie resp = flask.jsonify({}) # check the start of vote_type to determin the type of object that the user is voting on if vote_type.startswith('resp'): # if the user is voting on a response r = Response.get_response(poll_id, flask.request.form['resp_id']) if vote_type.lower() == 'resp-up': r.upvote(cookie) elif vote_type.lower() == 'resp-down': r.downvote(cookie) elif vote_type.lower() == 'resp-flag': r.update_flag(cookie) resp = flask.jsonify({ 'score': (r.upv - r.dnv), 'up': r.upv, 'down': r.dnv }) # if the user is voting on a poll elif vote_type.startswith('poll'): p = Poll.get_poll(poll_id) if vote_type.lower() == 'poll-flag': p.update_flag(cookie) resp.set_cookie('voteData', cookie) return resp
def test_format_poll_running(mocker): mocker.patch('formatters.resolve_usernames', new=lambda user_ids: user_ids) poll = Poll.create(creator_id='user0', message='# Spam? **:tada:**', vote_options=['Sure', 'Maybe', 'No'], secret=False) poll.vote('user0', 0) poll.vote('user1', 1) poll.vote('user2', 2) poll.vote('user3', 2) with app.app.test_request_context(base_url='http://localhost:5005'): poll_dict = frmts.format_poll(poll) assert 'response_type' in poll_dict assert 'attachments' in poll_dict assert poll_dict['response_type'] == 'in_channel' attachments = poll_dict['attachments'] assert len(attachments) == 1 assert 'text' in attachments[0] assert 'actions' in attachments[0] assert 'fields' in attachments[0] assert attachments[0]['text'] == poll.message assert len(attachments[0]['actions']) == 4 fields = attachments[0]['fields'] assert len(fields) == 1 assert 'short' in fields[0] assert 'title' in fields[0] assert 'value' in fields[0] assert not fields[0]['short'] assert not fields[0]['title'] assert fields[0]['value'] == '*Number of voters: 4*'
def end_poll(): """Ends the poll. Called by the 'End Poll' actions. Only the user that created the poll is allowed to end it. All other user will receive an ephemeral error message. """ json = request.get_json() user_id = json['user_id'] team_id = json['team_id'] poll_id = json['context']['poll_id'] request.user_id = user_id try: poll = Poll.load(poll_id) except InvalidPollError: return jsonify({ 'ephemeral_text': tr("This poll is not valid anymore.\n" "Sorry for the inconvenience.") }) app.logger.info('Ending poll "%s"', poll_id) # only the creator and admins may end a poll can_end_poll = \ user_id == poll.creator_id or \ is_admin_user(user_id) or \ is_team_admin(user_id=user_id, team_id=team_id) if can_end_poll: poll.end() return jsonify({'update': {'props': format_poll(poll)}}) return jsonify( {'ephemeral_text': tr("You are not allowed to end this poll")})
def __init__(self, curr_directory, output_directory, max_file_size, plugins_file, es_url): """Initializes the Efetch Helper""" # Setup directory references self.curr_dir = curr_directory self.resource_dir = self.curr_dir + os.path.sep + u'resources' + os.path.sep self.icon_dir = self.resource_dir + u'icons' + os.path.sep self.output_dir = output_directory self.max_file_size = max_file_size if not os.path.isdir(self.icon_dir): logging.error(u'Could not find icon directory ' + self.icon_dir) self.pathspec_helper = PathspecHelper(output_directory, max_file_size) # Create plugin manager and begin polling for changes to plugins self.plugin_manager = EfetchPluginManager(plugins_file, self.curr_dir) self.poll = Poll(self.plugin_manager) self.poll.start() self.standard_office_2007_extensions = ['xlsx', 'docx', 'pptx', 'dotx', 'docm', 'doct', 'xlsm', 'xltx', 'xltm', 'pptx', 'pptm', 'potx', 'ppam', 'ppsx', 'ppsm', 'sldx', 'sldm'] # Elastic Search DB setup if es_url: self.db_util = DBUtil() else: self.db_util = DBUtil(es_url)
def start_with_poll(bot: Bot, update: Update, groups: Tuple[str]): message: Message = update.message poll_id = int(groups[0]) poll = Poll.load(poll_id) send_vote_poll(message, poll)
def create_poll(self, title, user, **kwargs): ''' Creates a poll with the parameters Title : User ''' if title in self.poll_list: return "The poll already exist, remove it before" poll = Poll(title, user) self.poll_list[title] = poll poll.question = kwargs["question"] #set basic choices poll.choices = [":+1:",":-1:"] return "The poll \""+title+"\" has been created"
def consume(table, queue_url, message_count): main_loop = IOLoop.instance() poll = Poll(main_loop) cal = poll.cal delete = Delete() update_and_delete = UpdateAndDelete(main_loop, delete) poll.messages(sqs_receive_message, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count)) update_and_delete.execute(sqs_delete_message_batch, db_update_item, queue_url, table, cal.stats) logger.info("Update API count: {}".format(update_and_delete.update_count)) logger.info("Delete API count: {}".format(delete.delete_count)) logger.info("Delete Message count: {}".format(delete.message_count))
def handler(event, context): logger.info("Start!") poll = Poll() cal = Sum() update = Update() delete = Delete() table = event["table"] queue_url = event["queueUrl"] message_count = event["messageCount"] def on_error(e): raise e def on_poll_completed(): logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count)) update_and_delete() def update_and_delete_one(key): updated_message_ids = update.execute(db, table, cal.stats[key]) return delete.execute(sqs_client, queue_url, updated_message_ids) def update_and_delete(): delete_results = [] async_one = rx.Observable.to_async(update_and_delete_one) for key in cal.stats: delete_results.append(async_one(key)) rx.Observable.merge(delete_results).to_blocking().for_each(block) on_next_message = cal.add messages = poll.messages(sqs, queue_url, message_count).to_blocking() messages_observer = rx.Observer(on_next_message, on_error, on_poll_completed) messages.subscribe(messages_observer) messages.for_each(block) logger.info("Update API count: {}".format(update.update_count)) logger.info("Delete API count: {}".format(delete.delete_count)) logger.info("Delete Message count: {}".format(delete.message_count))
def make_variant_poll(self, variant, user): from poll import Poll key = self.variant_key(variant) for poll in self.polls: if poll.subject == key: return poll poll = Poll.create(self.page, user, Poll.SELECT, subject=key) if self._polls is not None: self._polls.append(poll) return poll
def handler(event, contest): logger.info("Start!") executor = ThreadPoolExecutor(max_workers=1000) main_loop = asyncio.new_event_loop() main_loop.set_default_executor(executor) asyncio.set_event_loop(main_loop) poll = Poll(main_loop) queue_url = event['queueUrl'] message_count = event['messageCount'] poll.messages(sqs, queue_url, message_count) logger.info("Receive API count: {}".format(poll.fetch_count)) logger.info("Fetched messages: {}".format(poll.message_count)) main_loop.close() executor.shutdown()
def vote(self, poll_id, vote): try: curs.execute("""INSERT INTO vote (poll_id, user_id, value) VALUES (%s, %s, '%s')""" % (poll_id, self.id, vote)) except IntegrityError: return 0 poll = Poll.get_by_id(poll_id) poll.update_state(vote) return 1
def create(cls, instance, label, user, with_vote=False, tags=None): from poll import Poll from tagging import Tagging proposal = Proposal(instance, label, user) meta.Session.add(proposal) meta.Session.flush() poll = Poll.create(proposal, user, Poll.RATE, with_vote=with_vote) proposal.rate_poll = poll if tags is not None: proposal.taggings = Tagging.create_all(proposal, tags, user) meta.Session.flush() return proposal
def create(cls, text, user, topic, reply=None, wiki=True, variant=None, sentiment=0, with_vote=False): from poll import Poll comment = Comment(topic, user, variant) comment.wiki = wiki comment.reply = reply meta.Session.add(comment) meta.Session.flush() poll = Poll.create(topic, user, Poll.RATE, comment, with_vote=with_vote) comment.poll = poll comment.latest = comment.create_revision( text, user, sentiment=sentiment, create_time=comment.create_time) return comment
def content( self ): ## real content loading if self.type == 'thread': ## Message.HEADER = 'chat-message:(.*)' Message.HEADER = 'thread-message:(.*)' msg = Message.load_per_block( self.file , self._content ) return msg if self.type == 'chat': Message.HEADER = 'chat:(.*)meta' msg = Message.load_per_block( self.file , self._content ) ## different Presemo versions use differend headers, lets collect them all Message.HEADER = 'chat-message:(.*)' msg += Message.load_per_block( self.file , self._content ) return msg if self.type == 'rating': Message.HEADER = 'rating:(.*)' _msg = Message.load_per_block( self.file , self._content ) ## some Presemo versions used this heading Message.HEADER = 'rating-message:(.*)' _msg += Message.load_per_block( self.file , self._content ) ## return only unique ratings msg = {} for m in _msg: if m not in msg: msg[ m.id ] = m return msg.values() if self.type == 'poll': polls = Poll.load_per_block( self.file , [ self.id ] ) return polls return []
def getUserPollAnswers(self, pollId): p = Poll(pollId) return p.getResults()
def getUserPolls(self): return Poll.getPollList()
class EfetchHelper(object): """This class provides helper methods to be used in Efetch and its plugins""" def __init__(self, curr_directory, output_directory, max_file_size, plugins_file, es_url): """Initializes the Efetch Helper""" # Setup directory references self.curr_dir = curr_directory self.resource_dir = self.curr_dir + os.path.sep + u'resources' + os.path.sep self.icon_dir = self.resource_dir + u'icons' + os.path.sep self.output_dir = output_directory self.max_file_size = max_file_size if not os.path.isdir(self.icon_dir): logging.error(u'Could not find icon directory ' + self.icon_dir) self.pathspec_helper = PathspecHelper(output_directory, max_file_size) # Create plugin manager and begin polling for changes to plugins self.plugin_manager = EfetchPluginManager(plugins_file, self.curr_dir) self.poll = Poll(self.plugin_manager) self.poll.start() self.standard_office_2007_extensions = ['xlsx', 'docx', 'pptx', 'dotx', 'docm', 'doct', 'xlsm', 'xltx', 'xltm', 'pptx', 'pptm', 'potx', 'ppam', 'ppsx', 'ppsm', 'sldx', 'sldm'] # Elastic Search DB setup if es_url: self.db_util = DBUtil() else: self.db_util = DBUtil(es_url) def get_request_value(self, request, variable_name, default=None): """Gets the value of a variable in either a GET or POST request""" if variable_name in request.query: return request.query[variable_name] elif request.forms.get(variable_name): return request.forms.get(variable_name) return default def get_query_string(self, request, default_query=''): """Returns the query string of the given request""" if request.query_string: return "?" + request.query_string else: return default_query def get_query(self, request): """Gets the Kibana Query from the request""" return self.db_util.get_query(self.get_request_value(request, '_a', '()')) def get_theme(self, request): """Gets the Kibana Theme from the request""" return self.db_util.get_theme(self.get_request_value(request, '_a', '()')) def get_filters(self, request, must=[], must_not=[]): """Gets the Kibana Filter from the request""" return self.db_util.get_filters(self.get_request_value(request, '_a', '()'), self.get_request_value(request, '_g', '()'), self.get_request_value(request, 'timefield', 'datetime'), must, must_not) def is_expandable_evidence(self, evidence): """Returns True if evidence should be expandable and false if not""" # Separated for cleanliness, ordering matters here # Partitions and volume shadows are expandable if 'type_indicator' in evidence and evidence['type_indicator'] in ['TSK_PARTITION', 'VSHADOW']: return True # Volumes are expandable if 'volume_type' in evidence: return True # Most Storage types are expandable if 'storage_type' in evidence: # Not E02-E0N files if evidence['extension'].lower().startswith('e0') and evidence['extension'].lower() != 'e01': return False # All other storage types are expandable return True # Compression types are expandable if 'compression_type' in evidence: return True # Most archive types are expandable if 'archive_type' in evidence: # Not files with office 2007 mimetypes if evidence['mimetype'].startswith('application/vnd'): return False # Not files with office 2007 extensions if evidence['extension'].lower() in self.standard_office_2007_extensions: return False # All other archives are expandable return True # Everything else is not expandable return False def get_icon(self, evidence, resource=True): """Returns either an icon or thumbnail of the provided file""" if resource: curr_icon_dir = '/resources/icons/' else: curr_icon_dir = self.icon_dir if 'volume_type' in evidence or 'storage_type' in evidence or 'compression_type' in evidence \ or 'archive_type' in evidence: if not evidence['mimetype_known']: evidence['mimetype'] = self.pathspec_helper.get_mimetype(evidence['pathspec']) if self.is_expandable_evidence(evidence): return curr_icon_dir + '_evidence.png' if not 'meta_type' in evidence: return curr_icon_dir + '_blank.png' # If it is folder just return the folder icon if evidence['meta_type'] == 'Directory' or unicode(evidence['file_name']).strip() == "." or unicode( evidence['file_name']).strip() == "..": return curr_icon_dir + '_folder.png' if evidence['meta_type'] != 'File' and evidence['meta_type'] != 'Device': return curr_icon_dir + '_blank.png' # If the file is an image create a thumbnail if evidence['mimetype'].startswith('image') and resource: return '/plugins/thumbnail?' + evidence['url_query'] elif evidence['mimetype'].startswith('image'): self.pathspec_helper.create_thumbnail(evidence) if os.path.isfile(evidence['thumbnail_cache_path']): return evidence['thumbnail_cache_path'] else: return curr_icon_dir + '_missing.png' # TODO if mimetype is known, perform a mimetype to extension lookup instead of using extension # If file is not an image return the icon associated with the files extension else: if not os.path.isfile(self.icon_dir + str(evidence['extension']).lower() + '.png'): return curr_icon_dir + '_blank.png' else: return curr_icon_dir + evidence['extension'].lower() + '.png' def action_get(self, evidence, request, display_name, function, term, update_term = False): """Runs a function that takes an evidence item, updates the term in elastic, and returns the results""" index = self.get_request_value(request, 'index', False) value = '' # Only needed when using elasticsearch just else just return the OCR if index: # If using elasticsearch get the first entry query = {'_source': [term, evidence['pathspec']], 'query': {'term': {'pathspec.raw': evidence['pathspec']}}} first_elastic_entry = self.db_util.query_sources(query, index, 1) # If this plugin has not been run on this entry run it on all entries if term not in first_elastic_entry or update_term: # Not masking the exception, should be handled by plugin value = function(evidence, self) try: update = {term: value} events = self.db_util.scan(query, index) for item in events: logging.debug('Updating elasticsearch item: ' + str(item)) self.db_util.update(item['_id'], index, update, doc_type=item['_type']) except: logging.warn('Failed to update value in elasticsearch') else: value = first_elastic_entry[term] else: value = function(evidence, self) return value
def polls(self): from poll import Poll if self._polls is None: self._polls = Poll.by_subjects(self.subjects) return self._polls
def getAnsweredUserPolls(self): return list(Poll.getAnsweredPollList(self.getUserId()))
def answerUserPoll(self, pollId, answerId): p = Poll(pollId) if p.pollExists(pollId): p.answer(self.getUserId(), answerId)