def edu_desktop_groups(self, data):
""" 教学桌面组列表 """
logger.debug(
"get education desktop info, terminal_id:%s, terminal_ip:%s",
data.get("terminal_id", 0), data.get("terminal_ip", ""))
terminal_id = data.get("terminal_id", 0)
if not terminal_id:
logger.error("terminal id param error: %s" % terminal_id)
return build_result("ParamError")
terminal_ip = data.get("terminal_ip", "")
if not is_ip_addr(terminal_ip):
logger.error("terminal edu desktop group info error, %s not ip" %
terminal_ip)
return build_result("IPAddrError", ipaddr=terminal_ip)
groups = db_api.get_group_with_all(
{"group_type": constants.EDUCATION_DESKTOP})
terminal_group = None
for group in groups:
if group.start_ip and group.end_ip:
if terminal_ip in find_ips(group.start_ip, group.end_ip):
terminal_group = group
break
_groups = list()
if not terminal_group:
logger.error("terminal group not exist: %s" % terminal_ip)
return build_result("Success", _groups)
logger.debug(
"get education desktop terminal ip: %s, terminal_group: %s",
terminal_ip, terminal_group.uuid)
terminal_id = int(terminal_id)
# 查找分组
desktops = db_api.get_desktop_with_all({
"group_uuid": terminal_group.uuid,
"active": True
})
logger.debug("get education desktop terminal ip: %s, desktops_len: %s",
terminal_ip, len(desktops))
for desktop in desktops:
# 判断是否总数大于序号
if desktop.instance_num < terminal_id:
continue
_d = {
"uuid": desktop.uuid,
"name": desktop.name,
"desc": desktop.template.desc,
"active": desktop.active,
"order_num": desktop.order_num,
"os_type": desktop.os_type
}
_groups.append(_d)
_groups = sorted(_groups, key=lambda _groups: _groups['order_num'])
logger.debug("edu terminal_ip %s desktop group list: %s" %
(terminal_ip, _groups))
return build_result("Success", _groups)
def terminal_instance_match(self, data):
""" 所有终端ip对应的桌面ip"""
# ips = data.get("ips", "")
# ips = ips.split(",")
# terminal_ips = list()
# for i in ips:
# if not is_ip_addr(i):
# continue
# terminal_ips.append(i)
# items = {}
groups = db_api.get_group_with_all(
{"group_type": constants.EDUCATION_DESKTOP})
group_dict = dict()
for group in groups:
start_ip = group.start_ip
end_ip = group.end_ip
uuid = group.uuid
group_dict[uuid] = find_ips(start_ip, end_ip)
desktop_group_dict = {}
desktops = db_api.get_desktop_with_all_by_groups(
list(group_dict.keys()))
for i in desktops:
desktop_group_dict[i.uuid] = i.group_uuid
terminals = list()
for i in data:
terminal_ip = i["terminal_ip"]
if not is_ip_addr(terminal_ip):
continue
for uuid, ips in group_dict.items():
# start_ip = group.start_ip
# end_ip = group.end_ip
# if find_ips(start_ip, end_ip)
if terminal_ip in ips:
i["group_uuid"] = uuid
terminals.append(i)
break
# 找到所有云桌面
ret = list()
instances = db_api.get_instance_with_all(
{"classify": constants.EDUCATION_DESKTOP})
for terminal in terminals:
group_uuid = terminal["group_uuid"]
terminal_id = terminal["terminal_id"]
for instance in instances:
desktop_uuid = instance.desktop_uuid
_group_uuid = desktop_group_dict.get(desktop_uuid)
_terminal_id = instance.terminal_id
_instance_ip = instance.ipaddr
if _group_uuid == group_uuid and terminal_id == _terminal_id and _instance_ip:
terminal["desktop_ip"] = _instance_ip
ret.append(terminal)
break
return build_result("Success", ret)
def create_group(self, data):
"""
创建分组，包括教学分组和用户分组
"""
if not self._check_params(data):
return get_error_result("ParamError")
if constants.EDUCATION_DESKTOP == data.get(
'group_type', constants.EDUCATION_DESKTOP):
subnet = db_api.get_subnet_by_uuid(data['subnet_uuid'])
if not subnet:
logger.error("subnet: %s not exist", data['subnet_uuid'])
return get_error_result("SubnetNotExist")
groups = db_api.get_group_with_all({
'name': data['name'],
'group_type': data['group_type']
})
if groups:
return get_error_result("GroupAlreadyExists", name=data['name'])
# add education group
group_uuid = create_uuid()
group_value = {
"uuid": group_uuid,
"group_type": data['group_type'],
"name": data['name'],
"desc": data['desc'],
"network_uuid": data.get('network_uuid', ''),
"subnet_uuid": data.get('subnet_uuid', ''),
"start_ip": data.get('start_ip', ''),
"end_ip": data.get('end_ip', '')
}
try:
db_api.create_group(group_value)
logger.info("create group %s success", data['name'])
except Exception as e:
logging.info("insert group info to db failed:%s", e)
return get_error_result("GroupCreateError", name=data['name'])
if data['group_type'] == constants.EDUCATION_DESKTOP:
terminals = db_api.get_terminal_with_all({'group_uuid': None})
self.change_group_uuid(terminals, data.get('start_ip', ''),
data.get('end_ip', ''), group_uuid)
return get_error_result("Success", group_value)
def education_group(self, data):
terminal_ip = data.get("terminal_ip", "")
if not is_ip_addr(terminal_ip):
return build_result("ParamError")
_group = None
edu_groups = db_api.get_group_with_all(
{"group_type": constants.EDUCATION_DESKTOP})
for group in edu_groups:
start_ip = group.start_ip
end_ip = group.end_ip
if terminal_ip in find_ips(start_ip, end_ip):
_group = group
break
if not _group:
return build_result("Success")
ret = {
"name": _group.name,
"uuid": _group.uuid,
}
return build_result("Success", ret)
def terminal_group_list(self, data):
"""
终端分组
获取所有分组
:param data:
:return:
"""
items = dict()
ret = list()
groups = db_api.get_group_with_all(items)
for group in groups:
_d = dict()
_d["uuid"] = group.uuid
_d["name"] = group.name
_d["start_ip"] = group.start_ip
_d["end_ip"] = group.end_ip
_d["group_type"] = group.group_type
ret.append(_d)
return build_result("Success", ret)
def delete_subnet(self, subnet_uuids):
"""
删除子网, 批量操作
:param subnet_uuids:
:return:
"""
prompt_info = []
try:
for subnet_uuid in subnet_uuids:
### 判断子网是否已被占用
subnet = db_api.get_subnet_by_uuid(subnet_uuid)
if not subnet:
logger.error("subnet: %s not exist", subnet_uuid)
return build_result("SubnetNotExist")
templates = db_api.get_template_with_all({
'deleted':
False,
'subnet_uuid':
subnet_uuid
})
template_names = list(
map(lambda template: template.name, templates))
if len(template_names) > 0:
prompt_info.append("子网 %s 被模板 %s 所引用" %
(subnet.name, ','.join(template_names)))
continue
groups = db_api.get_group_with_all({
'deleted': False,
'subnet_uuid': subnet_uuid
})
groups_names = list(map(lambda group: group.name, groups))
if len(groups_names) > 0:
prompt_info.append("子网 %s 被分组 %s 所引用" %
(subnet.name, ','.join(groups_names)))
continue
desktops = db_api.get_desktop_with_all({
'deleted':
False,
'subnet_uuid':
subnet_uuid
})
desktop_names = list(
map(lambda desktop: desktop.name, desktops))
if len(desktop_names) > 0:
prompt_info.append("子网 %s 被桌面 %s 所引用" %
(subnet.name, ','.join(desktop_names)))
continue
personal_desktops = db_api.get_personal_desktop_with_all({
'deleted':
False,
'subnet_uuid':
subnet_uuid
})
personal_desktops_names = list(
map(lambda personal_desktop: personal_desktop.name,
personal_desktops))
if len(personal_desktops_names) > 0:
prompt_info.append(
"子网 %s 被桌面 %s 所引用" %
(subnet.name, ','.join(personal_desktops_names)))
continue
# 判断子网是否被VOI使用
voi_templates = db_api.get_voi_template_with_all({
'deleted':
False,
'subnet_uuid':
subnet_uuid
})
voi_template_names = list(
map(lambda template: template.name, voi_templates))
if len(voi_template_names) > 0:
prompt_info.append(
"子网 %s 被VOI模板 %s 所引用" %
(subnet.name, ','.join(voi_template_names)))
continue
subnet.soft_delete()
if len(prompt_info) > 0:
return build_result("SubnetDeleteInfo")
except Exception as e:
return build_result("SubnetDeleteFail")
return build_result("Success")
def person_group(self):
person_groups = db_api.get_group_with_all(
{"group_type": constants.PERSONAL_DEKSTOP})
ret = {"groups": [x.uuid for x in person_groups]}
return build_result("Success", ret)
def create(self, data):
"""
创建新学期
:param data:
{
"name": "2020年上学期",
"start": "2020/09/01",
"end": "2021/02/01",
"duration": 45,
"break_time": 10,
"morning": "08:00",
"afternoon": "14:00",
"evening": "19:00",
"morning_count": 4,
"afternoon_count": 4,
"evening_count": 2,
"course_num_map": {
"1": "08:00-08:45",
"2": "09:00-09:45",
"3": "10:00-10:45",
"4": "11:00-11:45",
"5": "14:00-14:45",
"6": "15:00-15:45",
"7": "16:00-16:45",
"8": "17:00-17:45",
"9": "19:00-19:45",
"10": "20:00-20:45"
}
}
:return:
"""
try:
logger.info("data: %s" % data)
check_ret = self._check_course_num_map(data["course_num_map"])
if check_ret:
return check_ret
check_ret = self._check_term_time_detail(data)
if check_ret:
return check_ret
if db_api.get_term_with_first({"name": data["name"]}):
return get_error_result("TermNameExist")
# 校验新学期期间是否与已有学期重叠
check_ret = self._check_term_duplicate(data["start"], data["end"])
if check_ret:
return check_ret
data["uuid"] = create_uuid()
data["weeks_num_map"] = self._generate_weeks_num_map(
data["start"], data["end"])
# 添加学期的定时任务
task_uuid = self._add_crontab_task(
term_uuid=data["uuid"],
name=data["name"],
start_date=data["start"],
end_date=data["end"],
course_num_map=data["course_num_map"],
weeks_num_map=data["weeks_num_map"])
if task_uuid:
data["crontab_task_uuid"] = task_uuid
data["course_num_map"] = json.dumps(data["course_num_map"])
data["weeks_num_map"] = json.dumps(data["weeks_num_map"])
# 新创建学期时，所有教学分组的状态默认为已启用
group_status_map = dict()
group_obj_list = db_api.get_group_with_all(
{"group_type": constants.EDUCATION_GROUP})
for group_obj in group_obj_list:
group_status_map[
group_obj.uuid] = constants.COURSE_SCHEDULE_ENABLED
data["group_status_map"] = json.dumps(group_status_map)
db_api.create_term(data)
logger.info("insert in yzy_term success: %s" % data)
return get_error_result()
else:
logger.info("add course crontab task failed")
return get_error_result("OtherError")
except Exception as e:
logger.exception("create term failed: %s" % str(e), exc_info=True)
return get_error_result("OtherError")