def get_detail_by_record(record_id=None):
record = db.session.query(OperationRecord).filter(
OperationRecord.record_id == record_id).first()
if record is None:
abort(404, "record is not found")
username = UserCache.get(record.uid).nickname \
if UserCache.get(record.uid).nickname \
else UserCache.get(record.uid).username
timestamp = record.timestamp.strftime("%Y-%m-%d %H:%M:%S")
attr_history = db.session.query(CIAttributeHistory).filter(
CIAttributeHistory.record_id == record_id).all()
rel_history = db.session.query(CIRelationHistory).filter(
CIRelationHistory.record_id == record_id).all()
attr_dict, rel_dict = dict(), {"add": [], "delete": []}
for attr_h in attr_history:
attr_dict[CIAttributeCache.get(attr_h.attr_id).attr_alias] = {
"old": attr_h.old,
"new": attr_h.new,
"operate_type": attr_h.operate_type
}
manager = CIManager()
for rel_h in rel_history:
_, first = manager.get_ci_by_id(rel_h.first_ci_id)
_, second = manager.get_ci_by_id(rel_h.second_ci_id)
rel_dict[rel_h.operate_type].append(
(first, rel_h.relation_type, second))
return jsonify(username=username,
timestamp=timestamp,
attr_history=attr_dict,
rel_history=rel_dict)
def delete_user(self, uid):
user = UserCache.get(uid)
if user is None:
return abort(400, "the user[{0}] is not existed".format(uid))
db.session.query(UserRole).filter(UserRole.uid == uid).delete()
db.session.delete(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error("delete user error, {0}".format(str(e)))
return abort(500, "delete user error, {0}".format(str(e)))
return True, uid
def reset_key(self, uid):
user = UserCache.get(uid)
if user is None:
return abort(400, "the user[{0}] is not existed".format(uid))
key, secret = self._generate_key()
user.key = key
user.secret = secret
db.session.add(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error("reset key is error, {0}".format(str(e)))
return abort(500, "reset key is error, {0}".format(str(e)))
return True, user
def wrapper(*args, **kwargs):
if isinstance(getattr(g, 'user', None), User):
identity_changed.send(current_app._get_current_object(),
identity=Identity(g.user.uid))
return func(*args, **kwargs)
ip = request.remote_addr
if request.data:
request_args = dict()
_args = request.data.split("&")
for arg in _args:
if arg:
request_args[arg.split("=")[0]] = \
urllib.unquote(arg.split("=")[1])
else:
request_args = request.values
key = request_args.get('_key')
secret = request_args.get('_secret')
if not key and not secret and \
ip.strip() in current_app.config.get("WHITE_LIST"):
ip = ip.strip()
user = UserCache.get(ip)
if user:
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.uid))
return func(*args, **kwargs)
else:
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
return abort(400, "invalid _key and _secret")
path = request.path
keys = sorted(request_args.keys())
req_args = [
request_args[k] for k in keys if str(k) not in ("_key", "_secret")
]
current_app.logger.debug('args is %s' % req_args)
user, authenticated = User.query.authenticate_with_key(
key, secret, req_args, path)
if user and authenticated:
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.get("uid")))
return func(*args, **kwargs)
else:
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
return abort(400, "invalid _key and _secret")
def update_user(self, uid, **kwargs):
user = UserCache.get(uid)
if user is None:
return abort(400, "the user[{0}] is not existed".format(uid))
user.username = kwargs.get("username", "") \
if kwargs.get("username") else user.username
user.nickname = kwargs.get("nickname") \
if kwargs.get("nickname") else user.nickname
user.department = kwargs.get("department") \
if kwargs.get("department") else user.department
user.catalog = kwargs.get("catalog") \
if kwargs.get("catalog") else user.catalog
user.email = kwargs.get("email") \
if kwargs.get("email") else user.email
user.mobile = kwargs.get("mobile") \
if kwargs.get("mobile") else user.mobile
db.session.add(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error("create user is error {0}".format(str(e)))
return abort(500, "create user is error, {0}".format(str(e)))
return True, user
def create_user(self, **kwargs):
username = kwargs.get("username")
if username:
user = UserCache.get(username)
if user is not None:
user, authenticated = self.validate(username,
kwargs.get("password"))
if authenticated:
return user
else:
return abort(401, "authenticate validate failed")
else:
return abort(400, "argument username is required")
user = User()
email = kwargs.get("email", "")
if not email:
return abort(400, "argument email is required")
user.email = email
user.password = kwargs.get("password")
user.username = kwargs.get("username", "")
user.nickname = kwargs.get("nickname") if kwargs.get("nickname") \
else kwargs.get("username", "")
key, secret = self._generate_key()
user.key = key
user.secret = secret
user.date_joined = datetime.datetime.now()
user.block = 0
db.session.add(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error("create user is error {0}".format(str(e)))
return abort(500, "create user is error, {0}".format(str(e)))
return user
def get_user_by_uid(self, uid):
user = UserCache.get(uid)
return user
def get_record():
page = get_page(request.values.get("page", 1))
_start = request.values.get("start")
_end = request.values.get("end")
username = request.values.get("username", "")
per_page_cnt = current_app.config.get("DEFAULT_PAGE_COUNT")
start, end = None, None
if _start:
try:
start = datetime.datetime.strptime(_start, '%Y-%m-%d %H:%M:%S')
except ValueError:
abort(400, 'incorrect start date time')
if _end:
try:
end = datetime.datetime.strptime(_end, '%Y-%m-%d %H:%M:%S')
except ValueError:
abort(400, 'incorrect end date time')
records = db.session.query(OperationRecord)
numfound = db.session.query(db.func.count(OperationRecord.record_id))
if start:
records = records.filter(OperationRecord.timestamp >= start)
numfound = numfound.filter(OperationRecord.timestamp >= start)
if end:
records = records.filter(OperationRecord.timestamp <= end)
numfound = records.filter(OperationRecord.timestamp <= end)
if username:
user = UserCache.get(username)
if user:
records = records.filter(OperationRecord.uid == user.uid)
else:
return jsonify(numfound=0,
records=[],
page=1,
total=0,
start=_start,
end=_end,
username=username)
records = records.order_by(-OperationRecord.record_id).offset(
per_page_cnt * (page - 1)).limit(per_page_cnt).all()
total = len(records)
numfound = numfound.first()[0]
res = []
for record in records:
_res = row2dict(record)
_res["user"] = UserCache.get(_res.get("uid")).nickname \
if UserCache.get(_res.get("uid")).nickname \
else UserCache.get(_res.get("uid")).username
attr_history = db.session.query(CIAttributeHistory.attr_id).filter(
CIAttributeHistory.record_id == _res.get("record_id")).all()
_res["attr_history"] = [
CIAttributeCache.get(h.attr_id).attr_alias for h in attr_history
]
rel_history = db.session.query(CIRelationHistory.operate_type).filter(
CIRelationHistory.record_id == _res.get("record_id")).all()
rel_statis = {}
for rel in rel_history:
if rel.operate_type not in rel_statis:
rel_statis[rel.operate_type] = 1
else:
rel_statis[rel.res.operate_type] += 1
_res["rel_history"] = rel_statis
res.append(_res)
return jsonify(numfound=numfound,
records=res,
page=page,
total=total,
start=_start,
end=_end,
username=username)