async def cmdb_edit_type(edit_type: CMDBBase,
request: Request,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/edit_type'))):
old_type = db.query(CMDBType).filter(
CMDBType.cmdb_type_id == int(edit_type.type_id)).first()
if not old_type:
raise HTTPException(status_code=406, detail="要修改的类型不存在")
if old_type.cmdb_type_name != edit_type.type_name:
# 说明修改了类型名，需要判断修改后的类型是否已经存在
if db.query(CMDBType).filter(
CMDBType.cmdb_type_name == edit_type.type_name).first():
raise HTTPException(status_code=406, detail="修改的类型已存在")
old_record = deepcopy(old_type)
old_type.cmdb_type_name = edit_type.type_name
old_type.cmdb_type_icon = edit_type.type_icon
old_type.cmdb_type_label = edit_type.type_label
new_record = deepcopy(old_type)
db.add(old_type)
db.commit()
Record.create_operate_record(username=current_user.username,
old_object=old_record,
new_object=new_record,
ip=request.client.host)
return {"message": "类型修改成功"}
async def create_user(user: NewUser,
request: Request,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/users/create_user'))):
old_user = db.query(User).filter(
or_(User.username == user.username, User.email == user.email)).first()
if old_user:
raise HTTPException(status_code=406, detail="创建的用户已经存在")
user_dict = {
"username": user.username,
"email": user.email,
"nick_name": user.nick_name,
"is_active": user.is_active
}
new_user = User(**user_dict)
new_record = deepcopy(new_user)
new_user.convert_pass_to_hash(user.password)
db.add(new_user)
db.commit()
# 调用数据修改记录器
Record.create_operate_record(new_object=new_record,
username=current_user.username,
ip=request.client.host)
return {"message": "用户创建成功"}
async def edit_type_item(request: Request,
edit_item: CMDBItemBase,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/edit_type_item'))):
type_id = int(edit_item.item_id)
old_item = db.query(CMDBItem).filter(CMDBItem.item_id == type_id).first()
if not old_item:
raise HTTPException(status_code=406, detail="要修改的属性不存在")
# 判断是否存在
if old_item.item_name != edit_item.item_name:
if db.query(CMDBItem).filter(
and_(CMDBItem.cmdb_type_id == int(edit_item.cmdb_type_id),
CMDBItem.item_name == edit_item.item_name)).first():
raise HTTPException(status_code=406, detail="要修改的属性名已存在")
if old_item.item_label != edit_item.item_label:
if db.query(CMDBItem).filter(
and_(CMDBItem.cmdb_type_id == int(edit_item.cmdb_type_id),
CMDBItem.item_label == edit_item.item_label)).first():
raise HTTPException(status_code=406, detail="要修改的标签名已存在")
old_record = deepcopy(old_item)
old_item.item_name = edit_item.item_name
old_item.item_label = edit_item.item_label
new_record = deepcopy(old_item)
db.add(old_item)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
old_object=old_record,
ip=request.client.host)
return {"message": "属性修改成功"}
async def edit_perm(perm_id: str,
perm_edit: PermBase,
request: Request,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm("/perm/edit_perm"))):
# 查询
perm = db.query(Permission).filter(
Permission.perm_id == int(perm_id)).first()
if not perm:
raise HTTPException(status_code=406, detail="需要修改的权限不存在")
# 判断是否重复
if perm_edit.perm_name != perm.perm_name:
old_perm = db.query(Permission).filter(
Permission.perm_name == perm_edit.perm_name).first()
if old_perm:
raise HTTPException(status_code=406, detail="修改后的权限名称重复")
if perm_edit.perm_interface != perm.perm_interface:
old_perm = db.query(Permission).filter(
Permission.perm_interface == perm_edit.perm_interface).first()
if old_perm:
raise HTTPException(status_code=406, detail="修改后的权限接口重复")
old_perm = deepcopy(perm)
perm.perm_name = perm_edit.perm_name
perm.perm_interface = perm_edit.perm_interface
new_perm = deepcopy(perm)
db.add(perm)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_perm,
old_object=old_perm,
ip=request.client.host)
return {"message": "权限修改成功"}
async def update_user(request: Request,
modify_user: ModifyUser,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/users/update_user'))):
"""
用户名不可以修改
"""
user = db.query(User).filter(User.username == modify_user.username).first()
if user:
old_user = deepcopy(user)
if modify_user.password:
user.convert_pass_to_hash(modify_user.password)
user.is_active = modify_user.is_active
user.email = modify_user.email
user.nick_name = modify_user.nick_name
new_user = deepcopy(user)
db.add(user)
db.commit()
# 调用数据修改记录器
Record.create_operate_record(old_object=old_user,
new_object=new_user,
username=current_user.username,
ip=request.client.host)
return {"message": "用户信息更新成功"}
else:
raise HTTPException(status_code=406, detail="用户不存在")
async def add_perm(new_perm: PermBase, request: Request, db: Session = Depends(get_db),
current_user: User = Depends(check_perm('/perm/add_perm'))):
# 查询是否存在
old_perm = db.query(Permission).filter(
or_(Permission.perm_name == new_perm.perm_name, Permission.perm_interface == new_perm.perm_interface)).first()
if old_perm:
raise HTTPException(status_code=406, detail="权限已存在")
perm = Permission(perm_name=new_perm.perm_name, perm_interface=new_perm.perm_interface)
new_record = deepcopy(perm)
db.add(perm)
db.commit()
Record.create_operate_record(username=current_user.username, new_object=new_record, ip=request.client.host)
return {"message": "权限已添加"}
async def add_menu(menu: MenuBase, request: Request, db: Session = Depends(get_db),
current_user: User = Depends(check_perm('/menu/add_menu'))):
# 确认menu不存在
old_menu = db.query(Menu).filter(or_(Menu.menu_name == menu.menu_name, Menu.menu_flag == menu.menu_flag)).first()
if old_menu:
raise HTTPException(status_code=406, detail="菜单已存在")
new_menu = Menu(menu_name=menu.menu_name, menu_flag=menu.menu_flag,
parent_id="0" if not menu.parent_id else int(menu.parent_id))
new_record = deepcopy(new_menu)
db.add(new_menu)
db.commit()
Record.create_operate_record(username=current_user.username, new_object=new_record, ip=request.client.host)
settings.logger.info(f"新增菜单{menu.menu_name}")
return {"message": "菜单新增成功"}
async def add_role(role: RoleBase,
request: Request,
db: Session = Depends(get_db),
current_user: User = Depends(check_perm('/role/add_role'))):
old_role = db.query(Role).filter(Role.role_name == role.role_name).first()
if old_role:
raise HTTPException(status_code=406, detail="创建的角色已存在")
new_role = Role(role_name=role.role_name, role_desc=role.role_desc)
new_record = deepcopy(new_role)
db.add(new_role)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
ip=request.client.host)
return {"message": "角色添加成功"}
async def delete_record(request: Request,
record_id: str,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/delete_record'))):
record = db.query(CMDBRecord).filter(
CMDBRecord.cmdb_record_id == int(record_id)).first()
if not record:
raise HTTPException(status_code=406, detail="要删除的ID不存在")
old_record = deepcopy(record)
db.delete(record)
db.commit()
Record.create_operate_record(username=current_user.username,
old_object=old_record,
ip=request.client.host)
return {"message": "记录删除成功"}
async def cmdb_add_type(new_type: CMDBBase,
request: Request,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/add_type'))):
# type_name唯一
old_type = db.query(CMDBType).filter(
CMDBType.cmdb_type_name == new_type.type_name).first()
if old_type:
raise HTTPException(status_code=406, detail="创建的类型已经存在")
cmdb_type = CMDBType(cmdb_type_name=new_type.type_name,
cmdb_type_icon=new_type.type_icon,
cmdb_type_label=new_type.type_label)
new_record = deepcopy(cmdb_type)
db.add(cmdb_type)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
ip=request.client.host)
return {"message": "类型创建成功"}
async def add_record(request: Request,
new_record: Dict[str, str],
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/add_record'))):
type_id = int(new_record.get("cmdb_type_id", "0"))
if type_id == 0:
raise HTTPException(status_code=406, detail="请传入cmdb_type_id")
# 删除id就是记录详情了
del new_record['cmdb_type_id']
cmdb_record = CMDBRecord()
cmdb_record.cmdb_type_id = type_id
cmdb_record.cmdb_record_detail = new_record
record = deepcopy(cmdb_record)
db.add(cmdb_record)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=record,
ip=request.client.host)
return {"message": "实例添加成功"}
async def import_record(request: Request,
type_id: str,
file: UploadFile = File(...),
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/import_record'))):
# 获取用户上传的文件并存储，命名规则:{type_name}-{username}-{时间戳}
type_id = int(type_id)
cmdb_type = db.query(CMDBType).filter(
CMDBType.cmdb_type_id == type_id).first()
if not cmdb_type:
raise HTTPException(status_code=406, detail="上传的类型不存在")
# 上传文件必须为Excel
if not file.content_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
raise HTTPException(status_code=406, detail="请上传Excel文件")
cmdb_type_name = cmdb_type.cmdb_type_name
total_miles = str(int(round(time.time() * 1000)))
store_filename = f"{cmdb_type_name}-{total_miles}-{file.filename}"
content = await file.read()
# 保存用户上传的文件
with open(os.path.join(Settings.UPLOAD_FOLDER, store_filename),
"wb+") as f:
f.write(content)
# 解析Excel
excel = Excel(
filepath=os.path.join(Settings.UPLOAD_FOLDER, store_filename))
all_records = excel.import_cmdb_record()
if len(all_records) == 0:
raise HTTPException(status_code=406, detail="请填入具体数据")
# record插入数据库
for record in all_records:
cmdb_record = CMDBRecord()
cmdb_record.cmdb_type_id = type_id
cmdb_record.cmdb_record_detail = record
new_record = deepcopy(cmdb_record)
db.add(cmdb_record)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
ip=request.client.host)
return {"all_records": all_records}
async def add_type_desc(request: Request,
new_item: CMDBItemBase,
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/add_type_item'))):
# 确认属性是否重复
old_item = db.query(CMDBItem).filter(
and_(
CMDBItem.cmdb_type_id == new_item.cmdb_type_id,
or_(CMDBItem.item_name == new_item.item_name,
CMDBItem.item_label == new_item.item_label))).first()
if old_item:
raise HTTPException(status_code=406, detail="此属性已存在")
item = CMDBItem(cmdb_type_id=int(new_item.cmdb_type_id),
item_name=new_item.item_name,
item_label=new_item.item_label)
new_record = deepcopy(item)
db.add(item)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
ip=request.client.host)
return {"message": "属性新增成功"}
async def edit_menu(menu: MenuBase, request: Request, db: Session = Depends(get_db),
current_user: User = Depends(check_perm('/menu/edit_menu'))):
# 确认menu不存在
old_menu = db.query(Menu).filter(Menu.menu_id == int(menu.menu_id)).first()
if not old_menu:
raise HTTPException(status_code=406, detail="要修改的菜单不存在")
# 确认菜单是否重复
old_record = deepcopy(old_menu)
if menu.menu_name != old_menu.menu_name:
if db.query(Menu).filter(Menu.menu_name == menu.menu_name).first():
raise HTTPException(status_code=406, detail="菜单名已存在")
if menu.menu_flag != old_menu.menu_flag:
if db.query(Menu).filter(Menu.menu_flag == menu.menu_flag).first():
raise HTTPException(status_code=406, detail="菜单标识已存在")
old_menu.menu_name = menu.menu_name
old_menu.menu_flag = menu.menu_flag
old_menu.parent_id = int(menu.parent_id)
new_record = deepcopy(old_menu)
db.add(old_menu)
db.commit()
Record.create_operate_record(username=current_user.username, old_object=old_record, new_object=new_record,
ip=request.client.host)
return {"message": "菜单修改成功"}
async def edit_instance(request: Request,
edit_record: Dict[str, str],
db: Session = Depends(get_db),
current_user: User = Depends(
check_perm('/cmdb/edit_record'))):
type_id = int(edit_record.get("cmdb_type_id", "0"))
record_id = int(edit_record.get("cmdb_record_id", "0"))
if type_id == 0 or record_id == 0:
raise HTTPException(status_code=406, detail="请传入id")
# 删除id就是记录详情了
del edit_record["cmdb_type_id"]
del edit_record["cmdb_record_id"]
instance = db.query(CMDBRecord).filter(
CMDBRecord.cmdb_record_id == record_id).first()
old_record = deepcopy(instance)
instance.cmdb_record_detail = edit_record
new_record = deepcopy(instance)
db.add(instance)
db.commit()
Record.create_operate_record(username=current_user.username,
new_object=new_record,
old_object=old_record,
ip=request.client.host)
return {"message": "实例修改成功"}
