def prepareForProjectDataTable(self):
"""
为实验项目数据表格
:return:
"""
def _arrangeProjectDatas(_data_collection):
_middle_arrange = {}
for _raw_data in _data_collection:
if not _raw_data.row_id in _middle_arrange:
_middle_arrange[_raw_data.row_id] = {}
_middle_arrange[_raw_data.row_id].setdefault(_raw_data.label, _raw_data)
for _middle_data in _middle_arrange:
for _property in properties:
if not _property.label in _middle_arrange[_middle_data]:
_middle_arrange[_middle_data][_property.label] = None
return _middle_arrange
# TODO 组合项目数据表格，使body和head对应
pid, = self.requestParams("pid")
if self.checkParamsAvailable(pid):
project = db_session.query(Project).filter(Project.id==pid).first()
if project is not None:
project_data = {}
properties = db_session.query(ProjectProperty).filter(ProjectProperty.p_id==pid).all()
data_records = db_session.query(ProjectItem).filter(ProjectItem.proj_id==pid).all()
project_data.setdefault('project', project)
project_data.setdefault('properties', properties)
project_data.setdefault('records', _arrangeProjectDatas(data_records))
self.setData(project_data)
self.changeResponse2Success()
else:
self.setFailureReason("实验项目不存在！")
def update_account(request):
data = json.loads(request.data) if request.data else None
if not data:
return jsonify(error = True, message = "request data not provided")
if 'displayname' not in data:
return jsonify(error = True, message = "displayname not provided in request data")
if 'email' not in data:
return jsonify(error = True, message = "email not provided in request data")
displayname = cgi.escape( data['displayname'] )
email = cgi.escape( data['email'] )
if not displayname:
return jsonify(error = True, message = "displayname must have value")
you = db_session.query(Users).filter_by(id = user_session['you_id']).one()
you.displayname = displayname
if you.email != email:
check_email = db_session.query(Users).filter_by(email = email).first()
if check_email:
return jsonify(error = True, message = "Email is already in use")
you.email = email
db_session.add(you)
db_session.commit()
return jsonify(message = "Account Updated!", you = you.serialize)
def check_booking_request(request, sse, event_id, account_id):
your_id = user_session['account_id']
if account_id == your_id:
return jsonify(
error=True,
message=
'forbidden: provided account_id is equal to current account_id')
event = db_session.query(Events).filter_by(id=event_id).first()
if event == None:
return jsonify(error=True,
message='no event found by id: ' + str(event_id))
if event.host_id != your_id and event.host_id != account_id:
return jsonify(error=True,
message='none of the two accounts own this event')
booking_request = db_session.query(EventRequests) \
.filter(EventRequests.event_id == event_id) \
.filter( (EventRequests.sender_id == your_id) | (EventRequests.receiver_id == your_id) ) \
.filter( (EventRequests.sender_id == account_id) | (EventRequests.receiver_id == account_id) ) \
.first()
if booking_request:
return jsonify(message='booking request exists',
booking_request_exists=True,
booking_request=booking_request.serialize)
else:
return jsonify(message='no booking request exists',
booking_request_exists=False)
def get_conversation_messages(request, sse, c_id, cm_id):
try:
if cm_id == 0:
conversation_messages = db_session.query(ConversationMessages) \
.filter(ConversationMessages.conversation_id == c_id) \
.order_by(desc(ConversationMessages.date_created)) \
.limit(5) \
.all()
else:
conversation_messages = db_session.query(ConversationMessages) \
.filter(ConversationMessages.conversation_id == c_id) \
.filter(ConversationMessages.id < cm_id) \
.order_by(desc(ConversationMessages.date_created)) \
.limit(5) \
.all()
return jsonify(message='conversation messages',
conversation_messages=[
cm.serialize for cm in conversation_messages
])
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
def get_event_comments(request, sse, event_id, comment_id):
try:
if comment_id == 0:
event_comments = db_session.query(EventComments) \
.filter(EventComments.event_id == event_id) \
.order_by(desc(EventComments.date_created)) \
.limit(5) \
.all()
else:
event_comments = db_session.query(EventComments) \
.filter(EventComments.event_id == event_id) \
.filter(EventComments.id < comment_id) \
.order_by(desc(EventComments.date_created)) \
.limit(5) \
.all()
return jsonify(message='event comments',
event_comments=[ec.serialize for ec in event_comments])
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
def get_event_likes(request, sse, event_id, like_id):
try:
if like_id == 0:
likes = db_session.query(EventLikes) \
.filter(EventLikes.event_id == event_id) \
.order_by(desc(EventLikes.date_created)) \
.limit(5) \
.all()
else:
likes = db_session.query(EventLikes) \
.filter(EventLikes.event_id == event_id) \
.filter(EventLikes.id < like_id) \
.order_by(desc(EventLikes.date_created)) \
.limit(5) \
.all()
return jsonify(message='event likes',
likes=[l.serialize for l in likes])
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
def get_event_attending(request, sse, event_id, attend_id):
try:
if attend_id == 0:
attending = db_session.query(EventAttendees) \
.filter(EventAttendees.event_id == event_id) \
.order_by(desc(EventAttendees.date_created)) \
.limit(5) \
.all()
else:
attending = db_session.query(EventAttendees) \
.filter(EventAttendees.event_id == event_id) \
.filter(EventAttendees.id < attend_id) \
.order_by(desc(EventAttendees.date_created)) \
.limit(5) \
.all()
return jsonify(message='event attending',
attending=[a.serialize for a in attending])
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
async def channel_ignore_list(self, ctx: Context):
ignored_channels = [
f" • {c.mention}" for c in ctx.guild.text_channels
if c.id in list(db_session.query(IgnoredChannel).all())
]
mini_karma_channels = [
f" • {c.mention}" for c in ctx.guild.text_channels
if c.id in (list(db_session.query(MiniKarmaChannel).all()))
]
message = []
if ignored_channels:
message += ["Ignored channels:"] + ignored_channels
if ignored_channels and mini_karma_channels:
message.append("")
if mini_karma_channels:
message += ["", "Mini-karma Channels:"] + mini_karma_channels
if message:
await ctx.send("\n".join(message))
else:
await ctx.send("No channels are ignored or on mini-karma mode.")
def update_booking_email(request, sse):
try:
data = json.loads(request.data)
if not data:
return jsonify(error=True,
message='request body is empty, check headers/data')
booking_email = str(data['booking_email']).encode()
check_email = db_session.query(Accounts).filter_by(
booking_email=booking_email).first()
if check_email:
return jsonify(error=True,
message='booking account email is already in use')
you = db_session.query(Accounts).filter_by(
id=user_session['account_id']).one()
you.booking_email = booking_email
db_session.add(you)
db_session.commit()
return jsonify(account=you.serialize,
message='Booking Email Updated Successfully!')
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
def handleRegister(self):
"""
处理用户注册
:return:
"""
name, email, pwd = self.postParams('name', 'email', 'pwd')
if self.checkParamsAvailable(email, pwd):
exists_query = db_session.query(User).filter(User.email==email).exists()
if not db_session.query(exists_query).scalar():
try:
set_user = User()
set_user.name = name
set_user.email = email
set_user.salt = User.genSalt()
set_user.pwd = User.genPassword(pwd, set_user.salt)
set_user.reg_ip = str(request.remote_addr)
db_session.add(set_user)
db_session.commit()
self.changeResponse2Success()
mailer = getMailSender()
mailer.setMailtoList([email])
mailer.setSubject("感谢注册 [史前-在线定量研究工具]")
_mail_content = render_template("noticer/email/_register.html", nickname=name)
mailer.setContent(_mail_content)
mailer.send()
except Exception as e:
db_session.rollback()
self.setFailureReason(str(e))
else:
self.setFailureReason("该邮箱已经被注册，请更换邮箱申请或尝试找回密码！")
def toggle_comment_like(request, sse, comment_id):
comment = db_session.query(EventComments).filter_by(id=comment_id).first()
if not comment:
return jsonify(error=True, message='comment not found')
like = db_session.query(CommentLikes) \
.filter_by(comment_id = comment_id) \
.filter_by(owner_id = user_session['account_id']) \
.first()
if like:
db_session.delete(like)
check_notification = db_session.query(Notifications) \
.filter(Notifications.action == ACTION_TYPES['COMMENT_LIKE']) \
.filter(Notifications.target_type == TARGET_TYPES['COMMENT']) \
.filter(Notifications.target_id == like.comment_id) \
.filter(Notifications.from_id == user_session['account_id']) \
.filter(Notifications.account_id == like.comment_rel.owner_id) \
.first()
if check_notification:
db_session.delete(check_notification)
db_session.commit()
return jsonify(message='unliked', liked=False)
else:
like = CommentLikes(comment_id=comment_id,
owner_id=user_session['account_id'])
db_session.add(like)
db_session.commit()
if like.comment_rel.owner_id != user_session['account_id']:
you = db_session.query(Accounts).filter_by(
id=user_session['account_id']).one()
message = you.username + ' liked your comment: ' + like.comment_rel.text
new_notification = Notifications(
action=ACTION_TYPES['COMMENT_LIKE'],
target_type=TARGET_TYPES['COMMENT'],
target_id=like.comment_id,
from_id=user_session['account_id'],
account_id=like.comment_rel.owner_id,
message=message,
link='/event/' + str(like.comment_rel.event_rel.id))
db_session.add(new_notification)
db_session.commit()
sse.publish(
{
"message": message,
"for_id": like.comment_rel.owner_id
},
type='action')
return jsonify(message='liked', liked=True)
def handleRemoveGeopointGroup(self):
"""
删除指定的整个地理坐标集合
需要校验地理坐标集合是否属于操作者本人
:return:
"""
gid, pwd = self.postParams("gid", "pwd")
if self.checkParamsAvailable(gid, pwd):
if self.userIdentification(pwd):
current_user = UserIdentify()
geo_group_info = db_session.query(GeoPointGroup).filter(GeoPointGroup.id==gid).first()
if geo_group_info is not None:
if (geo_group_info.u_id == current_user.uid):
try:
# 删除集合下的所有观察子节点
db_session.query(GeoPointUnit).filter(GeoPointUnit.group_id==gid).delete()
db_session.delete(geo_group_info)
db_session.commit()
self.changeResponse2Success()
except Exception as e:
self.setFailureReason(str(e), redirect_url=url_for(".ViewGeoGroup", gid=gid))
else:
self.setFailureReason("该地理坐标点位集合不属于您，无法执行删除操作！", redirect_url=url_for(".ViewGeoGroup", gid=gid))
else:
self.setFailureReason("指定的地理坐标点位集合不存在！", redirect_url=url_for(".ViewGeoGroup", gid=gid))
else:
self.setFailureReason("对不起，您不具备执行当前操作的权限！", redirect_url=url_for(".ViewGeoGroup", gid=gid))
def rest_endpoint_handler():
id = request.args.get('id')
if id is not None:
user = db_session.query(UsersModel).filter(UsersModel.id == id).first()
followers = db_session.query(
FollowsModel.follow_by).filter(FollowsModel.follow_to == id).all()
d = dict()
d['firstName'] = user.firstName
d['lastName'] = user.lastName
d['username'] = user.username
d['email'] = user.email
l = list()
for follower in followers:
l.append('/rest/user/?id=' + str(follower[0]))
d['followers'] = l
return jsonify(resultSet=d)
else:
users = db_session.query(UsersModel).filter().all()
l1 = list()
for user in users:
followers = db_session.query(FollowsModel.follow_by).filter(
FollowsModel.follow_to == user.id).all()
d = dict()
d['firstName'] = user.firstName
d['lastName'] = user.lastName
d['username'] = user.username
d['email'] = user.email
l = list()
for follower in followers:
l.append('/rest/user/?id=' + str(follower[0]))
d['followers'] = l
l1.append(d)
return jsonify(resultSet=l1)
async def add(self, ctx: Context, item: str):
author_id = (
db_session.query(User)
.filter(User.user_uid == ctx.message.author.id)
.first()
.id
)
if (
not db_session.query(BlockedKarma)
.filter(BlockedKarma.topic == item.casefold())
.all()
):
blacklist = BlockedKarma(topic=item.casefold(), user_id=author_id)
db_session.add(blacklist)
try:
db_session.commit()
await ctx.send(f"Added {item} to the karma blacklist. :pencil:")
except (ScalarListException, SQLAlchemyError):
db_session.rollback()
await ctx.send(
f"Something went wrong adding {item} to the karma blacklist. No change has occurred"
)
else:
await ctx.send(
f"{item} is already in the karma blacklist. :page_with_curl:"
)
def validate_timestamp_and_nonce(self,
client_key,
timestamp,
nonce,
request_token=None,
access_token=None):
filters = [
Nonce.nonce == nonce, Nonce.timestamp == timestamp,
Client.id == Nonce.client_id, Client.client_key == client_key
]
if request_token:
filters.extend([
RequestToken.id == Nonce.request_token_id,
RequestToken.token == request_token
])
if access_token:
filters.extend([
AccessToken.id == Nonce.access_token_id,
AccessToken.token == access_token
])
try:
db_session.query(Nonce, Client,
ResourceOwner).filter(*filters).one()
return False
except NoResultFound:
return True
def handleUpdateProjectDataRecord(self):
'''
更新研究项目中的一行数据
:return:
'''
_data_dict = self.postParams("*")
if "pid" in _data_dict and "row_id" in _data_dict:
try:
project_id = int(_data_dict.get("pid", 0))
row_id = _data_dict.get("row_id", '')
except Exception:
project_id = 0
if project_id > 0 and '' != row_id:
try:
db_session.query(ProjectItem).filter(ProjectItem.proj_id==project_id).filter(ProjectItem.row_id==row_id).delete()
for _d in _data_dict:
if "pid" != _d and "row_id" != _d:
pproperty_item = db_session.query(ProjectProperty).filter(ProjectProperty.label==_d).first()
if pproperty_item is not None:
p_item = ProjectItem()
p_item.label = _d
p_item.value = _data_dict[_d]
p_item.row_id = row_id
p_item.proj_id = project_id
p_item.p_id = pproperty_item.id
db_session.add(p_item)
db_session.commit()
self.changeResponse2Success()
except Exception as e:
db_session.rollback()
self.setFailureReason(str(e))
else:
self.setFailureReason('缺少关键参数！')
def update_username(request, sse):
try:
data = json.loads(request.data)
if not data:
return jsonify(error=True,
message='request body is empty, check headers/data')
username = str(data['username']).encode()
check_username = db_session.query(Accounts).filter_by(
username=username).first()
if check_username:
return jsonify(error=True, message='username is already in use')
you = db_session.query(Accounts).filter_by(
id=user_session['account_id']).one()
you.username = username
db_session.add(you)
db_session.commit()
return jsonify(account=you.serialize,
message='Username Updated Successfully!')
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
def search_events(request, sse, search_type, search_query):
try:
search_type = str(search_type).encode().lower()
types = set(['location', 'category'])
if search_type not in types:
return jsonify(error=True,
message='search type is unknown/invalid: ' +
search_type)
search_query = str(search_query).encode().lower().replace(
'_space_', ' ').replace('%20', ' ')
query = '%' + str(cgi.escape(search_query)).encode().lower() + '%'
if search_type == 'location':
events = db_session.query(Events) \
.filter( func.lower(Events.location).like( query ) ) \
.order_by(func.random()) \
.limit(10).all()
if search_type == 'category':
events = db_session.query(Events) \
.filter( func.lower(Events.categories).like( query ) ) \
.order_by(func.random()) \
.limit(10).all()
return jsonify(message='events',
events=[e.serialize_small for e in events])
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error processing...')
async def listf(self, ctx: Context, *filter: clean_content):
# If there is a search filter then use it
if filter:
filter_str = str(filter[0])
filaments = (db_session.query(FilamentType).filter(
FilamentType.name.ilike(f"%{filter_str}%")).order_by(
FilamentType.name).all())
else:
filaments = db_session.query(FilamentType).order_by(
FilamentType.name).all()
if filaments:
# Format the list nicely
filament_list = "\n".join(
map(lambda x: f" • **{x.name}** - £{x.cost}/kg", filaments))
if len(filament_list) > 1:
await ctx.send(f"Our current filaments:\n{filament_list}")
else:
await ctx.send(f"Our current filament:\n{filament_list}")
else:
if filter:
await ctx.send(
f'There are no filaments that match "{str(filter[0])}"')
else:
await ctx.send("There are no filaments currently listed")
async def reminder_check(bot):
await bot.wait_until_ready()
while not bot.is_closed():
now = datetime.now()
# I have this useless variable because its not pep8 if you compare directly to False lol
not_triggered = False
reminders = (
db_session.query(Reminder)
.filter(Reminder.trigger_at <= now, Reminder.triggered == not_triggered)
.all()
)
for r in reminders:
if r.irc_name:
display_name = r.irc_name
else:
author_uid = (
db_session.query(User).filter(User.id == r.user_id).first().user_uid
)
display_name = f"<@{author_uid}>"
channel = bot.get_channel(r.playback_channel_id)
message = f"Reminding {display_name}: " + r.reminder_content
await channel.send(message)
r.triggered = True
db_session.commit()
await asyncio.sleep(CONFIG.REMINDER_SEARCH_INTERVAL)
def deleteById(object, item_id):
try:
db_session.query(type(object)).filter_by(id=item_id).delete()
db_session.commit()
except:
db_session.rollback()
finally:
closeDbSession()
async def remove(self, ctx: Context, item: str):
if not db_session.query(BlockedKarma).filter(BlockedKarma.topic == item.casefold()).all():
await ctx.send(f'{item} is not in the karma blacklist. :page_with_curl:')
else:
db_session.query(BlockedKarma).filter(BlockedKarma.topic == item.casefold()).delete()
db_session.commit()
await ctx.send(f'{item} has been removed from the karma blacklist. :wastebasket:')
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
schedule = db_session.query(ScheduleModel).filter_by(id=data['id'])
schedule.update(data)
db_session.commit()
schedule = db_session.query(ScheduleModel).filter_by(id=data['id']).first()
return UpdateSchedule(schedule=schedule)
def loadPropertiesOfProject(self, pid):
"""
读取指定id项目下的字段属性列表
:param pid:
:return:
"""
project_exists = db_session.query(Project).filter(Project.id==pid).exists()
return db_session.query(ProjectProperty).filter(ProjectProperty.p_id==pid).all() \
if db_session.query(project_exists).scalar() else []
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
message = db_session.query(MessageModel).filter_by(id=data['id'])
message.update(data)
db_session.commit()
message = db_session.query(MessageModel).filter_by(id=data['id']).first()
return UpdateMessage(message=message)
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
relationship = db_session.query(RelationshipModel).filter_by(id=data['id'])
relationship.update(data)
db_session.commit()
relationship = db_session.query(RelationshipModel).filter_by(id=data['id']).first()
return UpdateRelationship(relationship=relationship)
def validate_verifier(self, client_key, resource_owner_key, verifier):
try:
db_session.query(RequestToken, Client).filter(
Client.client_key == client_key,
RequestToken.token == resource_owner_key,
RequestToken.verifier == verifier).one()
return True
except NoResultFound:
return False
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
doctor = db_session.query(DoctorModel).filter_by(id=data['id'])
doctor.update(data)
db_session.commit()
doctor = db_session.query(DoctorModel).filter_by(id=data['id']).first()
return UpdateDoctor(doctor=doctor)
async def channel_ignore(self,
ctx: Context,
channel: TextChannel,
mode: ChannelIgnoreMode.get = None):
ignored_channel = (db_session.query(IgnoredChannel).filter(
IgnoredChannel.channel == channel.id).first())
if mode == ChannelIgnoreMode.Ignore:
if ignored_channel is None:
# Create a new entry
user = (db_session.query(User).filter(
User.user_uid == ctx.author.id).first())
new_ignored_channel = IgnoredChannel(
channel=channel.id,
user_id=user.id,
)
db_session.add(new_ignored_channel)
try:
db_session.commit()
await ctx.send(
f"Added {channel.mention} to the ignored list.")
except SQLAlchemyError as e:
db_session.rollback()
logging.error(e)
await ctx.send(
"Something went wrong. No change has occurred.")
else:
# Entry already present
await ctx.send(f"{channel.mention} is already ignored!")
elif mode == ChannelIgnoreMode.Watch:
if ignored_channel is not None:
# Remove the entry
db_session.query(IgnoredChannel).filter(
IgnoredChannel.channel == channel.id).delete()
try:
db_session.commit()
await ctx.send(
f"{channel.mention} is no longer being ignored.")
except SQLAlchemyError as e:
db_session.rollback()
logging.error(e)
await ctx.send(
"Something went wrong. No change has occurred.")
else:
# The entry is not present
await ctx.send(
f"{channel.mention} is not currently being ignored.")
else:
# Report status
if ignored_channel is not None:
await ctx.send(f"{channel.mention} is currently being ignored."
)
else:
await ctx.send(
f"{channel.mention} is not currently being ignored")
def post():
title = u'文章列表'
posts = db_session.query(Article).order_by(
Article.data_publish.desc()).all()
authors = db_session.query(User.id, User.username).all()
db_session.close()
return render_template('articles.html',
posts=posts,
title=title,
authors=authors)
def show_post(p_id):
title = u'文章详情'
# p_id = request.args.get('p_id')
posts = (db_session.query(Article).filter(Article.id == p_id).first())
author = db_session.query(User.username).filter(
Article.user_id == User.id, Article.id == p_id).first()[0]
return render_template('article_details.html',
post=posts,
title=title,
author=author)
def validate_verifier(self, client_key, resource_owner_key, verifier):
try:
db_session.query(RequestToken, Client).filter(
Client.client_key == client_key,
RequestToken.token == resource_owner_key,
RequestToken.verifier == verifier
).one()
return True
except NoResultFound:
return False
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
hospital = db_session.query(HospitalModel).filter_by(id=data['id'])
hospital.update(data)
db_session.commit()
hospital = db_session.query(HospitalModel).filter_by(
id=data['id']).first()
return UpdateHospital(hospital=hospital)
def mutate(self, info, input):
data = input_to_dictionary(input)
data['edited'] = datetime.utcnow()
question = db_session.query(QuestionModel).filter_by(id=data['id'])
question.update(data)
db_session.commit()
question = db_session.query(QuestionModel).filter_by(
id=data['id']).first()
return UpdateQuestion(question=question)
def validate_access_token(self, client_key, resource_owner_key):
try:
db_session.query(AccessToken, Client).filter(
Client.client_key == client_key,
Client.id == AccessToken.client_id,
AccessToken.token == resource_owner_key).one()
return True
except NoResultFound:
return False
def signup(request, sse):
try:
data = json.loads(request.data)
if not data:
return jsonify(error=True,
message='request body is empty, check headers/data')
print(data)
username = str(data['username']).encode()
account_email = str(data['account_email']).encode()
booking_email = str(data['booking_email']).encode()
account_type = str(data['account_type']).encode()
password = str(data['password']).encode()
hashed = bcrypt.hashpw(password, bcrypt.gensalt())
check_username = db_session.query(Accounts).filter_by(
username=username).first()
check_account_email = db_session.query(Accounts).filter_by(
email=account_email).first()
check_booking_email = db_session.query(Accounts).filter_by(
booking_email=booking_email).first()
if check_username:
return jsonify(error=True, message='username is already in use')
if check_account_email:
return jsonify(error=True,
message='account email is already in use')
if check_booking_email:
return jsonify(error=True,
message='booking email is already in use')
new_account = Accounts(username=username,
email=account_email,
booking_email=booking_email,
password=hashed,
type=account_type)
db_session.add(new_account)
db_session.commit()
session_id = chamber.uniqueValue()
user_session['session_id'] = session_id
user_session['account_id'] = new_account.id
user_session['account_type'] = new_account.type
return jsonify(message='Signed Up!')
except Exception as err:
print(err)
return jsonify(error=True,
errorMessage=str(err),
message='error signing up...')
def _whoami(
self, name, alias_contain=True, forward_match=False,
partial_match=False, backward_match=False, one=False):
"""
nameからUserを探す。
User.admin User.enable
if True in [pr.active for pr in User.personal_records]:
といった真偽値で、操作が可能かどうか判定するため、たいていの操作はここから始まる。
forward_match, partial_match, backward_matchのどれかをTrueに指定する場合は、
どれか1つだけにしなければならない。
nameの末尾のアンダースコアは取り除かれる。
IRCの事情をケアする仕様。
"""
# 前方一致、部分一致、後方一致
if forward_match or partial_match or backward_match:
if forward_match: base = u"%s%%"
if partial_match: base = u"%%%s%%"
if backward_match: base = u"%%%s"
users = db_session.query(User
).filter(User.enable==True
).filter(User.name.like(base % self._rstrip_underscore(name))
).all()
if alias_contain:
aliases = db_session.query(UserAlias
).filter(UserAlias.name.like(base % name)
).all()
for alias in aliases:
if alias.user.enable and (alias.user not in users):
users.append(alias.user)
# 唯一の該当者だった場合のみ結果がほしい場合
if one:
if len(users) == 1:
return users[0]
else:
return None
else:
return users if users else None
# 完全一致
else:
try:
return db_session.query(User
).filter(User.name==self._rstrip_underscore(name)
).filter(User.enable==True
).one()
except NoResultFound:
pass
if alias_contain:
try:
alias = db_session.query(UserAlias).filter(UserAlias.name==name).one()
return alias.user if alias.user.enable else None
except NoResultFound:
pass
return None
def validate_access_token(self, client_key, resource_owner_key):
try:
db_session.query(AccessToken, Client).filter(
Client.client_key == client_key,
Client.id == AccessToken.client_id,
AccessToken.token == resource_owner_key
).one()
return True
except NoResultFound:
return False
def validate_request_token(self, client_key, resource_owner_key):
# TODO: make client_key optional
if client_key:
db_session.query(RequestToken, Client).filter(
RequestToken.token == resource_owner_key,
Client.client_key == client_key).one()
else:
RequestToken.query.filter_by(token=resource_owner_key).one()
try:
return True
except NoResultFound:
return False
def handleDeleteProjectDataRecord(self):
'''
删除研究项目中的一行数据
:return:
'''
pid, row_id = self.postParams("pid", "row_id")
if self.checkParamsAvailable(pid, row_id):
try:
db_session.query(ProjectItem).filter(ProjectItem.proj_id==pid).filter(ProjectItem.row_id==row_id).delete()
db_session.commit()
self.changeResponse2Success()
except Exception as e:
db_session.rollback()
def loadValueLabel(self):
"""
获取有序变量的取值
:return:
"""
_lb = self.value
property_rel = db_session.query(ProjectProperty).filter(ProjectProperty.id==self.p_id).first()
if property_rel is not None and property_rel.type == ProjectProperty.TYPE_SEQUENCE:
property_option = db_session.query(PropertyOptions).filter(PropertyOptions.p_id==self.p_id).\
filter(PropertyOptions.label==self.value).first()
if property_option is not None:
_lb = property_option.name
return _lb
def fix_result(self, json):
"""勝敗をつけ直す。"""
args = loads(json)
print args
user = self._whoami(args["caller"])
if user is None:
return dumps((False,))
if type(args["room_id"]) == int:
try:
gr = db_session.query(GeneralRecord
).filter(GeneralRecord.id==args["room_id"]
).one()
except NoResultFound:
return dumps((False,))
if gr.completed_at is None:
return dumps((False,))
# 管理者かホスト自身だけが結果を訂正できる
if (not user.admin) and (user.name != gr.room_owner):
return dumps((False,))
owner_pr = self._get_owner_pr(gr)
else:
try:
# UserのPersonalRecordのうち最新のレコードを取得
pr_id = db_session.query(
func.max(PersonalRecord.id)
).correlate(PersonalRecord
).filter(PersonalRecord.user_id==user.id).one()[0]
pr = db_session.query(PersonalRecord
).filter(PersonalRecord.id==pr_id).one()
except NoResultFound:
return dumps((False,))
gr = pr.general_record
if (gr.room_owner != pr.user.name) or (gr.completed_at is None):
return dumps((False,))
owner_pr = pr
self._save_result(owner_pr, args["won"], rollback=True)
gr = owner_pr.general_record
members = []
for member in gr.personal_records:
# 勝敗のついた参加者のみに限定する（入って抜けた人は除外）
if member.won is not None:
members.append(member)
returns = self._construct_room_info(gr, user)
returns.update({"members": [self._construct_member_info(member) for member in members]})
return dumps((True, returns))
def handleUpdateGeoUnit(self):
"""
处理地理坐标信息的更新操作
:return:
"""
gid, pid, geo_name, longitude, latitude, desc, area, high, map_type = \
self.postParams("gid", "pid", "geo_name", "longitude", "latitude", "desc", "area", "high", "map_type")
if self.checkParamsAvailable(gid, pid, geo_name, longitude, latitude, desc, area, high, map_type):
try:
current_user = UserIdentify.getCurrentUser()
geo_unit = db_session.query(GeoPointUnit).filter(GeoPointUnit.id==pid).first()
geo_unit.name = geo_name
geo_unit.longitude = longitude
geo_unit.latitude = latitude
geo_unit.desc = desc
geo_unit.map_type = map_type
if str(high).isdigit():
geo_unit.high = high
else:
geo_unit.high = 0
if str(area).isdigit():
geo_unit.area = area
else:
geo_unit.area = 0
geo_unit.u_id = current_user.get('uid', 0)
db_session.add(geo_unit)
db_session.commit()
self.changeResponse2Success()
except Exception as e:
db_session.rollback()
self.setFailureReason(str(e))
def insert_data(self, data):
"""
Will handle inserting data into the database
"""
try:
# Check if book is in database, if so update else create
try:
book = db_session.query(Book).filter(Book.book_id == data.get('book_id')).one()
except NoResultFound:
book = Book()
book.title = data.get('title')
book.subtitle = data.get('subtitle')
book.author = data.get('author')
book.year = data.get('year')
book.pages = data.get('pages')
book.language = data.get('language')
book.publisher = data.get('publisher')
book.isbn = data.get('isbn')
book.format = data.get('format')
book.description = data.get('description')
book.file_source = data.get('file_source')
book.file_cover_source = data.get('file_cover_source')
book.file_location = data.get('file_location')
book.file_cover_location = data.get('file_cover_location')
book.book_id = data.get('book_id')
book.time_collected = data.get('time_collected')
db_session.add(book)
db_session.commit()
# self.track_stat('rows_added_to_db', rows_affected)
except Exception:
db_session.rollback()
logger.exception("Error adding to db {data}".format(data=data))
def handleViewLaborary(self):
"""
提取展示定量实验室需要的数据
:return:
"""
lid, = self.getParams("lid")
if self.checkParamsAvailable(lid):
view_datas = {}
laborary_item = db_session.query(Laborary).filter(Laborary.id==lid).first()
if laborary_item is not None:
projects_list = db_session.query(Project).filter(Project.l_id==lid).all()
view_datas['projects'] = projects_list
view_datas['laborary'] = laborary_item.toDict()
self.setData(view_datas)
self.changeResponse2Success()
def handleAddProjectDataRecord(self):
_data_dict = self.postParams("*")
if "pid" in _data_dict:
try:
project_id = int(_data_dict.get('pid'))
except Exception as e:
project_id = 0
if project_id > 0:
row_num = str(uuid1())
try:
for _d in _data_dict:
if "pid" != _d:
pproperty_item = db_session.query(ProjectProperty).\
filter(ProjectProperty.label==_d).\
filter(ProjectProperty.p_id==project_id).first()
if pproperty_item is not None:
p_item = ProjectItem()
p_item.label = _d
p_item.value = _data_dict[_d]
p_item.row_id = row_num
p_item.proj_id = project_id
p_item.p_id = pproperty_item.id
db_session.add(p_item)
db_session.commit()
self.changeResponse2Success()
except Exception as e:
db_session.rollback()
self.setFailureReason(str(e))
def _diff_session(self, user):
"""
make_room(新規ゲーム), join_room(参加表明)のとき、会員のFQDNとIPアドレスが
前回の記録から変わっているかどうか調べて、
変わっている場合には何から何に変わったのかを返す。
"""
diff = {}
diff_ = False
sessions = db_session.query(Session
).filter(Session.user_id == user.id
).order_by(Session.id.desc()
).limit(2
).all()
if len(sessions) == 2:
last, prev = sessions
if (not None in [last.ipaddr, prev.ipaddr]) and (last.ipaddr != prev.ipaddr):
diff_ = True
if last.hostname != prev.hostname:
diff_ = True
if diff_:
diff.update({
"username": user.name,
"last_ipaddr": last.ipaddr,
"last_hostname": last.hostname,
"last_timestamp": last.timestamp,
"prev_ipaddr": prev.ipaddr,
"prev_hostname": prev.hostname,
"prev_timestamp": prev.timestamp,
})
return diff
def get(self, id):
try:
dog = db_session.query(Dog).filter(Dog.id == id).one()
t = Template('<img alt="dog_image" src="data:image/jpeg;base64,{{ img }}" />')
self.write(t.generate(img=dog.image))
except:
self.write("Dog not found")
def breakup(self, json):
"""解散、強制解散"""
args = loads(json)
print args
user = self._whoami(args["caller"])
if user is None:
return dumps((False,))
pr = self._is_room_owner(args["channel"], args["caller"])
if (not pr) and (not args["force"]):
return dumps((False,))
if (not pr) and args["force"]:
q = db_session.query(GeneralRecord
).filter(GeneralRecord.active==True
).filter(GeneralRecord.room_number==args["room_number"]
).filter(GeneralRecord.channel==args["channel"])
try:
gr = q.one()
except NoResultFound:
return dumps((False,))
else:
gr = pr.general_record
members = self._execute_breakup(gr)
returns = self._construct_room_info(gr, user)
returns.update({"members": [self._construct_member_info(pr) for pr in members]})
db_session.commit()
return dumps((True, returns))
def get_count_like(keyword):
start_time = time.time()
#count = LogEntry.query.filter(LogEntry.referrer == "%" + keyword + "%").count()
count = db_session.query(LogEntry).filter(LogEntry.destination.like(
"%" + keyword + "%")).count()
print("-- %s seconds --" % (time.time() - start_time))
return count
def getPropertyOptions(self):
"""
如果是有序变量或名称变量，则获取其可取数值列表
@return list
"""
if self.typeOptions():
return db_session.query(PropertyOptions).filter(PropertyOptions.p_id==self.id).all()
def handleDeletePropertyForProject(self):
"""
删除指定的研究项目属性
:return:
"""
_id, = self.postParams("id")
if self.checkParamsAvailable(_id):
try:
_del_property = db_session.query(ProjectProperty).filter(ProjectProperty.id==_id).first()
if _del_property is not None:
db_session.query(ProjectItem.proj_id==_del_property.p_id).filter(ProjectItem.label==_del_property.label).delete()
db_session.delete(_del_property)
db_session.commit()
self.changeResponse2Success()
except Exception as e:
db_session.rollback()
self.setFailureReason(str(e))
def log_last_scraped(self):
try:
try:
last_book_id = db_session.query(Book).order_by(Book.book_id.desc()).first()
if last_book_id is not None:
setting = db_session.query(Setting).filter(Setting.bit == 0).one()
setting.book_last_id = last_book_id.book_id
setting.book_last_ran = cutil.get_datetime()
db_session.add(setting)
db_session.commit()
except NoResultFound:
# If there is no raw data then no books were collected
pass
except:
logger.exception("Problem logging last book scraped")
def get_active_pr(user):
q = db_session.query(PersonalRecord
).filter(PersonalRecord.active==True
).filter(PersonalRecord.user_id==user.id)
try:
return q.one()
except NoResultFound:
return None
def get_code_snippets(code_id):
if code_id:
try:
result = db_session.query(CodeSnippets).filter(CodeSnippets.code_id==code_id).one()
return result
except DisconnectionError:
result = {'error': True, 'msg': 'Please try after some time'}
return result
def _get_rnp(self):
q = db_session.query(RoomNumberPool
).filter(RoomNumberPool.id==1
)
try:
return q.one()
except NoResultFound:
return None
def handleVeiwQueryGeoPointGroup(self):
"""
查询地理坐标集合
:return:
"""
gid, = self.getParams("gid")
if self.checkParamsAvailable(gid):
geo_point_group = db_session.query(GeoPointGroup).filter(GeoPointGroup.id==gid).first()
if geo_point_group is not None:
geo_point_units = db_session.query(GeoPointUnit).filter(GeoPointUnit.group_id==gid).all()
self.setData({
'gid': gid,
'geo_point_group': geo_point_group,
'geo_point_units': geo_point_units
})
self.changeResponse2Success()
else:
self.setFailureReason("要查找的地理点位集合不存在！")
def handleLoadPropertyOptionsOfProperty(self):
"""
获取指定属性下的所有属性选项
:return:
"""
pid, = self.postParams("pid")
if self.checkParamsAvailable(pid):
property = db_session.query(ProjectProperty).filter(ProjectProperty.id==pid).first()
if property is not None:
ret_data = {}
options_list = db_session.query(PropertyOptions).filter(PropertyOptions.p_id==pid).all()
ret_data.setdefault('property', property)
ret_data.setdefault('options', options_list)
self.setData(ret_data)
self.changeResponse2Success()
else:
self.setFailureReason("字段属性不存在！")
def loadPropertyItem(self):
'''
获取项目字段属性
:param prop_id:
:return:
'''
prop_id, = self.postParams("prop_id")
if self.checkParamsAvailable(prop_id):
return db_session.query(ProjectProperty).filter(ProjectProperty.id==prop_id).first()
def order_product_grid(user_id,order_id, page=None, records_per_page=None):
query = db_session.query(OrderProduct, Order, Product).join(Order).join(Product).filter(Order.id==order_id).\
filter(Order.user_id==user_id).filter((Order.status_id == 3)|(Order.status_id == 4))
count = query.filter_by(is_deleted=False).count()
if page and records_per_page:
stop = page * records_per_page
start = stop - records_per_page
return query.slice(start, stop).all(), count
else:
return query.all(),count
