def get(self,request,guide_id,page):
if page < 1:
return Response(get_reply(81,'error page'),HTTP_404_NOT_FOUND)
begin_page = (int(page)-1)*20
try:
from django.db import connection
cursor = connection.cursor()
sql_guide_id = str(guide_id)
select_sql = "select isbn13 from bookdata_book where book_guide ='%s' \
order by average desc limit %d,20;" % (sql_guide_id,begin_page+6)
cursor.execute(select_sql)
isbn13_rs = cursor.fetchall()
queryset = list()
for row in isbn13_rs:
isbn13 = row[0]
try:
book = Book.objects.get(isbn13=isbn13)
queryset.append(book)
except:
pass
serializer = ShortInto(queryset,many=True,data=request.data)
serializer.is_valid(raise_exception=True)
return Response(serializer.data,HTTP_200_OK)
except Exception as e:
return Response(get_reply(0,e),HTTP_404_NOT_FOUND)
def post(self,request):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
wait_id = serializer.validated_data['wait_id']
order_time = serializer.validated_data['order_time']
# 删除原来的wait item
try:
wait_item = WaitOrderItem.objects.get(id=wait_id)
wait_item.delete()
book_id = wait_item.book_id
isbn13 = " "
try:
holding = Holding.objects.get(id=book_id)
title = holding.book.title
isbn13 = holding.isbn13
except:
title = ''
# try:
s = SuccessOrderItem.objects.create(user=request.user,
isbn13=isbn13,
order_time=order_time,
book_id=book_id,
title=title)
s.save()
return Response(get_reply(0,'success'),HTTP_200_OK)
except Exception as e:
print e
return Response(get_reply(110,'fail'))
def get(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
try:
borrow_item = BorrowItem.objects.get(user=user,pk=pk)
serializer = BorrowItemDetailSerializer(borrow_item,data=request.data)
serializer.is_valid(raise_exception=True)
for i in serializer.data:
# 在返回数据中,增加到期时间
return_time = i['return_time']
date_list = return_time.split("-")
year = int(date_list[0])
month = int(date_list[1])
day = int(date_list[2])
return_date = datetime.datetime(year, month, day)
now_date = datetime.datetime.now()
due = (return_date - now_date).days
i['due'] = due
if i < 7:
i['due_in_7'] = True
if i < 3:
i['due_in_3'] = True
else:
i['due_in_7'] = False
i['due_in_3'] = False
response = Response(serializer.data,HTTP_200_OK)
return response
except BorrowItem.DoesNotExist:
reply = get_reply(20,'item not found')
response = Response(reply,HTTP_404_NOT_FOUND)
return response
def get(self,request,pay_id):
try:
user = request.user
pay = PayItem.objects.get(id=pay_id)
pay.confirm = True
borrow_id = pay.borrow_id
dict = borrow_id.split("b")
for number in dict[1:]:
id = int(number)
try:
borrow_item1 = BorrowItem.objects.get(pk=id)
# 记录管理员这次借出操作
try:
record = AdminBorrowItemRecord.objects.create(user=user,
record_type=1,
borrow_item=borrow_item1,
pay_id=pay_id,
about_user=borrow_item1.user.id)
record.save()
except:
# TODO 异常处理
pass
except:
pass
pay.save()
reply = get_reply(0,'success')
return Response(reply,HTTP_200_OK)
except:
reply = get_reply(96,'not found')
return Response(reply,HTTP_404_NOT_FOUND)
def post(self, request):
user = request.user
if user.admin_permission.andriod_permisson:
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
id_list = serializer.validated_data['id_list']
for id in id_list:
try:
borrow_item1 = BorrowItem.objects.get(pk=id)
borrow_item1.finish_return = True
# 更改还书时间
borrow_item1.return_time = str(time.strftime('%Y-%m-%d', time.localtime(time.time())))
# 获取book_id
book_id = borrow_item1.book_id
# 修改馆藏信息
holding = Holding.objects.get(id=book_id)
holding.state = True
holding.back_time = "--"
holding.save()
borrow_item1.save()
# 记录归还操作
record = AdminBorrowItemRecord.objects.create(user=user,
record_type=2,
borrow_item=borrow_item1,
about_user=borrow_item1.user.id
)
record.save()
except:
pass
reply = get_reply(0, 'success')
return Response(reply, HTTP_200_OK)
else:
reply = get_reply(23, 'not a admin')
return Response(reply, HTTP_403_FORBIDDEN)
def get(self,request,isbn13):
try:
queryset = Holding.objects.filter(isbn13=isbn13)
if not queryset:
reply = get_reply(92, "not found")
return Response(reply, HTTP_404_NOT_FOUND)
serializer = HoldingSerializer(queryset,data=request.data,many=True)
serializer.is_valid(raise_exception=True)
return Response(serializer.data,HTTP_200_OK)
except Exception as e:
reply = get_reply(92,"not found")
return Response(reply,HTTP_404_NOT_FOUND)
def post(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17, 'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
recommend_times = serializer.validated_data['recommend_times']
try:
phone_user = PhoneUser.objects.get(user=request.user)
phone_user.recommend_times = recommend_times
phone_user.save()
return Response(get_reply(0,'success'),HTTP_200_OK)
except:
return Response(get_reply(150,'fail to change time'),HTTP_400_BAD_REQUEST)
def get(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
queryset = BorrowItem.objects.filter(user=user,in_return_bar=True,finish_return=False)
serializer = BorrowItemDetailSerializer(queryset,data=request.data,many=True)
serializer.is_valid(raise_exception=True)
for i in serializer.data:
# 在返回数据中,增加到期时间
return_time = i['return_time']
date_list = return_time.split("-")
year = int(date_list[0])
month = int(date_list[1])
day = int(date_list[2])
return_date = datetime.datetime(year, month, day)
now_date = datetime.datetime.now()
due = (return_date - now_date).days
i['due'] = due
if i < 7:
i['due_in_7'] = True
if i < 3:
i['due_in_3'] = True
else:
i['due_in_7'] = False
i['due_in_3'] = False
response = Response(serializer.data,HTTP_200_OK)
return response
def post(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
id_list = serializer.validated_data['id_list']
price = get_price(id_list)
ctime = time.time()
qrtype = 'borrow'
borrow_id = ""
for i in id_list:
borrow_id += 'b' + str(i) # 参数最后的样子:id = b1b2b3b56
# 在这里创建一个pay,得到唯一的pay_id
pay = PayItem.objects.create(user=request.user,
state=False,
confirm=False,
price = price,
borrow_id=borrow_id,
)
pay.save()
pay_id = pay.id
url = create_qrcode(id_list,ctime,qrtype,pay_id)
reply = dict()
reply['url'] = url
reply['pay_id'] = pay_id
reply['price'] = pay.price
return Response(reply,HTTP_200_OK)
def post(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17, 'not register with phone')
return Response(reply, HTTP_403_FORBIDDEN)
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
content = serializer.validated_data['content']
try:
feedback = FeedBack.objects.create(user=request.user,
content=content,
back_content=u'暂无回复')
feedback.save()
return Response(HTTP_200_OK)
except:
reply = get_reply(151, 'post feedback fail')
return Response(reply,HTTP_403_FORBIDDEN)
def post(self,request):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
user = request.user
isbn13 = serializer.validated_data['isbn13']
begin_time = serializer.validated_data['begin_time']
end_time = serializer.validated_data['end_time']
# 8.30加入总页数,日期
try:
book = Book.objects.get(isbn13=isbn13)
pages = book.pages
if pages == u"('',)":
sum_page = 300
else:
sum_page = int(pages)
except:
sum_page = 300
import datetime
last_date = datetime.datetime.now().date()
read_plan = ReadPlan.objects.create(
user=user,
isbn13=isbn13,
begin_time=begin_time,
end_time=end_time,
sum_page=sum_page,
last_date=last_date
)
read_plan.save()
return Response(get_reply(0,'success'),HTTP_201_CREATED)
def get(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
try:
star_item = StarBook.objects.get(user=user,pk=pk)
serializer = StarBookDetailSerializer(star_item,data=request.data)
serializer.is_valid(raise_exception=True)
response = Response(serializer.data,HTTP_200_OK)
return response
except StarBook.DoesNotExist:
reply = get_reply(82,'item not found')
response = Response(reply,HTTP_404_NOT_FOUND)
return response
def get(self,request,isbn13):
try:
r = Refer.objects.get(isbn13=isbn13)
refer_id = r.refer_id
refer_object_list = list()
refer = refer_id.split("&")
for i in range(1, len(refer)):
try:
b = Book.objects.get(d_id=refer[i])
refer_object_list.append(b)
except:
pass
serializer = ShortInto(refer_object_list, data=request.data, many=True)
serializer.is_valid(raise_exception=True)
return Response(serializer.data,HTTP_200_OK)
except:
# 当找不到相关书籍的时候,重新爬
refer_list = refer_book(isbn13)
print refer_list
refer_object_list = list()
if refer_list != -1:
for i in refer_list:
try:
b = Book.objects.get(d_id=i)
refer_object_list.append(b)
except:
pass
serializer = ShortInto(refer_object_list, data=request.data, many=True)
serializer.is_valid(raise_exception=True)
return Response(serializer.data, HTTP_200_OK)
reply = get_reply(91,"not found")
return Response(reply,HTTP_404_NOT_FOUND)
def get(self,request):
state = request.GET.get("state")
if state == 'close':
user = request.user
phone_user = PhoneUser.objects.get(user=user)
phone_user.return_message = False
phone_user.save()
return Response(get_reply(0,'success'))
elif state == 'open':
user = request.user
phone_user = PhoneUser.objects.get(user=user)
phone_user.return_message = True
phone_user.save()
return Response(get_reply(0, 'success'),HTTP_200_OK)
else:
return Response(get_reply(113,'fail'),HTTP_400_BAD_REQUEST)
def get(self, request, order):
order = int(order)
user = request.user
recommend_list = UserRecommendList.objects.get(user=user)
user_like = recommend_list.user_like
if user_like:
user_list = user_like.split("&")
db_username = user_list[order]
cursor = connection.cursor()
sql = "select * from user_record.user_item where user='******'" % db_username
cursor.execute(sql)
rs = cursor.fetchall()
items_list = list()
for row in rs:
items_in_string = row[1]
items_list = items_in_string.split("&")
items_list.remove("")
queryset = list()
for douban_id in items_list:
isbn13_sql = "select isbn13 from bookdata_book where d_id='%s' " % douban_id
cursor = connection.cursor()
cursor.execute(isbn13_sql)
isbn13_rs = cursor.fetchall()
for row in isbn13_rs:
isbn13 = row[0]
try:
book = Book.objects.get(isbn13=isbn13)
queryset.append(book)
except:
pass
serializer = ShortInto(queryset[:20], many=True, data=request.data)
serializer.is_valid(raise_exception=True)
return Response(serializer.data, HTTP_200_OK)
else:
return Response(get_reply(150, 'no data'), HTTP_200_OK)
def post(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
serializer = BorrowItemCreateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
isbn13 = serializer.validated_data['isbn13']
borrow_time = str(time.strftime('%Y-%m-%d',time.localtime(time.time())))
return_time = str(time.strftime('%Y-%m-%d',time.localtime(time.time()+2419200)))
book_id = serializer.validated_data['book_id']
try:
holding = Holding.objects.get(id=book_id)
location = holding.location
l_loaction = ['总馆', '信息馆', '工学馆', '医学馆']
guide = ['东', '西', '南', '北']
location_list = location.split("->")
location = l_loaction[int(location_list[0])] + "借阅区" + str(location_list[1]) + \
"楼" + guide[int(location_list[2])]
find_id = holding.find_id
except:
location = find_id = ''
user = request.user
try:
if BorrowItem.objects.get(user=user,book_id=book_id,in_return_bar=False,
finish_return=False):
reply = get_reply(10,'item existed')
return Response(reply,HTTP_200_OK)
except:
pass
# 判断购物车中是否超过2本书籍
borrow_item_list = BorrowItem.objects.filter(user=user,in_return_bar=False,
finish_return=False)
if len(borrow_item_list) >= 2:
reply = get_reply(11,'item over 2')
return Response(reply,HTTP_200_OK)
borrow_item = BorrowItem.objects.create(user=user,
isbn13=isbn13,
borrow_time=borrow_time,
return_time=return_time,
find_id =find_id,
book_id= book_id,
location=location)
borrow_item.save()
response = Response(serializer.data,HTTP_201_CREATED)
return response
def post(self,request):
serializer = StarBookSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
isbn13 = serializer.validated_data['isbn13']
try:
book = Book.objects.get(isbn13=isbn13)
user = request.user
# 判断这本书是否已经存在
try:
before_book = StarBook.objects.get(user=user,book=book)
return Response(get_reply(98, 'fail'))
except:
pass
starbook = StarBook.objects.create(user=user,book=book)
starbook.save()
return Response(get_reply(0,'success'))
except:
return Response(get_reply(98,'fail'))
def post(self,request):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
id = serializer.validated_data['id']
try:
return_book = BorrowItem.objects.get(id=id)
return_time = return_book.return_time
date_list = return_time.split("-")
year = int(date_list[0])
month = int(date_list[1])
day = int(date_list[2])
return_date = datetime.datetime(year, month, day)
new_return_date = return_date + datetime.timedelta(days=28)
return_book.return_time = str(new_return_date.date())
return_book.save()
return Response(get_reply(0,'success'),HTTP_200_OK)
except Exception as e:
print e
return Response(get_reply(112,'fail'))
def delete(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
try:
plan_item = ReadPlan.objects.get(user=user, pk=pk)
try:
plan_item.delete()
reply = get_reply(0,'success')
response = Response(reply,HTTP_200_OK)
return response
except:
content = get_reply(115,'delete fail')
response = Response(content, HTTP_400_BAD_REQUEST)
return response
except StarBook.DoesNotExist:
content = get_reply(116,'item not found')
response = Response(content, HTTP_404_NOT_FOUND)
return response
def get(self,request):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
# 判断借书栏中是否超过2本书籍
queryset = BorrowItem.objects.filter(user=user,in_return_bar=False,finish_return=False)
serializer = BorrowItemDetailSerializer(queryset,data=request.data,many=True)
serializer.is_valid(raise_exception=True)
response = Response(serializer.data,HTTP_200_OK)
return response
def get(self,request):
user = request.user
try:
queryset = BorrowItem.objects.filter(finish_return=True)
serializer = BorrowItemDetailSerializer(queryset,data=request.data,many=True)
serializer.is_valid(raise_exception=True)
reply = serializer.data
return Response(reply,HTTP_200_OK)
except:
reply = get_reply(97,'not found')
return Response(reply,HTTP_404_NOT_FOUND)
def post(self,request):
user = request.user
# 此处判断是否是管理员
if user.admin_permission.andriod_permisson:
serializer = ReturnBookSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
id_list = serializer.validated_data['id_list']
ctime = serializer.validated_data['ctime']
qrtype = serializer.validated_data['qrtype']
ctime = float(ctime)
now_time = time.time()
if now_time - ctime > 120.00:
reply = get_reply(21,'over time')
return Response(reply, HTTP_400_BAD_REQUEST)
if qrtype != 'return':
reply = get_reply(22, 'not a return')
return Response(reply, HTTP_400_BAD_REQUEST)
queryset = list()
for id in id_list:
try:
borrow_item = BorrowItem.objects.get(pk=id)
queryset.append(borrow_item)
except:
pass
serializer = ReturnBookInfoToAdmin(queryset,
data=[],
many=True)
serializer.is_valid(raise_exception=True)
return Response(serializer.data, HTTP_200_OK)
# serializer = ReturnBookSerializer(data=request.data)
# serializer.is_valid(raise_exception=True)
# # 返回书籍信息
# id = serializer.validated_data['id']
# borrow_item = BorrowItem.objects.get(pk=id)
# serializer = ReturnBookInfoToAdmin(borrow_item,data=request.data)
# serializer.is_valid(raise_exception=True)
# return Response(serializer.data,HTTP_200_OK)
else:
reply = get_reply(23, 'not a admin')
return Response(reply, HTTP_403_FORBIDDEN)
def get(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
try:
plan_item = ReadPlan.objects.get(user=user, pk=pk)
serializer = ReadPlanDetailSerializer(plan_item, data=request.data)
serializer.is_valid(raise_exception=True)
return Response(serializer.data, HTTP_200_OK)
except Exception as e:
print e
return Response(HTTP_404_NOT_FOUND)
def delete(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
user = request.user
try:
star_item = StarBook.objects.get(user=user, pk=pk)
serializer = StarBookDetailSerializer(star_item, data=request.data)
serializer.is_valid(raise_exception=True)
try:
star_item.delete()
reply = get_reply(0,'success')
response = Response(reply,HTTP_200_OK)
return response
except:
content = get_reply(83,'delete fail')
response = Response(content, HTTP_400_BAD_REQUEST)
return response
except StarBook.DoesNotExist:
content = get_reply(82,'item not found')
response = Response(content, HTTP_404_NOT_FOUND)
return response
def get(self,request,pay_id):
user = request.user
try:
pay = PayItem.objects.get(id=pay_id,user=user)
confirm = pay.confirm
reply = {
"pay_id":pay_id,
"confirm":confirm
}
return Response(reply,HTTP_200_OK)
except:
reply = get_reply(95, 'not found')
return Response(reply, HTTP_404_NOT_FOUND)
def get(self, request, return_id):
user = request.user
try:
return_item = ReturnItem.objects.get(id=return_id, user=user)
confirm = return_item.confirm
reply = {
"return_id": return_id,
"confirm": confirm
}
return Response(reply, HTTP_200_OK)
except:
reply = get_reply(114, 'not found')
return Response(reply, HTTP_404_NOT_FOUND)
def post(self,request):
user = request.user
if user.admin_permission.andriod_permisson:
print request.data
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
id_list = serializer.validated_data['id_list']
pay_id = serializer.validated_data['pay_id']
for id in id_list:
try:
borrow_item1 = BorrowItem.objects.get(pk=id)
borrow_item1.in_return_bar = True
# 获取book_id
book_id = borrow_item1.book_id
# 修改馆藏信息
holding = Holding.objects.get(id=book_id)
holding.state = False
holding.back_time = borrow_item1.return_time
holding.save()
borrow_item1.save()
# 记录管理员这次借出操作
try:
record = AdminBorrowItemRecord.objects.create(user=user,
record_type=1,
borrow_item=borrow_item1,
pay_id=pay_id,
about_user=borrow_item1.user.id)
record.save()
except:
# TODO 异常处理
pass
except:
pass
reply = get_reply(0,'success')
return Response(reply,HTTP_200_OK)
else:
reply = get_reply(16,'not a admin')
return Response(reply, HTTP_403_FORBIDDEN)
def get(self,request,pk):
if not have_phone_register(user=request.user):
reply = get_reply(17,'not register with phone')
return Response(reply,HTTP_403_FORBIDDEN)
borrow_item = BorrowItem.objects.get(pk=pk)
ctime = time.time()
qrtype = "borrow"
create_qrcode(pk,ctime,qrtype,None)
url = '/media/borrow_qrcode/'+str(pk)+".png"
borrow_item.qrcode = url
borrow_item.save()
content = {'url':url}
return Response(content,HTTP_200_OK)
def get(self,request,pay_id):
user = request.user
try:
pay = PayItem.objects.get(id=pay_id,user=user)
price = pay.price
borrow_id = pay.borrow_id
dict = borrow_id.split("b")
for number in dict[1:]:
id = int(number)
try:
borrow_item1 = BorrowItem.objects.get(pk=id)
borrow_item1.in_return_bar = True
# 获取book_id
book_id = borrow_item1.book_id
# 修改馆藏信息
holding = Holding.objects.get(id=book_id)
holding.state = False
holding.back_time = borrow_item1.return_time
holding.save()
borrow_item1.save()
except:
pass
try:
phone_user = PhoneUser.objects.get(user=user)
phone_user.money -= price
if phone_user.money < 0:
return Response(get_reply(111,'money not enough'))
phone_user.save()
except:
reply = get_reply(94, 'not found')
return Response(reply, HTTP_404_NOT_FOUND)
pay.state = True
pay.save()
reply = get_reply(0,'success')
return Response(reply,HTTP_200_OK)
except:
reply = get_reply(94,'not found')
return Response(reply,HTTP_404_NOT_FOUND)
def get(self,request,pay_id):
try:
pay = PayItem.objects.get(id=pay_id)
state = pay.state
price = pay.price
reply = {
'pay_id':pay_id,
'state':state,
'price':price,
}
return Response(reply)
except:
reply = get_reply(93,'not found')
return Response(reply)
