def get(self, request, format=None):
"""
내 매물 상세 조회, 업데이트, 삭제 API
---
"""
try:
id_member = request.headers['id-member']
except KeyError:
content = {"message": "올바른 ID값이 아닙니다.", "result": {}}
return Response(content, status=status.HTTP_404_NOT_FOUND)
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
my_product = Product.objects.filter(
id_member=id_member).order_by('-cdate')
paginated_my_product = paginator.paginate_queryset(my_product, request)
if paginated_my_product is not None:
serializers = ProductSearchSerializer(paginated_my_product,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializers.data)
serializer = ProductSearchSerializer(my_product,
many=True,
context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, format="JSON"):
# user=request.user
try:
query_params = list(request.query_params.keys())
kwargs = {}
devices_list = warnType.objects.filter(
**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 2 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(devices_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = WarnTypeSerialiser(devices_list, many=True)
jsondata = {}
jsondata['code'] = 20000
# jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
return Response(jsondata)
except:
return Response({'code': 0, 'msg': '告警类型获取失败'})
def get(self, request, format="JSON"):
user = request.user
try:
dept_id = user.dept.id
dept_arr = []
depts = Department.objects.all()
getDept(dept_id, depts, dept_arr).append(dept_id)
query_params = list(request.query_params.keys())
kwargs = {}
if 'title' in query_params:
kwargs['title__contains'] = request.query_params['title']
kwargs['dept_id__in'] = dept_arr
print(dept_arr)
type_list = Role.objects.filter(**kwargs)
page = PageNumberPagination() # 生成分页器对象
page.page_size = 20 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(type_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = Roleserializer(page_list, many=True)
jsondata = {}
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
return Response(jsondata)
except:
return Response({'code': 0, 'msg': '设备列表获取失败'})
def get(self, request, format=None):
payment = Payment.objects.all().using('default').order_by(
'id') # TODO orderby something logical
paginator = PageNumberPagination()
paginator.max_page_size = 100
paginator.page_size_query_param = 'page_size'
result_page = paginator.paginate_queryset(payment, request)
serializer = PaymentSerializer(result_page,
many=True,
context={'request': request})
current_page = paginator.page.number
total_pages = int(str(paginator.page).split(" ")[3].split(">")[0])
page_size = len(serializer.data)
previous_page = str(paginator.get_previous_link())
next_page = str(paginator.get_next_link())
return JsonResponse(data={
'page_size': page_size,
'results': serializer.data,
'next_page': next_page,
'previous_page': previous_page,
'current_page': current_page,
'total_pages': total_pages
},
status=200,
safe=False)
def product_search(request):
"""
제목에 검색어가 포함된 물건들 리스트
"""
# 디폴트 페이지네이션 사용
paginator = PageNumberPagination()
# 페이지 사이즈를 page_size라는 이름의 파라미터로 받을 거임
paginator.page_size_query_param = "page_size"
Search = request.GET['q']
product = Product.objects.filter(name__contains=Search)
if product.count() == 0:
#검색 결과 없음.
content = {"message": "검색한 제품이 없습니다.", "result": {"입력한 검색어": Search}}
return Response(content, status=status.HTTP_204_NO_CONTENT)
# 페이지 적용된 쿼리셋
paginated_product = paginator.paginate_queryset(product, request)
# 페이지 파라미터 (page, page_size) 있을 경우
# page_size 만 있을 경우 page=1 처럼 동작함
# page만 있을 경우 아래 if문 안 탐
if paginated_product is not None:
serializers = ProductSerializer(paginated_product, many=True)
return paginator.get_paginated_response(serializers.data)
# 페이지 파라미터 없을 경우
serializer = ProductSerializer(product, many=True)
return Response(serializer.data)
def get(self, request, format="JSON"):
user = request.user
try:
query_params = list(request.query_params.keys())
kwargs = {}
if 'start' in query_params and request.query_params['start'] != '':
kwargs['addtime__date__gte'] = request.query_params['start']
if 'end' in query_params and request.query_params['end'] != '':
kwargs['addtime__date__lte'] = request.query_params['end']
kwargs['user__id'] = user.id
log_list = Logs.objects.filter(**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 2 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(log_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = LogsSerialiser(page_list, many=True)
jsondata = {}
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
return Response(jsondata)
except:
return Response({'code': 0, 'msg': '日志列表获取失败'})
def product_category_search(request):
"""
카테고리로 매물 검색 API
---
제목에 검색어가 포함된 물건들 리스트
"""
try:
q = CategoryCode.objects.filter(code=request.GET['q'])
except CategoryCode.DoesNotExist:
content = {
"message": "잘못된 카테고리 입니다.",
"result": {
"입력한 검색어": request.GET['q']
}
}
return Response(content, status=status.HTTP_400_BAD_REQUESTS)
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
Search = request.GET['q']
product = Product.objects.filter(code=Search)
paginated_product = paginator.paginate_queryset(product, request)
serializer = ProductSerializer(paginated_product, many=True)
return paginator.get_paginated_response(serializer.data)
def product_list(request):
"""
매물 리스트 조회, 등록 API
---
상품을 모두 보여주거나 새 상품리스트를 만듭니다.
# form/data OR json/data
- id_product : seq key
- id_member : 상품을 올린 member 외래키
- name : 상품 제목
- price : 상품 가격
- info : 상품 내용
- category : 상품 카테고리
- views : 상품 조회수
- state : '판매중' / '예약중' / '판매완료' 텍스트로
- addr : 판매가 이루어질 장소 (동설정까지만 가능)
- image : 리스트형식의 이미지 URLs
"""
if request.method == 'GET':
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
product = Product.objects.all().order_by('-cdate')
paginated_product = paginator.paginate_queryset(product, request)
serializer = ProductSearchSerializer(paginated_product,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
elif request.method == 'POST':
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
queryset = Member.objects.all()
queryset_paginate = paginator.paginate_queryset(queryset, request)
serializer = MemberSerializer(queryset_paginate,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
def get_courses(self, request, *args, **kwargs):
num_paginator = PageNumberPagination()
num_paginator.page_size_query_param = 'page_size'
subcategory_obj = self.get_object()
courses = subcategory_obj.course_set.all().order_by('id')
page_courses = num_paginator.paginate_queryset(courses,
request,
view=self)
serializer_obj = CourseModelSerializer(page_courses, many=True)
return num_paginator.get_paginated_response(serializer_obj.data)
def get(self, request, format="JSON"):
user = request.user
try:
dept_id = user.dept.id
dept_arr = []
depts = Department.objects.all()
getDept(dept_id, depts, dept_arr).append(dept_id)
query_params = list(request.query_params.keys())
kwargs = {}
if 'sn' in query_params:
kwargs['sn__contains'] = request.query_params['sn']
if 'group' in query_params and request.query_params['group'] != '':
kwargs['group__id'] = request.query_params['group']
if 'building' in query_params and request.query_params[
'building'] != '':
kwargs['building__id'] = request.query_params['building']
if 'type' in query_params and request.query_params['type'] != '':
kwargs['type__id'] = request.query_params['type']
if 'name' in query_params:
kwargs['name__contains'] = request.query_params['name']
kwargs['user__dept_id__in'] = dept_arr
devices_list = Devices.objects.filter(
**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 2 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(devices_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = DeviceListSerialiser(page_list, many=True)
jsondata = {}
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
content = user.username + '进行获取设备列表操作；结果：成功！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response(jsondata)
except:
content = user.username + '进行获取设备列表操作；结果：失败！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response({'code': 0, 'msg': '设备列表获取失败'})
def get(self, request, format="JSON"):
user = request.user
try:
query_params = list(request.query_params.keys())
kwargs = {}
kwargs['device__user_id'] = user.id
if 'sn' in query_params:
kwargs['device__sn__contains'] = request.query_params['sn']
if 'start' in query_params and request.query_params['start'] != '':
kwargs['addtime__date__gte'] = request.query_params['start']
if 'end' in query_params and request.query_params['end'] != '':
kwargs['addtime__date__lte'] = request.query_params['end']
if 'type' in query_params:
kwargs['warnType_id'] = request.query_params['type']
if 'name' in query_params:
kwargs['device__name__contains'] = request.query_params['name']
devices_list = warndata.objects.filter(
**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 2 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(devices_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = WarnDataSerializer(page_list, many=True)
jsondata = {}
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
content = user.username + '进行获取告警列表操作；结果：成功！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response(jsondata)
except:
content = user.username + '进行获取告警列表操作；结果：失败！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response({'code': 0, 'msg': '告警列表获取失败'})
def list(self, request, *args, **kwargs):
if request.query_params.get('length'):
# listagem utilizando paginação do datatables.js
registers_per_page = int(request.query_params.get('length'))
first_record_in_page = int(request.query_params.get('start', 0))
request.query_params._mutable = True
request.query_params['page'] = int(
first_record_in_page / registers_per_page) + 1
request.query_params._mutable = False
self.pagination_class = PageNumberPagination
queryset = self.filter_queryset(self.get_queryset())
paginator = PageNumberPagination()
paginator.page_size_query_param = 'length'
courses_page = paginator.paginate_queryset(queryset, request)
if courses_page is not None:
serializer = self.get_serializer(courses_page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def company_list(request):
"""
업체 리스트 조회, 생성 API
---
업체리스트를 모두 보여주거나 새 업체리스트를 만듭니다.
"""
if request.method == 'GET':
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
queryset = Company.objects.all().order_by('-cdate')
paginated_company = paginator.paginate_queryset(queryset, request)
serializer = CompanySearchSerializer(paginated_company,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
elif request.method == 'POST':
serializer = CompanySerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format="JSON"):
user = request.user
try:
dept_id = user.dept.id
dept_arr = []
depts = Department.objects.all()
getDept(dept_id, depts, dept_arr).append(dept_id)
query_params = list(request.query_params.keys())
kwargs = {}
if 'deviceid' in query_params:
kwargs['device__id'] = request.query_params['deviceid']
kwargs['addTime__hour'] = datetime.datetime.now().hour
# if 'name' in query_params:
# kwargs['name__contains'] = request.query_params['name']
kwargs['device__user__dept_id__in'] = dept_arr
data_list = RealTimeData.objects.filter(
**kwargs).order_by('-addTime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 10 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(data_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
# ret = GroupListSerialiser(page_list, many=True)
ret = RealTimeListSerialiser(page_list, many=True)
jsondata = {}
jsondata['code'] = 20000
jsondata['items'] = ret.data
jsondata['total'] = page.page.paginator.count
return Response(jsondata)
except:
return Response({'code': 0, 'msg': '设备数据获取失败'})
def location_search_company(request):
"""
사용자의 위치에 따른 업체 검색 API
---
# 내용
- q = 검색어
- page = 현재 페이지
- page_size = 한번에 뿌려주는 상품 갯수
# Header
- id-member : header에 id_member를 캐치해서 선택된 addr, dis를 활용한다.
* header에 id-member값이 없을경우, 비회원 전체검색 로직
"""
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
Search = request.GET['q']
# 회원 검색
if 'id-member' in request.headers:
try:
member_addr = Memberaddr.objects.filter(
id_member=request.headers['id-member']).get(select='Y')
addr = member_addr.addr
dis = member_addr.distance
except Memberaddr.DoesNotExist:
content = {"message": "설정된 주소가 없습니다. 주소를 설정해 주세요.", "result": {}}
return Response(content, status=status.HTTP_204_NO_CONTENT)
location = [addr] + list(
NearbyLocation.objects.filter(dong=addr).filter(
distance=dis).values_list('nearby_dong', flat=True))
company_list = Company.objects.filter(name__contains=Search).filter(
addr__in=location).order_by('-cdate')
if company_list.count() == 0:
content = {
"message": "검색한 업체가 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
paginated_company_list = paginator.paginate_queryset(
company_list, request)
if paginated_company_list is not None:
serializers = CompanySearchSerializer(paginated_company_list,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializers.data)
serializer = CompanySearchSerializer(company_list,
many=True,
context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
# 비회원
else:
company = Company.objects.filter(
name__contains=Search).order_by('-cdate')
if company.count() == 0:
content = {
"message": "검색한 없체가 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
paginated_company = paginator.paginate_queryset(company, request)
if paginated_company is not None:
serializers = CompanySearchSerializer(paginated_company,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializers.data)
serializer = CompanySearchSerializer(company,
many=True,
context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def location_search(request):
"""
사용자의 위치에 따른 product 검색
---
# 내용
- q = 검색어
- page = 현재 페이지
- page_size = 한번에 뿌려주는 상품 갯수
# Header
- id-member : header에 id_member를 캐치해서 선택된 addr, dis를 활용한다.
* header에 id-member값이 없을경우, 비회원 전체검색 로직
"""
# 디폴트 페이지네이션 사용
paginator = PageNumberPagination()
# 페이지 사이즈를 page_size라는 이름의 파라미터로 받을 거임
paginator.page_size_query_param = "page_size"
Search = request.GET['q']
#회원 검색
if 'id-member' in request.headers:
#주소 유무 체크
try:
memberaddr = Memberaddr.objects.filter(
id_member=request.headers['id-member']).get(select='Y')
addr = memberaddr.addr
dis = memberaddr.distance
#설정된 주소가 없을
except Memberaddr.DoesNotExist:
product = Product.objects.filter(name__contains=Search)
if product.count() == 0:
content = {
"message": "검색한 제품이 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
serializer = ProductSearchSerializer(product, many=True)
# 페이지 적용된 쿼리셋
paginated_product = paginator.paginate_queryset(product, request)
# 페이지 파라미터 (page, page_size) 있을 경우
# page_size 만 있을 경우 page=1 처럼 동작함
# page만 있을 경우 아래 if문 안 탐
if paginated_product is not None:
serializers = ProductSearchSerializer(paginated_product,
many=True)
return paginator.get_paginated_response(serializers.data)
# # 페이지 파라미터 없을 경우
serializer = ProductSearchSerializer(product, many=True)
return Response(serializer.data)
#근처 주소 검색
location = NearbyLocation.objects.filter(dong=addr).filter(
distance=dis)
product_sum = Product.objects.filter(name__contains=Search).filter(
addr=addr)
for i in location:
product = Product.objects.filter(name__contains=Search).filter(
addr=i.nearby_dong)
product_sum = product_sum | product
if product_sum.count() == 0:
content = {
"message": "검색한 제품이 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
# 페이지 적용된 쿼리셋
paginated_product_sum = paginator.paginate_queryset(
product_sum, request)
# 페이지 파라미터 (page, page_size) 있을 경우
# page_size 만 있을 경우 page=1 처럼 동작함
# page만 있을 경우 아래 if문 안 탐
if paginated_product_sum is not None:
serializers = ProductSearchSerializer(paginated_product_sum,
many=True)
return paginator.get_paginated_response(serializers.data)
# # 페이지 파라미터 없을 경우
serializer = ProductSearchSerializer(product_sum, many=True)
return Response(serializer.data)
#비회원
else:
#모든 제품 검색
product = Product.objects.filter(name__contains=Search)
if product.count() == 0:
content = {
"message": "검색한 제품이 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
serializer = ProductSearchSerializer(product, many=True)
# 페이지 적용된 쿼리셋
paginated_product = paginator.paginate_queryset(product, request)
# 페이지 파라미터 (page, page_size) 있을 경우
# page_size 만 있을 경우 page=1 처럼 동작함
# page만 있을 경우 아래 if문 안 탐
if paginated_product is not None:
serializers = ProductSearchSerializer(paginated_product, many=True)
return paginator.get_paginated_response(serializers.data)
# # 페이지 파라미터 없을 경우
serializer = ProductSearchSerializer(product, many=True)
return Response(serializer.data)
def get(self, request, format="JSON"):
user = request.user
try:
dept_id = user.dept.id
dept_arr = []
depts = Department.objects.all()
getDept(dept_id, depts, dept_arr).append(dept_id)
query_params = list(request.query_params.keys())
kwargs = {}
if 'name' in query_params:
kwargs['name__contains'] = request.query_params['name']
kwargs['user__dept_id__in'] = dept_arr
buidling_list = Buidling.objects.filter(
**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 20 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(buidling_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = BuidlingListSerialiser(page_list, many=True)
jsondata = {}
for building in ret.data:
online = 0
offline = 0
open = 0
close = 0
total = 0
power = ActualData.objects.filter(
device__building_id=building['id']).aggregate(
power=Sum('tPower'))
for group in building['group']:
for device in group['device']:
total += 1
if device['status'] == '0':
offline += 1
else:
online += 1
if device['switch'] == '0':
close += 1
else:
open += 1
building['power'] = power
building['online'] = online
building['offline'] = offline
building['open'] = open
building['close'] = close
building['device_total'] = total
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
content = user.username + '进行获取楼层列表操作；结果：成功！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response(jsondata)
except:
content = user.username + '进行获取楼层列表操作；结果：失败！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response({'code': 0, 'msg': '设备列表获取失败'})
