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()
