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 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 get(self, aid, *args, **kwargs):
a = Activity.get_act_by_id(aid)
if a:
Activity.inc_read_nums_by_id(aid)
self.render('activity.html', **a)
else:
self.write(self.make_result(0, "url invalid", None))
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 post(self, *args, **kwargs):
t = self.get_argument("type", None)
skip = self.get_argument("skip", None)
if skip:
result = Activity.get_more_acts_by_type(t, int(skip))
else:
result = Activity.get_some_acts_by_type(t)
self.write(self.make_result(1, "get acts by club OK", result))
def schedule_activity(self, act: Activity, currentTime: int):
# Se reducen los recursos disponibles
self.resources.reduce_resources(act.resources)
act.reset_activity()
act.active = True
## TODO Create a partial object that records the starttime
act.start = currentTime
return act.end
def test_add_and_get(self):
uid0 = User.add("test1", "password", "*****@*****.**")
bid0 = Board.add("board1", "A")
aid0 = Activity.add(bid0, uid0, "BLABLA")
activity0 = Activity.get(aid0)
assert bid0 == activity0.board_id
assert uid0 == activity0.user_id
assert "BLABLA" == activity0.content
def api_add_activity():
try:
boardid= request.form['board_id']
content = request.form['content']
except KeyError:
return jsonify({'code': 400, 'message': 'Bad Request'})
activity_id = Activity.add(boardid, current_user.id, content)
return jsonify({'code': 200, 'activity_time': Activity.get(activity_id).created_at})
def __schedule_activity(self, act: Activity, currentTime: int):
# Se reducen los recursos disponibles
self.resources.reduce_resources(act.resources)
act.reset_activity()
act.active = True
act.start = currentTime
# Se asigna su duración con un número aleatorio
#act.duration=rand.get_random_duration(act.index)
# Se cacula el momento en que finaliza
act.end = currentTime + act.duration
def log_activity(user_name, activity_type, start_time, end_time):
try:
user = db_session.query(User).filter(User.user_name == user_name).first()
print user.id
activity = Activity(user.id, activity_type, start_time, end_time)
db_session.add(activity)
db_session.flush()
return {"message": "Success", "activity": activity.get_dict()}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def issues_with_user_in_participants(self):
"""
Append issue updated today.
Add all issuses, where current user is participant and
which was changed today
"""
activities = []
issues = self.jira_client.search_issues(
'Participants = currentUser() '
'AND updated > startOfDay() ',
expand='changelog'
)
today = datetime.today().date()
for issue in issues:
changelog = issue.changelog
# Get history (equivalently tab History in jira interface)
for history in changelog.histories:
if (history.author.name != self.username or
parser.parse(history.created).date() < today):
continue
for item in history.items:
if item.field == 'status':
activity = Activity(issue.key, date=history.created)
activity.name = item.toString
activities.append(activity)
# Get comments are left by currentuser
comments = self.jira_client.comments(issue)
for comment in comments:
if (comment.author.name == self.username and
parser.parse(comment.created).date() == today):
activity = Activity(
issue.key,
date=comment.created,
name=STATUS_COMMENTED
)
activities.append(activity)
worklogs = self.jira_client.worklogs(issue)
for worklog in worklogs:
if (worklog.author.name == self.username and
parser.parse(worklog.created).date() == today):
activity = Activity(
issue.key,
date=worklog.created,
name=STATUS_WORKLOG,
worklog=worklog.timeSpentSeconds
)
activities.append(activity)
return 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"})
class Controller:
def __init__(self):
self.activity = Activity()
def create(self, request):
p = Jwt.authHeader(request)
res = json.loads(p)
if res['code'] == 20000:
data = json.loads(request.get_data())
data['creator'] = res['data']['username']
result = self.activity.save(data)
if result == None:
return response({}, code=50000, message='该广告已存在！')
return response({}, code=20000, message='创建成功！')
else:
return p
def getList(self, request):
p = Jwt.authHeader(request)
res = json.loads(p)
if res['code'] == 20000:
result = self.activity.findAll()
return response(result, code=20000, message='获取成功！')
else:
return p
return p
def edit(self, request):
p = Jwt.authHeader(request)
res = json.loads(p)
if res['code'] == 20000:
data = json.loads(request.get_data())
result = self.activity.update_one(data['id'], data)
if result == None:
return response({}, code=50000, message='该广告已存在！')
return response({}, code=20000, message='修改成功！')
else:
return p
def delete(self, request):
p = Jwt.authHeader(request)
res = json.loads(p)
if res['code'] == 20000:
data = json.loads(request.get_data())
result = self.activity.delete(data)
print(type(result))
return response({}, code=20000, message='删除成功！')
else:
return p
def __eval_single_risk(self, activity: Activity):
## 0-1 -> 0.6
prob_risk = random.random()
## riesgo 1 pasa
activity.eval_risk1(prob_risk)
## riesgo 2 se quema
activity.eval_risk2(prob_risk)
## beta: 10 - 12
## duracion original 11
## riesgo 1 pasó
## duracion = duracion + (0.5*11*0.5+ 0*11*0.7)
new_duration = activity.duration + (
activity.risk1 * activity.duration_base +
activity.risk2 * activity.duration_base)
activity.duration = new_duration
def set_best_makespan(self):
## List sorted to get the best end
makespan_sorted = sorted(self.makespan, key=self.get_end, reverse=True)
current_best: Activity = Activity.empty_activity()
current_best.end = 1000000
index_current_best = 0
if not len(self.best_makespan) == 0:
current_best: Activity = self.best_makespan[len(self.best_makespan)
- 1]
new_best: Activity = makespan_sorted[0]
is_better = new_best.end < current_best.end
if is_better:
index: int = self.makespan.index(new_best)
self.best_makespan = copy.deepcopy(self.chromosomes[index].genes)
self.fitness_reference = copy.deepcopy(new_best)
for chromosome in self.chromosomes:
act = max(chromosome.genes, key=self.get_end)
new_fitness = float(new_best.end) / float(act.end)
chromosome.fitness = new_fitness
#print(f'new fitness {new_fitness}')
print('\n\nCurrent best: ')
current_best.print_activity()
print('New best: ')
self.best_makespan[len(self.best_makespan) - 1].print_activity()
print('\n')
def post(self, *args, **kwargs):
url = self.get_argument("url", None)
a = Activity.get_act_by_url(url)
if a:
self.write(self.make_result(1, "get act by url OK", a))
else:
self.write(self.make_result(0, "url invalid", None))
def test_get_comments_by_card_id(self):
uid0 = User.add("test1", "password", "*****@*****.**")
bid0 = Board.add("board1", "A")
bid1 = Board.add("board2", "A")
aid0 = Activity.add(bid0, uid0, "BLABLA")
aid1 = Activity.add(bid0, uid0, "LA")
aid2 = Activity.add(bid1, uid0, "HULA")
activity0 = Activity.get(aid0)
activity1 = Activity.get(aid1)
activity2 = Activity.get(aid2)
assert aid0 in [activity.id for activity in Activity.get_all(bid0)]
assert aid1 in [activity.id for activity in Activity.get_all(bid0)]
assert aid2 not in [activity.id for activity in Activity.get_all(bid0)]
assert aid2 in [activity.id for activity in Activity.get_all(bid1)]
def update(id):
user = User.get_by_id(current_user.id)
if user:
activity = Activity.get_or_none(Activity.id == id)
if activity:
if activity.id == int(id):
params = request.form
activity.is_completed = True if params.get(
"completed") == "on" else False
activity.task = params.get("activity")
activity.completion_date = params.get("date")
if activity.save():
flash("Successfully updated Activity!")
return redirect(
url_for("users.show", username=current_user.username))
else:
flash("Unable to edit!")
return redirect(url_for("schemes.edit", id=activity.id))
else:
flash("Cannot edit more than one activity!")
return redirect(
url_for("users.show", username=current_user.username))
else:
flash("No such activity!")
return redirect(
url_for("users.show", username=current_user.username))
else:
flash("No such user!")
redirect(url_for("home"))
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 delete():
current_user = get_jwt_identity()
user = User.get_or_none(User.username == current_user)
resp = request.get_json()
activity = Activity.get_or_none(Activity.activity == resp['activity'])
user_activity = User_Activity.get_or_none(
(User_Activity.user_id == user.id)
& (User_Activity.activity_id == activity.id))
if user_activity:
if user_activity.delete_instance():
message = {
'status': True,
'message': "Successfully deleted from database"
}
else:
message = {
'status': False,
'message': "Couldn't remove from database"
}
else:
message = {
'status': False,
'message': "The activity submitted is not register with user"
}
return jsonify(message)
def assign_assistant(self, id):
activity = Activity.get_by_id(int(id),
parent=self.get_current_account())
if not activity:
return self.redirect_to('activity.list',
messages.ACTIVITY_NOT_FOUND)
form = AssignAssistantForm(self.request.POST)
if self.request.method == 'POST' and form.validate():
assistant = Assistant.get_by_assistant_id(
form.data['assistant_id'])
if not assistant:
return self.redirect_to('activity.list',
messages.ASSIGN_ASSISTANT_NOT_FOUND)
activity.assistant = assistant
activity.put()
self.session.add_flash(messages.ASSIGN_ASSISTANT_ASSIGN_SUCCESS)
return self.redirect_to('activity.list')
self.session.add_flash(messages.ASSIGN_ASSISTANT_ASSIGN_ERROR,
level='error')
return self.redirect_to('activity.list')
def backgroundjob():
all_user = User.select()
for user in all_user:
print(user.username)
if user:
current_day = date.today()
previous_day = Activity.select().where(
(Activity.completion_date < current_day)).order_by(
Activity.completion_date.desc()).limit(1)
for p in previous_day:
print(p.completion_date)
yesterday = p.completion_date
if yesterday:
from models.dailyrecord import DailyRecord
is_completed = Activity.select().where(
Activity.is_completed == 1,
Activity.completion_date == yesterday,
Activity.user == user.id).count()
print(is_completed)
task = Activity.select().where(
Activity.completion_date == yesterday,
Activity.user == user.id).count()
if task == 0:
print(user.id)
print(task)
completion_rate = 0
title = yesterday
relationship = DailyRecord(title=title,
completion_rate=completion_rate,
user=user.id)
else:
print(user.id)
print(task)
completion_rate = is_completed / task * 100
title = yesterday
relationship = DailyRecord(title=title,
completion_rate=completion_rate,
user=user.id)
if relationship.save():
print('Successfully saved')
else:
print('Something wrong in the code')
else:
print('Query Problem')
else:
print('No such user')
print("done")
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 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 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 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 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 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 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 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'))
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 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 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 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 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 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 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 delete(self, id):
activity = Activity.get_by_id(int(id), parent=self.get_current_account())
if not activity:
self.session.add_flash(messages.ACTIVITY_NOT_FOUND, level='error')
return self.redirect_to('activity.list')
activity.delete()
self.session.add_flash(messages.ACTIVITY_DELETE_SUCCESS)
return self.redirect_to('activity.list')
def render_user(user_id = None):
'''user page'''
user = User.get(long(user_id))
if not user:
return jsonify({'code':404, 'message':'Page Not Found'})
return render_template('profile.html',
tag = 'profile',
user = current_user,
profile_owner = user,
avatar_image = None,
add_board_form = AddBoardForm(),
activities = Activity.get_all_by_user(current_user.id))
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 update_times(self, id):
activity = Activity.get_by_id(int(id), parent=self.get_current_account())
if not activity:
return self.redirect_to('activity.list', messages.ACTIVITY_NOT_FOUND)
form = ActivityTimeForm(self.request.POST, obj=activity)
if self.request.method == 'POST' and form.validate():
form.populate_obj(activity)
activity.put()
self.session.add_flash(messages.ACTIVITY_Times_SUCCESS)
return self.redirect_to('activity.list')
return self.render_to_response('activity/form.haml', {'form': form})
def render_board(board_id = None):
'''board page'''
board=Board.get(board_id)
activity = Activity.get_all(board_id)
try:
show_card_id = request.args['show_card']
except:
show_card_id = -1
if board == None:
return render_template('404.html');
else:
return render_template('board.html',
user=current_user,
board=board,
show_card_id=show_card_id,
lists = board.get_lists(),
activities = activity,
add_card_form = AddCardForm(),
add_list_form = AddListForm(),
edit_card_desc_form = EditCardDescForm(),
add_comment_form = AddCommentForm(),
add_board_form = AddBoardForm())
def assign_assistant(self, id):
activity = Activity.get_by_id(int(id), parent=self.get_current_account())
if not activity:
return self.redirect_to('activity.list', messages.ACTIVITY_NOT_FOUND)
form = AssignAssistantForm(self.request.POST)
if self.request.method == 'POST' and form.validate():
assistant = Assistant.get_by_assistant_id(form.data['assistant_id'])
if not assistant:
return self.redirect_to('activity.list', messages.ASSIGN_ASSISTANT_NOT_FOUND)
activity.assistant = assistant
activity.put()
self.session.add_flash(messages.ASSIGN_ASSISTANT_ASSIGN_SUCCESS)
return self.redirect_to('activity.list')
self.session.add_flash(messages.ASSIGN_ASSISTANT_ASSIGN_ERROR, level='error')
return self.redirect_to('activity.list')
def post(self, *args, **kwargs):
uid = self.get_argument("uid", None)
result = Activity.get_user_collect_acts(uid)
self.write(self.make_result(1, "get user collect acts OK", result))
def get_Activity(self): # This is not at the top to prevent circular imports. from models.activity import Activity return Activity.all().ancestor(self)
def post(self, *args, **kwargs):
cname = self.get_argument("cname", None)
result = Activity.get_all_acts_by_club(cname)
self.write(self.make_result(1, "get acts by club OK", result))
def post(self, *args, **kwargs):
Activity.reset()
self.write(self.make_result(1, "activity reset OK", None))
def post(self, *args, **kwargs):
result = Activity.get_recommend_acts()
self.write(self.make_result(1, "get recommend acts OK", result))
