def query_handler(update, context): query = update.callback_query if (query.data == "intro"): context.bot.send_message( chat_id=update.effective_chat.id, text= "Auto Schedular is a python based project that provides an interface through which a user can post a message on multiple social media platforms on single click!" ) if (query.data == "get_otp"): tg_user = context.bot.username # tg_user_otp = str(token_urlsafe()) if not tg_user: context.bot.send_message( chat_id=update.effective_chat.id, text="Please set your telegram username to login") else: session = models.Session() try: otp = models.User.insert_record_in_user(session, tg_user) context.bot.send_message(chat_id=update.effective_chat.id, text="OTP " + str(otp) + " generated for " + tg_user) finally: session.close() if (query.data == "add_new_grp"): # print(update.effective_message.chat) r = requests.get('https://api.telegram.org/bot' + const.tg_token + '/getUpdates') #r = r.json() """ if not r['result']: context.bot.send_message(chat_id=update.effective_chat.id,text="Please add bot to the Group") else: """ print(r['result'][0]['message']['chat']['id']) group_id = str(r['result'][0]['message']['chat']['id']) group_name = r['result'][0]['message']['chat']['title'] send_message_url = 'https://api.telegram.org/bot' + const.tg_token + '/sendMessage' data = { 'chat_id': group_id, 'text': 'Hi I am schedular bot. I can help you to publish your post on multiple platforms with a single click!' } requests.post(send_message_url, data=data) session = models.Session() try: tg_user_id = session.query(models.User.id).filter( models.User.tg_username == context.bot.username).all() u_id = tg_user_id[0][0] models.Group.add_group(session, group_id, group_name) models.Link.insert_record(session, u_id, group_id) context.bot.send_message(chat_id=update.effective_chat.id, text="Group added successfully") finally: session.close()
def check_addr(): try: session = models.Session() addrs = session.query(models.Monitor).all() for addr in addrs: ip = addr.httpaddr.split(":")[0] port = addr.httpaddr.split(":")[1] rev = check_tcp(ip, port) if rev == 0: addr.success += 1 addr.faild = 0 info = u'服务{0}({1})运行正常'.format(addr.name, addr.httpaddr) mylogger.info(info) # print(info) else: addr.success = 0 addr.faild += 1 info = u'服务{0}({1})运行异常'.format(addr.name, addr.httpaddr) mylogger.error(info) # print(addr.name + u'异常') addr.last_commit = now() mylogger.debug( '==============================================================') session.commit() except Exception as e: mylogger.fatal(e) finally: if session: session.close()
def ewas_gift_lists(self): session = models.Session() tmpl = env.get_template('ewas_gift_lists.html') ctx = {'lists': session.query(models.GiftList).all()} return tmpl.generate(ctx)
def get_dashboard(): # tg_handle_of_user = request.args['tg_handle_of_user'] if 'loggedin' in session: tg_handle_of_user = session.get('curr_user') new_session = models.Session() try: u_id = new_session.query(models.User.id).filter( models.User.tg_username == tg_handle_of_user).all() u_id = u_id[0][0] session['curr_user_id'] = u_id group_names_of_user = new_session.query( models.Group).filter(models.Link.user_id == u_id).all() print("group_names") print(group_names_of_user) groups_id_of_user = new_session.query(models.Link.group_id).filter( models.Link.user_id == u_id).all() data = [] for row in groups_id_of_user: data.append([x for x in row]) session['groups_id_of_user'] = data print("Inside dashboard") print(groups_id_of_user) #session['group_names_displayed'] = group_names_of_user #print(session.get('groups_id_of_user')) finally: new_session.close() return render_template('dashboard.html', tg_handle_of_user=tg_handle_of_user, groups_details=group_names_of_user) else: return render_template('login.html')
def find_equivalent_switch(self, fields): try: model = fields.get("Model", None) network_module = fields.get("Network_Module", None) platform = fields.get("Platform", None) data = {} data["matched"] = False data["modular"] = False data["switches"] = [] data["matched_model"] = None db_session = models.Session() requested_switch = self.find_switches_with_filters( db_session, model=model, network_module=network_module) # We found one match if len(requested_switch) == 1: # Save the name of the matched model data["matched_model"] = requested_switch[0].id mapping_ids = self.find_switch_mapping(db_session, requested_switch[0].id) # Could not find an equivalent if not mapping_ids: data["matched"] = True return data equivalent_switch = [] for mapping_id in mapping_ids: matches = self.find_switch_by_id(db_session, mapping_id) if len(matches) == 0: matches.extend( self.find_switch_by_id(db_session, mapping_id, expand=True)) equivalent_switch.extend(matches) # Pass the data back data["switches"] = equivalent_switch data["matched"] = True # Did not find any matching switch elif not requested_switch: return data # Multiple results, not fully matched yet else: data["switches"] = requested_switch data["matched"] = False # Check if the switch is modular if len(requested_switch) > 1: data["modular"] = requested_switch[0].modular return data except InvalidRequestError: # An SQL error will occur if the database is being spammed db_session.rollback() return data finally: db_session.close()
def run_once(self): session = models.Session() raw_messages = self._load_messages(session) # check if there is something to do. # if not, close the session and return. if not raw_messages.first(): transaction.abort() session.close() return None try: # enrich each message with the current session. messages = ((msg, session) for msg in raw_messages) for _ in self.pipeline.run(messages): # nothing to do here. pass finally: try: transaction.commit() except Exception as e: logger.error(e.message) transaction.abort() finally: session.close()
def session_action(methods=['GET']): from flask import request _id = request.args.get('user', None) user = None session_dict = {} session_dict['title'] = request.args.get('title', None) session_dict['description'] = request.args.get('description', None) session_dict['votes'] = 0 session_dict['accepted'] = False error = json.dumps({ "success": False, "text": "Please send a valid user ID and a session title and description." }) if not _id: return json.dumps(error) if _id: user = dict(utils.connect('user').find_one({"_id": _id})) session_dict['user'] = _id s = models.Session(**session_dict).save() tally() return json.dumps({ "success": True, "action": "create", "session": s['_id'] })
def post (self): res, message = self.checkValues('email','password') if res != constants.STATUS_OK: self.write(message) return email = self.request.get('email').lower() password = self.request.get('password') name = self.request.get('name','') phone = self.request.get('phone','') dr = models.MyDoctor() dr.email = email dr.password = password dr.name = name dr.phone_number = phone d_key = dr.put() reg_sess = models.RegistrationSession() reg_sess.user = d_key reg_sess.put() sess = models.Session() sess.user = d_key #sess.session = services.createNewSession() sess.put() self.write('all is OK')
def create_session(db: Session, user: schemas.UserAuthenticate): if not check_email_password(db, user): return None, None, None db_user = get_user_by_email(db, user.email) if not db_user.is_confirmed: return None, "User is not confirmed", None session = db.query( models.Session).filter(models.Session.userId == db_user.id).first() if session is None: session = models.Session(userId=db_user.id) db.add(session) db.commit() db.refresh(session) now = datetime.datetime.utcnow() access_token, refresh_token = create_tokens(db_user.email, session, now) session.refreshToken = refresh_token session.refreshTokenExpirationDate = now + datetime.timedelta( minutes=constants.TIMEDELTA) #db.add(session) db.commit() db.refresh(session) return access_token, refresh_token, session
def remove(self): session = models.Session() query = session.query( models.Forms).filter(models.Forms.id == str(self.formID)).one() correctAnswers, questions, userAnswers = query.get_correctAnswers( ), query.get_questions(), query.get_userAnswers() session.delete(query) for answer in correctAnswers: query = session.query( models.Answers).filter(models.Answers.id == str(answer)).one() session.delete(query) for question in questions: query = session.query(models.Questions).filter( models.Questions.id == str(question)).one() session.delete(query) for answer in userAnswers[str(question)]: query = session.query(models.Answers).filter( models.Answers.id == str(answer)).one() session.delete(query) session.commit() session.close() return True
def update_letv(): models.init_db() session = models.Session() movies = session.query(models.OnLineMovies) ret = letv.get_all() for one in ret: one = json.loads(one) movie = movies.filter_by(title=one["title"]).first() if not movie: movie = models.OnLineMovies() movie.title = one["title"] movie.url = one["url"] movie.language = one["language"] movie.director = one["director"] movie.img = one["img"] movie.description = one["description"] movie.actors = one["actors"] movie.duration = one["duration"] movie.rating = int(float(one["rating"]))*10 movie.subCategoryName = one["subCategoryName"] movie.releaseDate = one["releaseDate"] movie.ctime = one["ctime"] movie.area = one["area"] movie.tag = one["tag"] movie.subname = one["subname"] session.add(movie) session.commit()
def GET(self, *args, **kwargs): """ """ response = Response.internal_error() web.ctx.orm = None try: self.get_argument_timestamp() self.get_argument('token') self.get_argument('sign') self.log_request() with models.Session() as session: web.ctx.orm = session result = self.get(*args, **kwargs) response.code = 0 response.message = err.Success.message response.result = result pass except err.BaseError as e: logger.error("base error: %s", e.message) response.code = e.code response.message = e.message except: logger.exception('JsonHandler failure:') pass finally: del web.ctx.orm response_json_data = utils.json_dumps(response) return response_json_data
def handle_events(self, job_queue): while True: filepath = job_queue.get() logger.debug('Started handling event for %s' % filepath) pack = package.SafePackage(filepath, self.config.get('app', 'working_dir')) try: attempt = checkin.get_attempt(pack) except ValueError as e: pack.mark_as_failed(silence=True) except excepts.DuplicatedPackage as e: pack.mark_as_duplicated(silence=True) else: # Create a notification to keep track of the checkin process session = models.Session() checkin_notifier = self.CheckinNotifier(attempt, session) checkin_notifier.start() if attempt.is_valid: notification_msg = 'Attempt ready to be validated' notification_status = models.Status.ok else: notification_msg = 'Attempt cannot be validated' notification_status = models.Status.error checkin_notifier.tell(notification_msg, notification_status, 'Checkin') checkin_notifier.end() attempt.proceed_to_validation = True transaction.commit()
def loli(bot, update, args, session): logger.info("Ricevuto comando loli da: %s con parametri %s", update.message.from_user.username, ' '.join(args)) data = models.registerUpdate(session, update) if len(args) > 0: try: count = int(args[0]) logger.info("Richiesto invio di %i immagini con parametro %s", count, ' '.join(args[1:])) if 0 < count <= 10 and checkPermission( data['user'], 4, chat=data['chat']): param = ' '.join(args[1:]) if not '' else None for i in range(0, count): sendImage(update, models.Session(), param) else: logger.info( "Numero di immagini oltre il limite o mancanza di permessi" ) except ValueError: param = ' '.join(args) logger.info("Richiesta loli con parametro di ricerca: %s", param) sendImage(update, session, param) else: sendImage(update, session)
def inspect(): session = models.Session() return u"<strong>Cities:</strong><pre>{0}</pre><hr />"\ u"<strong>Houses:</strong><pre>{1}</pre><hr />"\ u"<strong>Persons:</strong><pre>{2}</pre><hr />".format( u"\n".join(enc(repr(x)) for x in session.query(models.City)), u"\n".join(enc(repr(x)) for x in session.query(models.House)), u"\n".join(enc(repr(x)) for x in session.query(models.Person)))
def remove(self): session = models.Session() query = session.query(models.Answers).filter( models.Answers.id == str(self.answerID)).one() session.delete(query) session.commit() session.close() return True
def vote_action(): from flask import request session = request.args.get('session') user = request.args.get('user') error = json.dumps({ "success": False, "text": "Please send a session ID and a user ID." }) if not session or not user: return error u = utils.connect('user').find_one({"_id": user}) if not u: return error s = utils.connect('session').find_one({"_id": session}) if not s: return error votes = [ vote for vote in utils.connect('vote').find({ "user": user, "session": session }) ] # Create a new vote. if len(votes) == 0: models.Vote(user=u['_id'], session=s['_id']).save() sesh = models.Session(s) sesh.update_records() tally() return json.dumps({"success": True, "action": "create vote"}) # Delete existing votes. if len(votes) > 0: utils.connect('vote').remove({"user": user, "session": session}) sesh = models.Session(s) sesh.update_records() tally() return json.dumps({"success": True, "action": "delete vote"}) return error
def remove(self): session = models.Session() query = session.query(models.Questions).filter( models.Questions.id == str(self.questionID)).one() session.delete(query) session.commit() session.close() return True '''
def wireteData(): db.session = db.Session() readDir("cxyx","2020-11-24") readDir("mtyx","2020-11-24") readDir("ddmc","2020-11-23") readDir("sht", "2020-11-24") readDir("xsyx", "2020-11-24") db.session.close() db.engine.dispose()
def synch(): session = models.Session() return u"<strong>Content Types:</strong><pre>{0}</pre><hr />"\ u"<strong>Nodes:</strong><pre>{1}</pre><hr />"\ u"<strong>Versions:</strong><pre>{2}</pre><hr />"\ u"<strong>Operations:</strong><pre>{3}</pre><hr />".format( u"\n".join(enc(repr(x)) for x in session.query(synchmodels.ContentType)), u"\n".join(enc(repr(x)) for x in session.query(synchmodels.Node)), u"\n".join(enc(repr(x)) for x in session.query(synchmodels.Version)), u"\n".join(enc(repr(x)) for x in session.query(synchmodels.Operation)))
def pipeline(self, item): movie = models.Movie(title=item["name"], img_url=item["icon"], download_url=item["url"]) session = models.Session() session.add(movie) session.commit() session.close() print("保存数据成功")
def setUp(self): users = fabfile.load_users() self.user_dict = users[0] self.user = models.User(self.user_dict) self.user.save(test=True) sessions = fabfile.load_sessions() self.session_dict = sessions[0] self.session = models.Session(self.session_dict) self.session.save(test=True)
def _check_order_state(self): session = models.Session() try: if self.current_order.is_bought and self.current_order.is_sold: self.current_order.state = 'done' _logger.info('[TRADER] The order is done!') session.commit() except Exception as e: _logger.error(e) session.rollback()
class Symbol(object): session = models.Session() def get_all(self): query = self.session.query(models.Symbol) return pd.read_sql(query.statement, self.session.bind) def get_all_as_list(self): return self.session.query(models.Symbol).all()
class Exchange(object): session = models.Session() def get_all(self): query = self.session.query(models.Mark) return pd.read_sql(query.statement, self.session.bind) def get_filtert(self,Currency_Pattern="%"): return self.session.execute('SELECT DISTINCT exchange_global_id FROM Marks INNER JOIN Symbols ON marks.id=symbols.mark_id WHERE symbol_global_id like \''+Currency_Pattern+'\' ORDER BY exchange_global_id')
def ewas_gift_list(self): tmpl = env.get_template('ewas_gift_list.html') session = models.Session() ctx = { 'gifts': session.query(models.GiftRequest).join(models.GiftProduct).all() } return tmpl.generate(ctx)
def put(self): session = models.Session() if self.userID in models.query(models.Users.id): query = session.query(models.Users).filter(models.Users.id == str(self.userID)).first() query.forms = str(self.forms) else: session.add(models.Users(id=self.userID, forms=str(self.forms))) session.commit() session.close() return True
def get_ip_rank(cls, phone): with models.Session() as session: day = datetime.date.today() model = PhoneCheckLogModel count = session.query(func.count(distinct(model.ip))).filter(model.phone==phone, model.create_datetime>=day).first()[0] rank = cls.ip_rank_map.get_rank(count) logger.debug("phone access ip count: %s at %s, rank: %s", count, day, rank) return rank return
def generate_grid_cells(grid): """Autogenerate a set of grid cells based on the grid specification. Parameters ---------- grid(Grid): an sqlalchemy orm entity for the target grid """ bbox_shape = to_shape(grid.bounding_box) min_x, min_y, max_x, max_y = bbox_shape.bounds x_range = np.arange(min_x, max_x, grid.cell_width) y_range = np.arange(min_y, max_y, grid.cell_height) grid_cells = pd.DataFrame(index=y_range, columns=x_range) session = models.Session() if len( session.query(models.GridCell).filter( models.GridCell.grid_id == grid.id).limit(2).all()) == 0: cell_mappings = [] cell_queue = Queue.Queue() threads = [] i = 0 for y, r in grid_cells.iterrows(): for x, v in r.iteritems(): t = threading.Thread(target=generate_grid_cell, args=(grid, x, y, cell_queue)) t.start() threads.append(t) i += 1 if i % 1000 == 0: print("Initializing threads: %s%%" % (i / len(grid_cells) * 100)) for t in threads: t.join() cell_queue.put('STOP') cell_mappings = dump_queue(cell_queue) print("Generated %s cells, inserting" % (len(cell_mappings))) for c in cell_mappings: session.add(c) session.flush() cell_queue = Queue.Queue() threads = [] for t in threads: t.join() cell_queue.put('STOP') cell_mappings = dump_queue(cell_queue) print(cell_mappings[0]) print("Generated %s cells, inserting" % (len(cell_mappings))) for c in cell_mappings: session.add(c) session.commit() session.close()
def load_data(): """ Loads data from database """ s = m.Session() id_to_i = {} total_links = {} LIMIT = 13000 # Select top LIMIT nodes ordered by number of inlinks pages = s.query(m.Page)\ .join(m.Link, m.Page.id == m.Link.to_id)\ .group_by(m.Page.id)\ .order_by('COUNT(*) DESC')\ .limit(LIMIT)\ .all() n = len(pages) P = [[0 for _ in xrange(n)] for _ in xrange(n)] print "Generating identity map" cnt = 0 for page in s.query(m.Page).order_by(m.Page.id).limit(LIMIT).all(): id_to_i[page.id] = cnt cnt += 1 linknum = 0 for link in page.outlinks: linknum += link.n total_links[page.id] = linknum print "Identity map generated" "Generating P" for link in s.query(m.Link).all(): if link.from_id in id_to_i and link.to_id in id_to_i: P[id_to_i[link.from_id]][id_to_i[link.to_id]] =\ float(link.n) / total_links[link.from_id] print "P generated" n = len(P) V = np.matrix([1.0 / n for _ in xrange(n)]) print "Closing session..." print "generating matrix" P = np.matrix(P) return P print "Dvocrtica" P = dvocrtica(P, V) print "Doing the pagerank.." res = do_the_pagerank(P, V) V = res['V'] for i in np.nditer(np.argsort(V)): i = int(i) print pages[i].url, V[0, i], pages[i].id s.close()