def get_fuzzy_tenants_by_tenant_alias(self, tenant_alias):
tenant_alias_map = list(Tenants.objects.values("tenant_alias"))
tenant_alias_list = map(lambda x: x.get("tenant_alias", "").lower(), tenant_alias_map)
find_tenant_alias = list(fuzzyfinder(tenant_alias.lower(), tenant_alias_list))
tenant_query = Q(tenant_alias__in=find_tenant_alias)
tenant_list = Tenants.objects.filter(tenant_query)
return tenant_list
def get_fuzzy_tenants_by_tenant_name(self, tenant_name):
tenant_name_map = list(Tenants.objects.values("tenant_name"))
tenant_name_list = map(lambda x: x.get("tenant_name", "").lower(), tenant_name_map)
find_tenant_name = list(fuzzyfinder(tenant_name.lower(), tenant_name_list))
tenant_query = Q(tenant_name__in=find_tenant_name)
tenant_list = Tenants.objects.filter(tenant_query)
return tenant_list
def get_fuzzy_labels(self, label_alias):
label_alias_map = list(Labels.objects.values("label_alias"))
label_alias_list = map(lambda x: x.get("label_alias", "").lower(), label_alias_map)
find_label_alias = list(fuzzyfinder(label_alias.lower(), label_alias_list))
label_query = Q(label_alias__in=find_label_alias)
label_list = Labels.objects.filter(label_query)
return label_list
def get_completions(self, document, complete_event):
"""
Get command completion
:param document:
:param complete_event:
:return:
"""
# fix input
cmd = next(csv.reader([" ".join(document.text.split())], delimiter=' '))
# get current word
word_before_cursor = document.get_word_before_cursor(WORD=True)
# suggest keywords
suggestions = list()
if self.need_param(cmd=cmd, word_before_cursor=word_before_cursor):
param = self.get_param(cmd=cmd, word_before_cursor=word_before_cursor)
if self.thread_state in [StateEnum.START, StateEnum.CONTINUE]:
if param in ['--project-name', '--dataset-name', '--remote-path']:
thread = threading.Thread(target=self.get_param_suggestions,
kwargs={"param": param,
'word_before_cursor': word_before_cursor,
'cmd': cmd})
thread.daemon = True
thread.start()
else:
self.get_param_suggestions(param=param, word_before_cursor=word_before_cursor, cmd=cmd)
if self.thread_state in [StateEnum.DONE, StateEnum.CONTINUE]:
suggestions = self.param_suggestions
elif len(cmd) == 0:
suggestions = list(self.keywords.keys())
elif len(cmd) == 1:
self.thread_state = StateEnum.START
if cmd[0] not in self.keywords.keys() and cmd[0] != '':
if not word_before_cursor == '':
suggestions = list(self.keywords.keys())
elif cmd[0] == '':
suggestions = list(self.keywords.keys())
elif isinstance(self.keywords[cmd[0]], list):
suggestions = self.keywords[cmd[0]]
elif isinstance(self.keywords[cmd[0]], dict):
suggestions = list(self.keywords[cmd[0]].keys())
elif len(cmd) >= 2:
self.thread_state = StateEnum.START
if cmd[0] not in self.keywords.keys():
suggestions = list()
elif isinstance(self.keywords[cmd[0]], list):
suggestions = self.keywords[cmd[0]]
elif isinstance(self.keywords[cmd[0]], dict):
if cmd[1] in self.keywords[cmd[0]].keys():
suggestions = self.keywords[cmd[0]][cmd[1]]
else:
suggestions = list(self.keywords[cmd[0]].keys())
matches = fuzzyfinder(word_before_cursor, suggestions)
for match in matches:
yield Completion(match, start_position=-len(word_before_cursor))
def fuzzy_query_enterprise_by_enterprise_name(self, enterprise_name):
enter_name_map = list(
TenantEnterprise.objects.values("enterprise_name"))
enter_name_list = map(lambda x: x.get("enterprise_name", "").lower(),
enter_name_map)
find_enter_name = list(
fuzzyfinder(enterprise_name.lower(), enter_name_list))
tenant_query = Q(enterprise_name__in=find_enter_name)
tenant_list = TenantEnterprise.objects.filter(tenant_query)
return tenant_list
def fuzzy_query_enterprise_by_enterprise_alias(self, enterprise_alias):
enter_alias_map = list(
TenantEnterprise.objects.values("enterprise_alias"))
enter_alias_list = map(lambda x: x.get("enterprise_alias", "").lower(),
enter_alias_map)
find_enter_alias = list(
fuzzyfinder(enterprise_alias.lower(), enter_alias_list))
tenant_query = Q(enterprise_alias__in=find_enter_alias)
tenant_list = TenantEnterprise.objects.filter(tenant_query)
return tenant_list
def get_fuzzy_users(self, user_name, tenant_name):
# 如果租户名存在
if tenant_name:
tenants = Tenants.objects.filter(tenant_name=tenant_name)
if not tenants:
raise TenantNotExistError("租户{}不存在".format(tenant_name))
tenant = tenants[0]
user_id_list = PermRelTenant.objects.filter(tenant_id=tenant.ID).values_list("user_id", flat=True)
user_list = Users.objects.filter(user_id__in=user_id_list)
user_name_list = map(lambda x: x.nick_name.lower(), user_list)
else:
user_name_map = list(Users.objects.values("nick_name"))
user_name_list = map(lambda x: x.get("nick_name").lower(), user_name_map)
find_user_name = list(fuzzyfinder(user_name.lower(), user_name_list))
user_query = Q(nick_name__in=find_user_name)
user_list = Users.objects.filter(user_query)
return user_list
def get_completions(self, document, complete_event):
word_before_cursor = document.get_word_before_cursor(WORD=True)
matches = fuzzyfinder(word_before_cursor, GitlabCLIKeywords)
for m in matches:
yield Completion(m, start_position=-len(word_before_cursor))
def handle(self, *args, **options):
conference = Conference.objects.get(year=options['year'])
data = requests.get(options['data_url']).json()
questions = data['questions']
categories = data['categories']
rooms = data['rooms']
# Sync rooms
Room.objects.filter(conference=conference).delete()
Slot.objects.filter(conference=conference).delete()
all_presentations_this_year = list(
Presentation.objects.filter(conference=conference).values_list(
"id", "title"))
for room in rooms:
Room.objects.create(pk=room['id'],
conference=conference,
name=room['name'],
sort_order=room['sort'])
# Make speaker dict
speakers = {}
for _ in data['speakers']:
first_name = _.pop('firstName')
last_name = _.pop('lastName')
speakers[f"{first_name} {last_name}"] = _
for speaker in speakers.values():
for i, session in enumerate(speaker['sessions']):
speaker['sessions'][i] = list(
filter(lambda _: int(_['id']) == session,
data['sessions']))[0]
# Attach Speaker obj from DB
speakers_qs = Speaker.objects.all().prefetch_related(
Prefetch("presentations",
queryset=Presentation.objects.filter(
active=True, conference=conference).order_by("type")))
_cant_find = []
for speaker in speakers_qs:
if not any(speaker.presentations.all()):
continue
r = list(fuzzyfinder(speaker.full_name, speakers.keys()))
if not any(r):
_cant_find.append(speaker)
continue
speakers[r[0]]["model_speaker"] = speaker
speaker = speakers[r[0]]
for _ in speaker['sessions']:
r = list(
fuzzyfinder(_['title'],
list(zip(*all_presentations_this_year))[1]))
if not any(r):
_cant_find.append(_)
try:
presentation = Presentation.objects.get(
title__icontains=_['title'])
except Presentation.DoesNotExist:
_cant_find.append(_)
# TODO NEXT YEAR MAYBE, GET TZ FROM CONFERENCE OBJECT ?!
Slot.objects.create(from_date=timezone.make_aware(
datetime.strptime(_['startsAt'], "%Y-%m-%dT%H:%M:%S")),
to_date=timezone.make_aware(
datetime.strptime(
_['endsAt'], "%Y-%m-%dT%H:%M:%S")),
talk=presentation,
room=Room.objects.get(pk=_['roomId']),
conference=conference)
if any(_cant_find):
if options['force']:
print(_cant_find)
else:
raise Exception("Had problems with the following", _cant_find)
