def get(self, uuid):
""" Query specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
manuals_instance = ManualsModel.query.get_or_404(uuid)
manuals_dump = ManualsSchema().dump(manuals_instance)
return pretty_response(200, manuals_dump)
def put(self, uuid):
""" Update specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
blockset_instance = BlocksetModel.query.get_or_404(uuid)
jsondata = request.get_json()
try:
coordinates = find_coordinates(jsondata.get('description', ''))
if not coordinates:
return pretty_response(40001)
BlocksetSchema().load(jsondata,
partial=(
"title",
"description",
),
unknown=EXCLUDE)
for key, val in jsondata.items():
setattr(blockset_instance, key, val)
blockset_instance.coordinates = json.dumps(coordinates)
blockset_instance.centroid = json.dumps(find_centroid(coordinates))
blockset_instance.area = calculate_area(coordinates)
blockset_instance.updatetime = datetime.now()
blockset_instance.update()
blockset_dump = BlocksetSchema().dump(blockset_instance)
return pretty_response(200, blockset_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def get(self):
""" Query all instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
users_list = UsersModel.query.all()
users_dump = UsersSchema(many=True).dump(users_list)
return pretty_response(200, users_dump)
def get(self, uuid):
""" Query specific instance """
if current_identity.roless not in ['super'] and \
uuid != current_identity.id:
return pretty_response(403)
users_instance = UsersModel.query.get_or_404(uuid)
users_dump = UsersSchema().dump(users_instance)
return pretty_response(200, users_dump)
def get(self, uuid):
""" Query specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
dataset_instance = DatasetModel.query.get_or_404(uuid)
dataset_dump = DatasetSchema().dump(dataset_instance)
result = fetch_collection('T' + dataset_instance.uuid, [])
dataset_dump['data'] = result
return pretty_response(200, dataset_dump)
def delete(self, uuid):
""" Delete specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
blockset_instance = BlocksetModel.query.get_or_404(uuid)
try:
blockset_instance.delete(blockset_instance)
return pretty_response(20003)
except SQLAlchemyError as e:
current_app.logger.error(e)
pretty_response(50001)
def get(self):
""" Query all instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
if request.args.get('title'):
manuals_list = ManualsModel.query.filter_by(
title=request.args.get('title')).order_by("createtime").all()
else:
manuals_list = ManualsModel.query.order_by("createtime").all()
manuals_dump = ManualsSchema(many=True).dump(manuals_list)
return pretty_response(200, manuals_dump)
def get(self):
""" Query all instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
if request.args.get('opt_key'):
options_list = OptionsModel.query.filter_by(
opt_key=request.args.get('opt_key')).all()
else:
options_list = OptionsModel.query.all()
options_dump = OptionsSchema(many=True).dump(options_list)
return pretty_response(200, options_dump)
def get(self, uuid):
""" Query specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
blockset_instance = BlocksetModel.query.get_or_404(uuid)
# print(json.loads(blockset_instance.centroid))
blockset_dump = BlocksetSchema().dump(blockset_instance)
blockset_dump['centroid'] = json.loads(blockset_instance.centroid)
blockset_dump['coordinates'] = json.loads(
blockset_instance.coordinates)
print(blockset_dump)
return pretty_response(200, blockset_dump)
def get(self):
""" Query all instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
title = request.args.get('title', '')
page = request.args.get('page', 1, type=int)
per_page = request.args.get('per_page', 10, type=int)
paginate = DatasetModel.query.filter(DatasetModel.title.like('%' + title + '%')).paginate(
page, per_page, max_per_page=100)
data = paginate_parse(paginate)
data['items'] = DatasetSchema(many=True).dump(paginate.items)
return pretty_response(200, data)
def put(self, uuid):
""" Update specific instance """
dataset_instance = DatasetModel.query.get_or_404(uuid)
try:
jsondata = request.get_json()
DatasetSchema().load(jsondata, unknown=EXCLUDE)
for key, val in jsondata.items():
setattr(dataset_instance, key, val)
dataset_instance.updatetime = datetime.now()
dataset_instance.update()
dataset_dump = DatasetSchema().dump(dataset_instance)
return pretty_response(200, dataset_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def put(self, uuid):
""" Update specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
manuals_instance = ManualsModel.query.get_or_404(uuid)
try:
jsondata = request.get_json()
ManualsSchema().load(jsondata)
for key, val in jsondata.items():
setattr(manuals_instance, key, val)
manuals_instance.updatetime = datetime.now()
manuals_instance.update()
manuals_dump = ManualsSchema().dump(manuals_instance)
return pretty_response(200, manuals_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def post(self):
""" Insert multi-instances """
jsondata = request.get_json()
if not jsondata or jsondata['username'] is None:
return pretty_response(40001)
if UsersModel.query.filter_by(username=jsondata['username']).first():
return pretty_response(40002)
try:
users_instance = UsersSchema().load(jsondata)
users_instance = UsersModel(
jsondata['username'], jsondata['password'])
users_instance.add(users_instance)
users_dump = UsersSchema().dump(users_instance)
return pretty_response(200, users_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def post(self):
""" Insert multi-instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
jsondata = request.get_json()
if BlocksetModel.query.filter_by(
title=jsondata.get('title', '')).first():
return pretty_response(40002)
try:
coordinates = find_coordinates(jsondata.get('description', ''))
if not coordinates:
return pretty_response(40001)
blockset_instance = BlocksetSchema().load(jsondata,
unknown=EXCLUDE)
blockset_instance.coordinates = json.dumps(coordinates)
blockset_instance.centroid = json.dumps(find_centroid(coordinates))
blockset_instance.area = calculate_area(coordinates)
blockset_instance.add(blockset_instance)
blockset_dump = BlocksetSchema().dump(blockset_instance)
return pretty_response(200, blockset_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def get(self):
""" Query specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
options_instance = None
try:
if request.args.get('opt_key'):
options_instance = OptionsModel.query.filter(
OptionsModel.opt_key == request.args.get(
'opt_key')).first()
else:
return StandardResponse(400, 1, u'Invalid Request Parameters')
except Exception, e:
return StandardResponse(500, 1, u'SQLAlchemy Error')
def put(self):
""" Update multi-instances """
blocksets = BlocksetModel.query.all()
point_pool = []
for blockset in blocksets:
coordinates_temp = []
coordinates = json.loads(blockset.coordinates)
for coordinate in coordinates:
aggregate_flag = False
for point in point_pool:
if abs(coordinate.get('lng') -
point.get('lng')) < 0.001 and abs(
coordinate.get('lat') -
point.get('lat')) < 0.001:
coordinates_temp.append(point)
aggregate_flag = True
break
if not aggregate_flag:
coordinates_temp.append(coordinate)
point_pool.append(coordinate)
blockset.coordinates = json.dumps(coordinates_temp)
blockset.update()
return pretty_response(200)
def post(self):
""" Insert multi-instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
jsondata = request.get_json()
if not jsondata or 'title' not in jsondata:
return pretty_response(40001)
if ManualsModel.query.filter_by(title=jsondata['title']).first():
return pretty_response(40002)
try:
manuals_instance = ManualsSchema().load(jsondata)
manuals_instance.add(manuals_instance)
manuals_dump = ManualsSchema().dump(manuals_instance)
return pretty_response(200, manuals_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def post(self):
""" Insert multi-instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
jsondata = request.get_json()
if not jsondata or 'opt_key' not in jsondata:
return pretty_response(400)
if OptionsModel.query.filter_by(opt_key=jsondata['opt_key']).first():
return pretty_response(400)
try:
options_instance, errors = OptionsSchema().load(jsondata)
if errors:
current_app.logger.error(errors)
return pretty_response(400)
options_instance.add(options_instance)
options_dump, errors = OptionsSchema().dump(options_instance)
return pretty_response(200, options_dump)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(500)
def post(self):
""" Insert multi-instances """
if current_identity.roles not in ['super']:
return pretty_response(403)
jsondata = request.get_json()
if DatasetModel.query.filter_by(title=jsondata['title']).first():
return pretty_response(40002)
headers = jsondata.get('header', [])
catalog = jsondata.get('catalog', None)
if '数值' not in headers \
or (catalog == 'block' and '板块' not in headers) \
or (catalog == 'point' and '标题' not in headers):
return pretty_response(40001)
try:
dataset_instance = DatasetSchema().load(jsondata, unknown=EXCLUDE)
dataset_instance.add(dataset_instance)
blocksets = BlocksetModel.query.all()
data = json.loads(
re.sub(r'[\s+]', '', json.dumps(jsondata.get('data', []))))
if catalog == 'block':
# 导入板块数据
t = threading.Thread(target=analysis_dataset_block, args=(
'T' + dataset_instance.uuid, data, blocksets, headers))
t.start()
else:
# 导入集合数据
t = threading.Thread(target=analysis_dataset, args=(
'T' + dataset_instance.uuid, data, blocksets, headers))
t.start()
dataset_dump = DatasetSchema().dump(dataset_instance)
return pretty_response(200, dataset_dump)
except ValidationError as e:
current_app.logger.error(e.messages)
return pretty_response(40003)
except SQLAlchemyError as e:
current_app.logger.error(e)
return pretty_response(50001)
def delete(self):
""" Batch-delete instances """
return pretty_response(405)
def put(self):
""" Update multi-instances """
return pretty_response(405)
def post(self, uuid):
""" Update specific instance """
if current_identity.roles not in ['super']:
return pretty_response(403)
dataset_instance = DatasetModel.query.get_or_404(uuid)
jsondata = request.get_json()
if not jsondata:
return pretty_response(40001)
catalog = jsondata.get('catalog', '')
match = jsondata.get('match', {})
pipeline = []
aggregate_items = []
aggregate_max = 0
if catalog == 'block':
pipeline = [{
'$match': match
}, {
'$group': {'_id': "$板块", 'value': {dataset_instance.mode: '$数值'}}
}]
result = fetch_collection('T' + dataset_instance.uuid, pipeline)
blockset_list = BlocksetModel.query.all()
for blockset in blockset_list:
temp = {
'title': blockset.title,
'area': blockset.area,
'centroid': json.loads(blockset.centroid),
'coordinates': json.loads(blockset.coordinates),
'org_value': 0,
'value': 0,
}
for item in result:
if blockset.title == item.get('_id', ''):
if not item.get('value', None):
break
item_value = item.get('value', 0)
temp['org_value'] = item_value
temp['value'] = round(
item_value / float(blockset.area), 4) if dataset_instance.inc_area else item_value
if temp['value'] > aggregate_max:
aggregate_max = temp['value']
break
aggregate_items.append(temp)
else:
pipeline = [{
'$match': match
}]
result = fetch_collection('T' + dataset_instance.uuid, pipeline)
for item in result:
aggregate_item = {
'title': item.get('标题', ''),
'address': item.get('地址', ''),
'lng': item.get('经度', ''),
'lat': item.get('纬度', ''),
'value': item.get('数值', 0),
}
if aggregate_item['value'] > aggregate_max:
aggregate_max = aggregate_item['value']
aggregate_items.append(aggregate_item)
return pretty_response(200, {'max': aggregate_max, 'items': aggregate_items})
def post(self):
""" Update specific instance """
return pretty_response(405)
def get(self):
""" Query specific instance """
users_dump = UsersSchema().dump(current_identity)
return pretty_response(200, users_dump)
