def get_instance_detail(self, item, instanceid):
item.takeChildren()
current_running_activities = list()
execution_results = self.parent.main_window.kos.root.\
get_executions(
self.parent.main_window.session_id,
self.parent.main_window.token,
self.parent.env,
self.parent.tenant_id,
instanceid
)
if isinstance(execution_results, int):
if execution_results == -1:
# token失效
self.tree_analysis_results.collapseItem(item)
self.parent.main_window.set_enabled_cascade(False)
self.parent.main_window.login_window.show()
return
elif execution_results:
for e in execution_results:
current_running_activities.append(e['ActivityID'])
activity_results = self.parent.main_window.kos.root.\
get_activities(
self.parent.main_window.session_id,
self.parent.main_window.token,
self.parent.env,
instanceid,
self.parent.tenant_id
)
if isinstance(activity_results, int):
if activity_results == -1:
# token失效
self.tree_analysis_results.collapseItem(item)
self.parent.main_window.set_enabled_cascade(False)
self.parent.main_window.login_window.show()
return
elif activity_results:
dict_activities = {0: item}
for a in activity_results:
item_prev_activity = dict_activities[a['PrevActivityID']]
item_activity = QtWidgets.QTreeWidgetItem(item_prev_activity)
item_activity.setText(0, a['Name'])
if a['ActivityID'] in current_running_activities:
item_activity.setIcon(0, QtGui.QIcon('images/running.svg'))
activity_data = Activity(a['ActivityID'], a['ActivityDefID'],
a['ExecutionID'], a['ProcDefID'],
a['CallProcInstID'], a['TaskID'])
item_activity.setData(0, QtCore.Qt.UserRole, activity_data)
item_activity.setText(1, a['ActivityType'])
item_activity.setText(2, str(a['Created']))
item_activity.setText(3, str(a['Modified']))
item_activity.setData(4, QtCore.Qt.BackgroundRole,
self.status_brush[a['Status']]['brush'])
dict_activities[a['ActivityID']] = item_activity
self.expand_children(item)
else:
# 找不到变量
item_activity = QtWidgets.QTreeWidgetItem(item)
item_activity.setText(0, '(无)')
self.expand_children(item)
def main():
args = parse_args(sys.argv[1:])
config = load_config(args.config_file_path)
client = config.client.create_client()
with psycopg2.connect(config.database.connection_string) as conn_activity, \
psycopg2.connect(config.database.connection_string) as conn_db:
activity = Activity(conn=conn_activity,
activity_type='check_completed',
run_at=datetime.now(tz=local_tz))
db = DB(conn=conn_db,
completion_registry_thread_id=config.completion_registry_thread_id)
stats = Stats()
message = None
is_successful = True
try:
scan_finished_threads(db, client, stats)
except:
exc_text = traceback.format_exc()
logging.critical(exc_text)
message = exc_text
is_successful = False
finally:
activity.report_end(is_successful, message, stats)
if is_successful:
logging.info("成功结束")
else:
exit(1)
def create(self):
form = ActivityForm(self.request.POST)
if self.request.method == 'POST' and form.validate():
if Activity.get_by_activity_id(form.data['activity_id']):
self.session.add_flash(messages.ACTIVITY_EXISTS, level='error')
return self.render_to_response('activity/form.haml',
{'form': form})
activity = Activity(activity_id=form.data['activity_id'],
course_code=form.data['course_code'],
activity_type=form.data['activity_type'],
day=form.data['day'],
time=form.data['time'],
room=form.data['room'],
parent=self.get_current_account())
activity.put()
self.session.add_flash(messages.ACTIVITY_CREATE_SUCCESS,
level='info')
return self.redirect_to('activity.list')
self.session.add_flash(messages.ACTIVITY_CREATE_ERROR, level='error')
return self.redirect_to('activity.list')
def main():
args = parse_args(sys.argv[1:])
config = load_config(args.config_file_path)
with psycopg2.connect(config.database.connection_string) as conn_activity, \
psycopg2.connect(config.database.connection_string) as conn_db:
activity = Activity(conn=conn_activity,
activity_type='collect',
run_at=datetime.now(tz=local_tz))
db = DB(conn=conn_db,
completion_registry_thread_id=config.completion_registry_thread_id)
stats = Stats()
fetching_since = activity.should_collect_since
is_successful = False
message = None
try:
fetch_board(db=db, activity=activity, client=config.client.create_client(),
board_id=config.board_id, fetching_since=fetching_since, stats=stats)
is_successful = True
except:
exc_text = traceback.format_exc()
logging.critical(exc_text)
message = exc_text
finally:
activity.report_end(is_successful, message, stats)
if is_successful:
logging.info("成功结束")
else:
exit(1)
def select(id):
sql = 'SELECT * FROM activities WHERE id = %s'
values = [id]
results = run_sql(sql, values)[0]
trainer = trainer_repository.select(results['trainer_id'])
activity = Activity(results['name'], results['date'], results['time'],
trainer, results['capacity'], results['id'])
return activity
def show_upcoming_activities():
upcoming = []
sql = "SELECT * FROM activities WHERE finished = False"
results = run_sql(sql)
for row in results:
activity = Activity(row['name'], row['venue'], row['category'], row['capacity'], row['finished'], row['offpeak'], row['id'])
upcoming.append(activity)
return upcoming
def create_activity():
name = request.form["name"]
photo = request.files["photo"].filename
trainer = request.form["trainer"]
activity = Activity(name, photo, trainer)
activity_repository.save(activity)
return redirect('/activities')
def select_all():
activities = []
sql = "SELECT * FROM activities"
results = run_sql(sql)
for row in results:
activity = Activity(row['name'], row['photo'], row['trainer'],
row['id'])
activities.append(activity)
return activities
def create_activity():
name = request.form['name']
date = request.form['date']
time = request.form['time']
trainer = trainer_repository.select(request.form['trainer'])
capacity = request.form['capacity']
activity = Activity(name, date, time, trainer, capacity)
activity_repository.save(activity)
return redirect("/activities")
def update_activity(id):
name = request.form['name']
date = request.form['date']
time = request.form['time']
capacity = request.form['capacity']
trainer = trainer_repository.select(request.form['trainer_id'])
activity = Activity(name, date, time, trainer, capacity, id)
activity_repository.update(activity)
return redirect("/activities")
def select(id):
activity = None
sql = "SELECT * FROM activities WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
activity = Activity(result['name'], result['venue'], result['category'], result['capacity'], result['finished'], result['offpeak'], result['id'])
return activity
def select_all():
activities = []
sql = 'SELECT * FROM activities'
results = run_sql(sql)
for row in results:
trainer = trainer_repository.select(row['trainer_id'])
activity = Activity(row['name'], row['date'], row['time'], trainer,
row['capacity'], row['id'])
activities.append(activity)
return activities
def update_activity(id):
name = request.form["name"]
venue = request.form["venue"]
category = request.form["category"]
capacity = request.form["capacity"]
finished = request.form["finished"]
offpeak = request.form["offpeak"]
activity = Activity(name, venue, category, capacity, finished, offpeak, id)
activity_repository.update(activity)
return redirect("/activities")
def create_activity():
name = request.form["name"]
venue = request.form["venue"]
category = request.form["category"]
capacity = request.form["capacity"]
finished = request.form["finished"]
offpeak = request.form["offpeak"]
new_activity = Activity(name, venue, category, capacity, finished, offpeak)
activity_repository.save(new_activity)
return redirect("/activities")
def test_activity(self):
date = datetime.datetime(2019, 12, 10, 12, 10)
activity = Activity('1', ['1234', '5678'], date.date(), date.time(),
'test')
self.assertEqual(activity.uid, '1')
self.assertEqual(activity.persons_uids, ['1234', '5678'])
self.assertEqual(activity.date, date.date())
self.assertEqual(activity.time, date.time())
self.assertEqual(activity.description, 'test')
def select_all():
activities = []
sql = "SELECT * FROM activities"
results = run_sql(sql)
for row in results:
activity = Activity(row['name'], row['venue'], row['category'], row['capacity'], row['finished'], row['offpeak'], row['id'])
activities.append(activity)
return activities
def create_activity():
activity_name = request.form["name"]
try:
upcoming = request.form["upcoming"]
except:
upcoming = False
new_activity = Activity(activity_name, upcoming)
activity_repository.save(new_activity)
return redirect("/activities")
def select(id):
activity = None
sql = "SELECT * FROM activities WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
activity = Activity(result['name'], result['photo'], result['trainer'],
result['id'])
return activity
def activities(id):
activities = []
sql = 'SELECT * FROM activities WHERE trainer_id = %s'
values = [id]
results = run_sql(sql, values)
for row in results:
trainer = select(id)
activity = Activity(row['name'], row['date'], row['time'], trainer,
row['id'])
activities.append(activity)
return activities
def execute(self):
person: Person = self.outer_instance._person_repository.remove_item(uid=self.uid)
activities = self.outer_instance._activity_repository.get_items(lambda a: person.uid in a.persons_uids)
self.count = len(activities)
for i, activity in enumerate(activities):
new_uids = activity.persons_uids.copy()
new_uids.remove(person.uid)
new_activity = Activity(activity.uid, new_uids, activity.date, activity.time, activity.description)
self.outer_instance._activity_repository.replace_item(new_activity, uid=activity.uid)
def update_activity(id):
name = request.form["name"]
# upcoming = request.form["upcoming"]
try:
upcoming = request.form["upcoming"]
except:
upcoming = False
activity = Activity(name, upcoming, id)
activity_repository.update(activity)
return redirect('/activities')
def crawl(self):
r = Reddit()
db = DbInteract()
user = r.conn.redditor(self.id)
activity = []
for comment in list(user.comments.new(limit=None)):
activity.append(
Activity(
comment.subreddit_id, comment.author.id, 'comment',
datetime.datetime.fromtimestamp(
comment.created_utc).isoformat()))
for submission in list(user.submissions.new(limit=None)):
activity.append(
Activity(
submission.subreddit.id, submission.author.id,
'submission',
datetime.datetime.fromtimestamp(
submission.created_utc).isoformat()))
db.add_activity_records(activity)
def update_activity(id):
name = request.form["name"]
photo = request.files["photo"].filename
if photo == '':
activity = activity_repository.select(id)
photo = activity.photo
trainer = request.form["trainer"]
activity = Activity(name, photo, trainer, id)
activity_repository.update(activity)
return redirect("/activities")
def create():
user_id = get_jwt_identity()
current_user = User.get_or_none(User.id == user_id)
if current_user:
params = request.json
new_activity = Activity(task=params.get('activity'),
completion_date=params.get('date'),
user=current_user.id)
if new_activity.save():
return jsonify({"message": "Activity added successfully"})
else:
return jsonify({"message": "Activity failed to add"})
else:
return jsonify({"message": "No such user"})
def parse_additional_activities(activities_page):
try:
activities_raw = [
[cell.text for cell in row("td")]
for row in BeautifulSoup(activities_page.content, features="lxml")("tr", "even")
]
activities = [
Activity(*[field for field in activity_raw]).__dict__
for activity_raw in activities_raw
]
except:
activities = None
return activities
def migrate_activity_table(conn_s3: sqlite3.Connection,
conn_pg: psycopg2._psycopg.connection):
n = count_rows(conn_s3, 'activity')
last_fetched_until: datetime = None
for i, [
_, # id,
run_at,
fetched_since,
ensured_fetched_until,
is_successful,
message,
uploaded_bytes,
downloaded_bytes,
newly_recorded_thread_count,
affected_thread_count,
newly_recorded_post_count,
requested_board_page_count,
requested_thread_page_count,
logged_in_thread_request_count,
] in enumerate(conn_s3.execute(r'SELECT * FROM activity')):
activity = Activity(conn=conn_pg,
activity_type='legacy',
run_at=ts2dt(run_at),
logger=None)
if last_fetched_until is None:
assert (Activity.never_collected(conn=conn_pg))
assert (activity.should_collect_since)
else:
assert (not Activity.never_collected(conn=conn_pg))
assert (activity.should_collect_since == last_fetched_until)
activity.report_collecting_range(since=ts2dt(fetched_since),
until=ts2dt(ensured_fetched_until))
if ensured_fetched_until and is_successful:
last_fetched_until = ts2dt(ensured_fetched_until)
stats = Stats()
stats.new_thread_count = newly_recorded_thread_count
stats.affected_thread_count = affected_thread_count
stats.new_post_count = newly_recorded_post_count
stats.board_request_count = requested_board_page_count
stats.thread_request_count = requested_thread_page_count
stats.logged_in_thread_request_count = logged_in_thread_request_count
stats.total_bandwidth_usage.add([uploaded_bytes, downloaded_bytes])
activity.report_end(is_successful=bool(is_successful),
message=message,
stats=stats)
if i % 100 == 0:
print(f"activity: {i+1}/{n} {ts2dt(run_at)}")
def get_activity(self, id):
try:
with dbapi2.connect(self.url) as connection:
cursor = connection.cursor()
statement = "SELECT id, name, description FROM activities WHERE id = %s"
data = [id]
cursor.execute(statement, data)
value = cursor.fetchone()
cursor.close()
if not value:
return None
activity = Activity(value[0], value[1], value[2])
return activity
except Exception as err:
print("Get activity error: ", err)
return None
def add_activity(activity: ActivityModel,
merchant_id: int = Depends(get_login_merchant),
session: Session = Depends(create_session)):
"""
新建营销活动\n
:param activity: 活动信息\n
:return:
"""
ret_code = 0
ret_msg = "success"
try:
cur_merchant = json.loads(redis_client.hget("merchants", merchant_id))
if cur_merchant["merchant_type"] != 0:
session.commit()
return make_response(-1, "权限不足!")
now = datetime.now()
act = Activity(activity.act_name, activity.act_cover,
activity.begin_time, activity.end_time, now, now)
session.add(act)
# 活动存入redis并添加商品折扣表
activity_key = f"activity_{act.id}"
discount_key = f"discount_of_activity_{act.id}"
expire_time = (activity.end_time - now).seconds
pipe = redis_client.pipeline(transaction=True)
pipe.set(activity_key,
json.dumps(act.to_dict(), cls=JsonEncoder),
ex=expire_time)
# 创建一个空的商品折扣表, 插入一条空数据占位符
pipe.hset(discount_key, "", "")
pipe.expire(discount_key, expire_time)
pipe.execute()
logger.info("活动redis信息初始化成功!")
session.commit()
logger.info(f"新建营销活动成功，活动id: {act.id}")
except Exception as e:
session.rollback()
logger.error(str(e))
ret_code = -1
ret_msg = str(e)
return make_response(ret_code, ret_msg)
def input_activity(self, uid: str):
date_raw = input('Input activity date (yyyy-mm-dd): ')
time_raw = input('Input activity time (HH:MM:')
date = None
if date_raw != '':
date = datetime.datetime.strptime(date_raw, '%Y-%m-%d').date()
time = None
if time_raw != '':
time = datetime.datetime.strptime(time_raw, '%H:%M').time()
description = input('Input activity description: ')
persons_uids = input(
'Input activity persons: <uid_1>,<uid_2>,...\n').split(',')
return Activity(uid, persons_uids, date, time, description)
def create():
print("HELLO")
user = User.get_by_id(current_user.id)
if user:
new_activity = Activity(task=request.form['activity'],
completion_date=request.form['date'],
user=current_user.id)
if new_activity.save():
flash("Activity has been succesfully added!")
return redirect(
url_for('users.show', username=current_user.username))
else:
flash("Not added!")
return render_template('schemes/new.html',
completion_date=request.form['date'],
errors=new_activity.errors)
else:
flash("No such user")
return redirect(url_for('home'))
