def create(self, request, *args, **kwargs):
logger.info("TRY CREATE CHATBOT ||" + create_log_content(request))
# Django 에서는 request의 body로 들어온 정보를 변환하지 못하도록 막았기 때문에 이를 풀어줌
mutable = request.POST._mutable
request.POST._mutable = True
chat_log_data = request.data
now_date_time = datetime.now()
# 필드 중 생성 날짜. 시간들에 대한 정보를 클라이언트가 아닌 서버에서 생성
create_date_time = "%04d%02d%02d%02d%02d%02d" % (
now_date_time.year,
now_date_time.month,
now_date_time.day,
now_date_time.hour,
now_date_time.minute,
now_date_time.second
)
# 20191123 => 2019년 11월 23
create_date = create_date_time[:8]
# 193043일 => 19시 30분 43초
create_time = create_date_time[8:]
chat_log_data['createDateTime'] = create_date_time
chat_log_data['createDate'] = create_date
chat_log_data['createTime'] = create_time
# 생성 날짜, 시간에 대한 정보를 바꾸었으니 다시 원상 복구
request.POST._mutable = mutable
# 이 데이터를 토대로 채팅 생성
return CreateModelMixin.create(self, request, *args, **kwargs)
def list(self, request, *args, **kwargs):
logger.info("TRY LIST SI GUN GU ||" + create_log_content(request))
existing_queryset = self.queryset
query_dict = request.GET
si_do_id = query_dict.get('sidoid')
if si_do_id is not None:
select_si_gun_gu_with_si_do_query = """
SELECT * FROM Sigungu
JOIN Address ON Sigungu.sigunguid = Address.sigunguid
WHERE Address.sidoid = (%s)
AND Sigungu.siGunGuId != (%s)
ORDER BY siGunGuName
"""
bon_cheung_id = '9999999'
select_si_gun_gu_with_si_do_query = select_si_gun_gu_with_si_do_query % (
si_do_id, bon_cheung_id)
existing_queryset = SiGunGu.objects.raw(
select_si_gun_gu_with_si_do_query)
self.queryset = existing_queryset
return ListModelMixin.list(self, request, *args, **kwargs)
def create(self, request, *args, **kwargs):
logger.info("TRY CREATE WELFARE ||" + create_log_content(request))
welfare_data = request.data
disables = welfare_data.get('disables', [])
house_types = welfare_data.get('houseTypes', [])
desires = welfare_data.get('desires', [])
target_characters = welfare_data.get('targetCharacters', [])
life_cycles = welfare_data.get('lifeCycles', [])
responsibles = welfare_data.get('responsibles', [])
# 유효성 검사를 거치지않는 필드들에 대해서 따로 검사
try:
for disable in disables:
Disable.objects.get(disableId=disable)
for house_type in house_types:
HouseType.objects.get(houseTypeId=house_type)
for desire in desires:
Desire.objects.get(desireId=desire)
for target_character in target_characters:
TargetCharacter.objects.get(targetCharacterId=target_character)
for life_cycle in life_cycles:
LifeCycle.objects.get(lifeCycleId=life_cycle)
for responsible in responsibles:
Responsible.objects.get(responsibleId=responsible)
except Disable.DoesNotExist or Welfare.DoesNotExist or HouseType.DoesNotExist or TargetCharacter.DoesNotExist \
or LifeCycle.DoesNotExist or Responsible.DoesNotExist:
return Response(status=status.HTTP_400_BAD_REQUEST)
return CreateModelMixin.create(self, request, *args, **kwargs)
def retrieve(self, request, *args, **kwargs):
logger.info("TRY RETRIEVE MEMBER" + create_log_content(request))
instance = self.get_object()
serializer = self.get_serializer(instance)
serializer_data = serializer.data
member_data = self.changeAddressToString(serializer_data)
decrypt_member_data = self.decryptMemberData(
social_id=instance.socialId, member_data=member_data)
return Response(decrypt_member_data)
def list(self, request, *args, **kwargs):
logger.info("TRY LIST WELFARE ||" + create_log_content(request))
existing_queryset = self.queryset
query_dict = request.GET
pagination_class = PageNumberPagination
disable = query_dict.get('disable')
house_type = query_dict.get('houseType')
desire = query_dict.get('desire')
target_character = query_dict.get('targetCharacter')
life_cycle = query_dict.get('lifeCycle')
responsible = query_dict.get('responsible')
welfare_address_id = query_dict.get('welAddressId')
search = query_dict.get('search')
offset = query_dict.get('offset')
if disable is not None:
existing_queryset = existing_queryset.filter(disables__disableId=disable)
if house_type is not None:
existing_queryset = existing_queryset.filter(houseTypes__houseTypeId=house_type)
if desire is not None:
existing_queryset = existing_queryset.filter(desires__desireId=desire)
if target_character is not None:
existing_queryset = existing_queryset.filter(targetCharacters__targetCharacterId=target_character)
if life_cycle is not None:
existing_queryset = existing_queryset.filter(lifeCycles__lifeCycleId=life_cycle)
if responsible is not None:
existing_queryset = existing_queryset.filter(responsibles_responsibleId=responsible)
if welfare_address_id is not None:
existing_queryset = existing_queryset.filter(welAddressId__addressId=welfare_address_id)
if offset is not None:
pagination_class.page_size = offset
else:
pagination_class.page_size = 10
if search is not None:
existing_queryset = Welfare.objects.filter(
Q(welName__icontains=search) | Q(welSummary__icontains=search) | Q(targetDetail__icontains=search))
self.queryset = existing_queryset
return ListModelMixin.list(self, request, *args, **kwargs)
def list(self, request, *args, **kwargs):
logger.info("TRY LIST MEMBER" + create_log_content(request))
new_queryset = Member.objects.all()
# 보안성을 위해 배포시에 주석 해제
# new_queryset = Member.objects.filter(socialId=None)
social_id = request.GET.get('socialId', None)
if social_id is not None:
try:
instance = Member.objects.get(socialId=social_id)
except Member.DoesNotExist:
message = {'message': '해당하는 socialId가 존재하지 않습니다.'}
return Response(message, status=status.HTTP_404_NOT_FOUND)
serializer = self.get_serializer(instance)
serializer_data = serializer.data
member_data = self.changeAddressToString(serializer_data)
decrypt_member_data = self.decryptMemberData(
social_id=social_id, member_data=member_data)
return Response(decrypt_member_data)
self.queryset = new_queryset
return ListModelMixin.list(self, request, *args, **kwargs)
def update(self, request, *args, **kwargs):
logger.info("TRY UPDATE WELFARE ||" + create_log_content(request))
welfare_data = request.data
disables = welfare_data.get('disables')
welfares = welfare_data.get('welfares')
house_types = welfare_data.get('houseTypes')
desires = welfare_data.get('desires')
target_characters = welfare_data.get('targetCharacters')
life_cycles = welfare_data.get('lifeCycles')
responsibles = welfare_data.get('responsibles')
# 유효성 검사를 거치지않는 필드들에 대해서 따로 검사
try:
for disable in disables:
Disable.objects.get(disableId=disable)
for welfare in welfares:
Welfare.objects.get(welId=welfare)
for house_type in house_types:
HouseType.objects.get(houseTypeId=house_type)
for desire in desires:
Desire.objects.get(desireId=desire)
for target_character in target_characters:
TargetCharacter.objects.get(targetCharacterId=target_character)
for life_cycle in life_cycles:
LifeCycle.objects.get(lifeCycleId=life_cycle)
for responsible in responsibles:
Responsible.objects.get(responsibleId=responsible)
except Disable.DoesNotExist or Welfare.DoesNotExist or HouseType.DoesNotExist or TargetCharacter.DoesNotExist \
or LifeCycle.DoesNotExist or Responsible.DoesNotExist:
return Response(status=status.HTTP_400_BAD_REQUEST)
# 부분적인 업데이트를 한다는 것을 serializer에게 알려줌
kwargs['partial'] = True
return UpdateModelMixin.partial_update(self, request, *args, **kwargs)
def create(self, request, *args, **kwargs):
logger.info("TRY CREATE MEMBER" + create_log_content(request))
# Django 에서는 request의 body로 들어온 정보를 변환하지 못하도록 막았기 때문에 이를 풀어줌
mutable = request.POST._mutable
request.POST._mutable = True
member_data = request.data
social_id = member_data['socialId']
salting_with_social_id = 'hoxymetoo_' + social_id
now_datetime = datetime.now()
jobs = member_data.get('jobs', [])
disables = member_data.get('disables', [])
welfares = member_data.get('welfares', [])
house_types = member_data.get('houseTypes', [])
desires = member_data.get('desires', [])
target_characters = member_data.get('targetCharacters', [])
life_cycles = member_data.get('lifeCycles', [])
# 유효성 검사를 거치지않는 필드들에 대해서 따로 검사
try:
for job in jobs:
Job.objects.get(jobId=job)
for disable in disables:
Disable.objects.get(disableId=disable)
for welfare in welfares:
Welfare.objects.get(welId=welfare)
for house_type in house_types:
HouseType.objects.get(houseTypeId=house_type)
for desire in desires:
Desire.objects.get(desireId=desire)
for target_character in target_characters:
TargetCharacter.objects.get(targetCharacterId=target_character)
for life_cycle in life_cycles:
LifeCycle.objects.get(lifeCycleId=life_cycle)
except Job.DoesNotExist or Disable.DoesNotExist or Welfare.DoesNotExist or HouseType.DoesNotExist or \
Desire.DoesNotExist or TargetCharacter.DoesNotExist or LifeCycle.DoesNotExist:
logger.error("ERROR with field associated with CREATE MEMBER" +
create_log_content(request))
return Response(status=status.HTTP_400_BAD_REQUEST)
# 필드 중 생성 날짜. 시간들에 대한 정보를 클라이언트가 아닌 서버에서 생성
create_date_time = "%04d%02d%02d%02d%02d%02d" % (
now_datetime.year, now_datetime.month, now_datetime.day,
now_datetime.hour, now_datetime.minute, now_datetime.second)
create_date = create_date_time[:8]
create_time = create_date_time[8:]
mem_key = hashlib.sha256(salting_with_social_id.encode()).hexdigest()
member_data['memKey'] = mem_key
member_data['createDateTime'] = create_date_time
member_data['updateDateTime'] = create_date_time
member_data['createDate'] = create_date
member_data['updateDate'] = create_date
member_data['createTime'] = create_time
member_data['updateTime'] = create_time
# mutable 원상복구
request.POST._mutable = mutable
# 이 데이터를 토대로 멤버 생성
CreateModelMixin.create(self, request, *args, **kwargs)
instance = Member.objects.get(socialId=social_id)
serializer = self.get_serializer(instance)
serializer_data = serializer.data
list_of_welfare_of_recommend = self.select_welfare_of_member(social_id)
for welfare_of_recommend in list_of_welfare_of_recommend:
MemWelfare.objects.get_or_create(socialId=instance,
welId=welfare_of_recommend)
member_data = self.changeAddressToString(serializer_data)
decrypt_member_data = self.decryptMemberData(social_id=social_id,
member_data=member_data)
return Response(decrypt_member_data)
def update(self, request, *args, **kwargs):
logger.info("TRY UPDATE SI DO ||" + create_log_content(request))
return super().update(self, request, *args, **kwargs)
def retrieve(self, request, *args, **kwargs):
logger.info("TRY RETRIEVE SI DO ||" + create_log_content(request))
return super().retrieve(self, request, *args, **kwargs)
def list(self, request, *args, **kwargs):
logger.info("TRY LIST SI DO ||" + create_log_content(request))
return super().list(self, request, *args, **kwargs)
def create(self, request, *args, **kwargs):
logger.info("TRY CREATE ADDRESS ||" + create_log_content(request))
return super().create(self, request, *args, **kwargs)
def list(self, request, *args, **kwargs):
logger.info("TRY LIST CHATBOT ||" + create_log_content(request))
chat_data = request.GET
receiver_member_key = chat_data.get('receiverMemKey', None)
sender_member_key = chat_data.get('senderMemKey', None)
search = chat_data.get('search', None)
# queryset과 serializer_class를 재지정 시작
# 챗봇을 보낸 사람을 기준으로 list를 호출할 때,
if receiver_member_key is None and sender_member_key is not None:
new_queryset = ChatLog.objects.filter(senderMemKey__memKey=sender_member_key)
new_serializer_class = ChatLogSenderSerializer
self.queryset = new_queryset
self.serializer_class = new_serializer_class
# 챗봇을 받은 사람을 기준으로 list를 호출할 때,
elif receiver_member_key is not None and sender_member_key is None:
new_queryset = ChatLog.objects.filter(receiverMemKey__memKey=receiver_member_key)
new_serializer_class = ChatLogReceiverSerializer
self.queryset = new_queryset
self.serializer_class = new_serializer_class
# queryset과 serializer_class를 재지정 끝
# search로 파라미터를 받았을 때는 토큰화를 통해 word2vec을 이용하여 복지 검색
if search is not None:
from gensim.models import Word2Vec
from konlpy.tag import Okt
import sys
# tagger class를 Okt를 이
okt = Okt()
# 단어 토큰화
token_list = okt.pos(phrase=search, stem=True, norm=True)
model = Word2Vec.load(f'{sys.path[0]}/chatbot/word2vec.model')
dict_similar_tokens = dict()
# 일치율이 높은 3개의 단어만 추출
n = 3
# 총 3개 이상의 인덱스가 겹치는 복지의 경우만 반환
total_count = 3
for token in token_list:
if token[1] in ['Noun']:
# 사용자의 질문자체를 이용한 유사한 단어 추출
try:
similar_tokens = model.wv.most_similar(token[0])
# 모델에 있지않은 단어의 경우 그냥 계속 작동
except KeyError:
continue
# 사용자의 질문자체에서 뽑힌 단어중 일치율이 높은 n개의 단어만 추출
if similar_tokens:
dict_similar_tokens[token[0]] = similar_tokens[:n]
recommend_welfare = dict()
# ('육아', ('도우미', 0.7666430473327637))
for key, similar_keys in dict_similar_tokens.items():
# 사용자의 질문자체의 Noun에 대한 index정보 획득
try:
recommend_index = Index.objects.get(indexName=key)
# 사용자의 질문자체가 인덱스로 등록 안되어있는 경우에 대한 예외처
except Index.DoesNotExist:
recommend_index = 1560
# 사용자의 질문자체의 Noun에 대한 index를 갖는 복지들 획득
list_recommend_welfare_index = WelIndex.objects.filter(indexId=recommend_index)
for recommend_welfare_index in list_recommend_welfare_index:
welfare_count = recommend_welfare.get(recommend_welfare_index.welId.welId)
# 처음 검색된 복지일 때, 카운트 = 1
if welfare_count is None:
recommend_welfare[recommend_welfare_index.welId.welId] = 1
# 이미 찾아진 복지일 떄, 카운트 += 1
else:
recommend_welfare[recommend_welfare_index.welId.welId] = welfare_count + 1
# 사용자의 질문과 일치율이 높은 단어들에 대해서
for similar_key in similar_keys:
# 일치율이 높은 단어에 대한 index정보 획득
try:
recommend_index = Index.objects.get(indexName=similar_key[0])
except Index.DoesNotExist:
recommend_index = 1560
# 일치율이 높은 단어에 대한 index를 갖는 복지들 획득
list_recommend_welfare_index = WelIndex.objects.filter(indexId=recommend_index)
for recommend_welfare_index in list_recommend_welfare_index:
welfare_count = recommend_welfare.get(recommend_welfare_index.welId.welId)
# 처음 검색된 복지일 때, 카운트 = 1
if welfare_count is None:
recommend_welfare[recommend_welfare_index.welId.welId] = 1
# 이미 찾아진 복지일 떄, 카운트 += 1
else:
recommend_welfare[recommend_welfare_index.welId.welId] = welfare_count + 1
# 카운트가 높은 순으로 정렬
recommend_welfares_sorted_by_count_desc = sorted(recommend_welfare, key=recommend_welfare.get, reverse=True)
# 카운트가 특정 수를 넘어야 추천
recommend_welfare_dict = dict()
for recommend_welfare_sorted_by_count_desc in recommend_welfares_sorted_by_count_desc:
if recommend_welfare.get(recommend_welfare_sorted_by_count_desc) >= total_count:
recommend_welfare_dict[recommend_welfare_sorted_by_count_desc] = recommend_welfare.get(
recommend_welfare_sorted_by_count_desc)
# 채팅이 어떻게 쪼개졌나 확인하기
recommend_welfare_dict['chat tokenize'] = token_list
# 쪼개진 채팅을 토대로 어떤 단어가 유사하다고 나왔는지 확인
for chat_token, similar_chat_token in dict_similar_tokens.items():
recommend_welfare_dict[chat_token] = similar_chat_token
# 이 데이터를 토대로 search에 대한 결과갑 반환
return Response(recommend_welfare_dict)
# 이 데이터를 토대로 채팅 반환
return ListModelMixin.list(self, request, *args, **kwargs)
def create(self, request, *args, **kwargs):
logger.info("TRY CREATE TARGET CHARACTER ||" + create_log_content(request))
return super().create(self, request, *args, **kwargs)
