def _get_whitelist_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
white_id = kwargs.get('white_id', None)
issue_id = kwargs.get('issue_id', None)
close_old_connections()
try:
sql_where = {}
if white_id:
sql_where['id'] = int(white_id)
if issue_id:
sql_where['issue__id'] = int(issue_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "white_id, issue_id" key parameters!')
item = IssueWhiteListInfo.objects.get(**sql_where)
result = item
except IssueWhiteListInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def update_whitelist_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
white_id = kwargs.get('white_id', None)
is_active = kwargs.get('is_active', None)
try:
sql_where = {}
if white_id:
sql_where['id'] = int(white_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "white_id" key parameters!')
item = IssueWhiteListInfo.objects.get(**sql_where)
if item:
if is_active:
item.is_active = True
else:
item.is_active = False
item.save()
cache.set('{0}:{1}'.format(ISSUE_CACHE[1], item.id), None, 0)
result = item
except IssueWhiteListInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_member_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
git_id = kwargs.get('git_id', None)
member_id = kwargs.get('member_id', None)
username = kwargs.get('username', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if member_id:
sql_where['id'] = int(member_id)
if username:
sql_where['username'] = username.strip()
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "member_id, git_id, username" key parameters!')
item = MemberInfo.objects.filter(**sql_where).first()
result = item
except MemberInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_crontab(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
cron_expression = kwargs.get('cron_expression', None)
cron_id = kwargs.get('cron_id', None)
close_old_connections()
try:
if cron_expression:
cron_expression = cron_expression.strip()
minute, hour, day_of_week, day_of_month, month_of_year = cron_expression.split(
' ')
result = CrontabSchedule.objects.get(minute=minute,
hour=hour,
day_of_week=day_of_week,
day_of_month=day_of_month,
month_of_year=month_of_year)
if cron_id:
result = CrontabSchedule.objects.get(id=int(cron_id))
except CrontabSchedule.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_engine_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
engine_id = kwargs.get('engine_id', None)
module_name = kwargs.get('module_name', None)
close_old_connections()
try:
sql_where = {}
if engine_id:
sql_where['id'] = int(engine_id)
if module_name:
sql_where['module_name'] = module_name
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "engine_id" key parameters!')
item = EngineInfo.objects.get(**sql_where)
result = item
except EngineInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_node_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
node_id = kwargs.get('node_id', None)
hostname = kwargs.get('hostname', None)
ipv4 = kwargs.get('ipv4', None)
close_old_connections()
try:
sql_where = {}
if node_id:
sql_where['id'] = int(node_id)
if hostname:
sql_where['hostname'] = hostname
if ipv4:
sql_where['ipv4'] = ipv4
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "node_id, hostname" key parameters!')
item = HostInfo.objects.get(**sql_where)
result = item
except HostInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_repository_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
repo_id = kwargs.get('repo_id', None)
name = kwargs.get('name', None)
project_id = kwargs.get('project_id', None)
close_old_connections()
try:
sql_where = {}
if repo_id:
sql_where['id'] = int(repo_id)
if name:
sql_where['name'] = name.strip()
if project_id:
sql_where['project__id'] = project_id
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "repo_id, name, project_id" key parameters!')
item = RepositoryInfo.objects.filter(**sql_where).first()
result = item
except RepositoryInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_lang_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
lang_id = kwargs.get('lang_id', None)
name = kwargs.get('name', None)
key = kwargs.get('key', None)
close_old_connections()
try:
sql_where = {}
if name:
sql_where['name__iexact'] = name.strip()
if key:
sql_where['key'] = key.lower()
if lang_id:
sql_where['id'] = int(lang_id)
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "lang_id, name, key" key parameters!')
item = LanguageInfo.objects.get(**sql_where)
result = item
except LanguageInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_tactic_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
tactic_id = kwargs.get('tactic_id', None)
name = kwargs.get('name', None)
key = kwargs.get('key', None)
attribution_type = kwargs.get('attribution_type', None)
close_old_connections()
try:
sql_where = {}
if tactic_id:
sql_where['id'] = int(tactic_id)
if name:
sql_where['name'] = name
if key:
sql_where['key'] = key
if attribution_type:
sql_where['attribution_type'] = int(attribution_type)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "tactic_id, name, key" key parameters!')
result = TacticInfo.objects.filter(**sql_where).first()
except TacticInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_project_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
git_id = kwargs.get('git_id', None)
project_id = kwargs.get('project_id', None)
name = kwargs.get('name', None)
ssh_url = kwargs.get('ssh_url', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if project_id:
sql_where['id'] = int(project_id)
if name:
sql_where['name'] = name.strip()
if ssh_url:
sql_where['ssh_url_to_repo__iexact'] = ssh_url.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "project_id, git_id, name" key parameters!')
item = ProjectInfo.objects.get(**sql_where)
result = item
except ProjectInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_vuln_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
vuln_id = kwargs.get('vuln_id', None)
title = kwargs.get('title', None)
cve = kwargs.get('cve', None)
close_old_connections()
try:
sql_where = {}
if vuln_id:
sql_where['id'] = int(vuln_id)
if title:
sql_where['title'] = title.strip()
if cve:
sql_where['cve'] = cve.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "vuln_id, title" key parameters!')
item = VulnInfo.objects.get(**sql_where)
result = item
except VulnInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def update_tag_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
tag_id = kwargs.get('tag_id', None)
name = kwargs.get('name', None)
try:
sql_where = {}
if tag_id:
sql_where['id'] = int(tag_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "tag_id" key parameters!')
item = TagInfo.objects.get(**sql_where)
if item:
item.name = name.strip()
item.save()
result = item
except TagInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_statistics_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
stat_id = kwargs.get('stat_id', None)
language = kwargs.get('language', None)
app_id = kwargs.get('app_id', None)
close_old_connections()
try:
sql_where = {}
if stat_id:
sql_where['id'] = int(stat_id)
if language:
sql_where['language__iexact'] = language.strip()
if app_id:
sql_where['app__id'] = int(app_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "stat_id, language, app_id" key parameters!')
item = FileStatisticsInfo.objects.get(**sql_where)
result = item
except FileStatisticsInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_app_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
app_id = kwargs.get('app_id', None)
module_name = kwargs.get('module_name', None)
app_name = kwargs.get('app_name', None)
project_id = kwargs.get('project_id', None)
close_old_connections()
try:
sql_where = {}
if app_id:
sql_where['id'] = int(app_id)
if project_id:
sql_where['project__id'] = int(project_id)
if module_name:
sql_where['module_name__iexact'] = module_name.lower().strip()
if app_name:
sql_where['app_name__iexact'] = app_name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "app_id, module_name, app_name" key parameters!')
item = ApplicationInfo.objects.filter(**sql_where).first()
result = item
except ApplicationInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_tag_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
tag_id = kwargs.get('tag_id', None)
parent_id = kwargs.get('parent_id', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if tag_id:
sql_where['id'] = int(tag_id)
if parent_id:
sql_where['parent__id'] = int(parent_id)
if name:
sql_where['name'] = name
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "parent_id, name" key parameters!')
item = TagInfo.objects.get(**sql_where)
result = item
except TagInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_periodic_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
periodic_id = kwargs.get('periodic_id', None)
task = kwargs.get('task', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if periodic_id:
sql_where['id'] = int(periodic_id)
if task:
sql_where['task'] = task.strip()
if name:
sql_where['name'] = name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "periodic_id, task, name" key parameters!')
item = PeriodicTask.objects.get(**sql_where)
result = item
except PeriodicTask.DoesNotExist as ex:
logger.warning(ex)
return result
def update_app_lang(**kwargs):
"""
:param kwargs:
:return:
"""
result = False
app_id = kwargs.get('app_id', None)
lang = kwargs.get('lang', None)
size = kwargs.get('size', None)
status = kwargs.get('status', None)
code_total = kwargs.get('code_total', None)
try:
if lang:
lang_obj = get_lang_by_name(name=lang)
result = update_app_obj(
app_id=app_id,
lang_obj=lang_obj,
size=size,
code_total=code_total,
status=status,
)
except Exception as ex:
logger.warning(ex)
return result
def _get_group_member_perm(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
member_id = kwargs.get('member_id', None)
group_id = kwargs.get('group_id', None)
close_old_connections()
try:
sql_where = {}
if member_id:
sql_where['member__id'] = int(member_id)
if group_id:
sql_where['group__id'] = int(group_id)
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "member_id, group_id" key parameters!')
result = GroupPermissionInfo.objects.get(**sql_where)
except GroupPermissionInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_pro_member_perm(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
member_id = kwargs.get('member_id', None)
project_id = kwargs.get('project_id', None)
close_old_connections()
try:
sql_where = {}
if member_id:
sql_where['member__id'] = int(member_id)
if project_id:
sql_where['project__id'] = int(project_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "member_id, project_id" key parameters!')
result = ProjectPermissionInfo.objects.filter(**sql_where).first()
except ProjectPermissionInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_sched_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
sched_id = kwargs.get('sched_id', None)
close_old_connections()
try:
sql_where = {}
if sched_id:
sql_where['id'] = int(sched_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "sched_id" key parameters!')
item = SchedInfo.objects.get(**sql_where)
result = item
except SchedInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_group_obj(**kwargs):
"""
:param kwargs:
:return:
"""
git_id = kwargs.get('git_id', None)
group_id = kwargs.get('group_id', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if group_id:
sql_where['id'] = int(group_id)
if name:
sql_where['name'] = name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "group_id, git_id, name" key parameters!')
item = GroupInfo.objects.filter(**sql_where).first()
return item
except GroupInfo.DoesNotExist as ex:
logger.warning(ex)
return None
def delete_group_obj(group_id):
"""
:param group_id:
:return:
"""
try:
GroupInfo.objects.get(id=int(group_id)).delete()
return True
except Exception as ex:
logger.warning(ex)
return False
def update_statistics_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
stat_id = kwargs.get('stat_id', None)
files = kwargs.get('files', None)
blank = kwargs.get('blank', None)
comment = kwargs.get('comment', None)
code = kwargs.get('code', None)
if files:
files = int(files)
if blank:
blank = int(blank)
if comment:
comment = int(comment)
if code:
code = int(code)
try:
sql_where = {}
if stat_id:
sql_where['id'] = int(stat_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "stat_id" key parameters!')
item = FileStatisticsInfo.objects.get(**sql_where)
if item:
if files:
item.files = files
if blank:
item.blank = blank
if comment:
item.comment = comment
if code:
item.code = code
item.save()
cache.set('{0}:{1}'.format(PROJECT_APP_CACHE[3], item.id), None, 0)
result = item
except FileStatisticsInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_or_update_hostservice(**kwargs):
"""
:param kwargs:
:return:
"""
result = False
ipv4 = kwargs.get('ipv4', None)
key = kwargs.get('key', None)
ppid = kwargs.get('ppid', None)
pid = kwargs.get('pid', None)
status = kwargs.get('status', None)
if not all((ipv4, key)):
raise QueryConditionIsEmptyException(
u'Missing "ipv4, key" key parameters!')
close_old_connections()
try:
host = HostInfo.objects.filter(ipv4=ipv4).first()
service = ServiceInfo.objects.filter(key=key).first()
if host and service:
host_service = HostServiceInfo.objects.filter(
host_id=host.id, service_id=service.id).first()
if host_service:
host_service.status = status
host_service.ppid = ppid
host_service.pid = pid
host_service.save()
result = True
else:
host_service = HostServiceInfo(
host=host,
service=service,
status=status,
ppid=ppid,
pid=pid,
)
host_service.save()
result = True
except Exception as ex:
import traceback
traceback.print_exc()
logger.warning(ex)
return result
def create_or_update_host(**kwargs):
"""
:param kwargs:
:return:
"""
result = False
hostname = kwargs.get('hostname', None)
ipv4 = kwargs.get('ipv4', None)
ipv6 = kwargs.get('ipv6', None)
role = kwargs.get('role', 'client')
ui_version = kwargs.get('ui_version', '')
client_version = kwargs.get('client_version', '')
close_old_connections()
try:
sql_where = {}
if ipv4:
sql_where['ipv4'] = ipv4
if ipv6:
sql_where['ipv6'] = ipv6
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "ipv4, ipv6" key parameters!')
item = HostInfo.objects.filter(**sql_where).first()
if item:
if hostname:
item.hostname = hostname.strip()
if ui_version:
item.ui_version = ui_version.strip()
if client_version:
item.client_version = client_version.strip()
item.save()
result = True
else:
create_host_obj(**kwargs)
result = True
except HostInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_interval(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
seconds = kwargs.get('seconds', None)
interval_id = kwargs.get('interval_id', None)
close_old_connections()
try:
if seconds:
seconds = int(seconds.strip())
result = IntervalSchedule.objects.get(every=seconds * 60,
period='seconds')
if interval_id:
result = IntervalSchedule.objects.get(id=int(interval_id))
except IntervalSchedule.DoesNotExist as ex:
logger.warning(ex)
return result
def get_groups(self):
"""
获得所有分组
:return:
"""
result = []
page_size = 100
status_code, total_page, contents = self._get_groups(
per_page=page_size)
for page in range(1, total_page + 1):
if page != 1:
status_code, _, contents = self._get_groups(per_page=page_size,
page=page)
if status_code == 200:
result.extend(contents)
else:
logger.warning('同步项目分组发生错误, {0}'.format(contents))
return result
def get_members_by_group(self, group_id):
"""
获得指定分组下的所有成员
:param group_id: 分组id
:return:
"""
result = []
page_size = 100
status_code, total_page, contents = self._get_members_by_group(
group_id=group_id, per_page=page_size)
for page in range(1, total_page + 1):
if page != 1:
status_code, _, contents = self._get_members_by_group(
group_id=group_id, per_page=page_size, page=page)
if status_code == 200:
result.extend(contents)
else:
logger.warning('同步分组成员发生错误, {0}'.format(contents))
return result
def get_branches(self, project_id):
"""
获取项目中的 branches, https://git.example.com/api/v3/projects/:id/repository/branches
:param project_id:
:return:
"""
result = []
page_size = 100
status_code, total_page, contents = self._get_branches(
project_id=project_id, per_page=page_size)
for page in range(1, total_page + 1):
if page != 1:
status_code, _, contents = self._get_branches(
project_id=project_id, per_page=page_size, page=page)
if status_code == 200:
for item in contents:
yield item
else:
logger.warning('获取项目分支发生错误, {0}'.format(contents))
return result
def update_dependent_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
dep_id = kwargs.get('dep_id', None)
version = kwargs.get('version', '')
new_version = kwargs.get('new_version', '')
description = kwargs.get('description', '')
language = kwargs.get('language', '')
try:
sql_where = {}
if dep_id:
sql_where['id'] = int(dep_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "dep_id" key parameters!')
item = DependentInfo.objects.get(**sql_where)
if item:
if version:
item.version = version
if new_version:
item.new_version = new_version
if description:
item.description = description.strip()
if language:
item.language = language.strip()
item.save()
cache.set('{0}:{1}'.format(PROJECT_APP_CACHE[2], item.id), None, 0)
result = item
except DependentInfo.DoesNotExist as ex:
logger.warning(ex)
return result
