def unfriend(request, pk=None):
""" Delete friend relation between 2 users.
Returns:
400 -- Send unfriend request to current user - E_SAME_USER.
-- Any user is not valid - E_USER_NOT_FOUND.
-- Has no friend connections - E_REQUEST_NOT_FOUND.
204 -- Friend connection has been removed successfully - OK_UNFRIEND.
"""
# Check user id and friend id
if int(request.user.id) == int(pk):
return Response(
{
'status': '400',
'code': 'E_SAME_USER',
'detail': code['E_SAME_USER']
},
status=400)
# Check 2 user is valid
current_user = get_or_none(User, pk=request.user.id)
friend = get_or_none(User, pk=pk)
# if 1 or 2 user is not valid
if current_user is None or friend is None:
return Response(
{
'status': '400',
'code': 'E_USER_NOT_FOUND',
'detail': code['E_USER_NOT_FOUND']
},
status=400)
# get connect of request user -> friend
# from_user=friend.to_user, to_user=request.user
current_connection = get_or_none(Friend,
from_user=current_user,
to_user=friend)
if current_connection is None:
return Response(
{
'status': '400',
'code': 'E_REQUEST_NOT_FOUND',
'detail': code['E_REQUEST_NOT_FOUND']
},
status=400)
# get connect of friend to request user
# reverse_connection = get_or_none(FriendConnect, user=friend, friend=current_user)
#if reverse_connection is None:
# return Response({'status': '400', 'code': 'E_REQUEST_NOT_FOUND',
# 'detail': code['E_REQUEST_NOT_FOUND']}, status=400)
# Delete
current_connection.delete()
#reverse_connection.delete()
# if every thing ok
return Response(
{
'status': '200',
'code': 'OK_UNFRIEND',
'detail': code['OK_UNFRIEND']
},
status=200)
def share(request, pk=None):
"""
Share a post.
Returns:
The return code::
201 -- OK_SHARE.
400 -- E_POST_NOT_FOUND.
-- E_INVALID_PARAMETER_VALUES.
500 -- E_NOT_SAVE.
"""
# Check if post id is wrong
post = get_or_none(Post, pk=pk)
if post is None:
return Response(
{
'status': '400',
'code': 'E_POST_NOT_FOUND',
'detail': code['E_POST_NOT_FOUND']
},
status=400)
# If not None : Create new post base on old post
data = {"content": post.content, "link": post.link}
serializer = PostSerializer(data=data)
if not serializer.is_valid:
return Response(
{
'status': '400',
'code': 'E_INVALID_PARAMETER_VALUES',
'detail': serializer.errors
},
status=400)
# Save
serializer.save()
is_save = get_or_none(Post,
user_id=request.user.id,
content=post.content)
if is_save is None:
return Response(
{
'status': '500',
'code': 'E_NOT_SAVE',
'detail': code['E_NOT_SAVE']
},
status=500)
return Response(
{
'status': '201',
'code': 'OK_SHARE',
'detail': code['OK_SHARE']
},
status=201)
def delete(self, request, pk, format=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
query = self.get_object(pk=pk)
if query:
if self.check_valid_timerange_type_to_delete(query):
query.delete()
else:
return Response(
{
'status':
'400',
'code':
'DELETE FAIL',
'detail':
'This timerange type have exist teetime in active deeal. Please stop deal first'
},
status=400)
return Response({
'status': '200',
'code': 'DELETE SUCCESS'
},
status=200)
def get_analytic_booking(request):
staff = get_or_none(GolfCourseStaff, user=request.user)
if not staff:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail': 'You do not have permission to peform this action'
},
status=401)
results = {}
golfcourse = staff.golfcourse
date = request.QUERY_PARAMS.get('date', '')
if date == '':
date = datetime.date.today()
else:
date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
get_by = request.QUERY_PARAMS.get('get_by', 'date')
if get_by == 'day':
results = analytic_booking_by_day(golfcourse, date)
elif get_by == 'week':
results = analytic_booking_by_week(golfcourse, date)
elif get_by == 'month':
results = analytic_booking_by_month(golfcourse, date)
elif get_by == 'year':
results = analytic_booking_by_year(golfcourse, date)
return Response(results, status=200)
def cancel(request, pk=None):
""" Cancel a friend request.
Returns:
400 -- Request is none - E_REQUEST_NOT_FOUND.
201 -- Friend request cancelled successfully - OK_CANCEL_FRIEND_REQUEST.
"""
# Check request is still valid or not
friend_request = get_or_none(FriendRequest, pk=pk)
# if request is not valid
if friend_request is None:
return Response(
{
'status': '400',
'code': 'E_REQUEST_NOT_FOUND',
'detail': code['E_REQUEST_NOT_FOUND']
},
status=400)
# Delete request
friend_request.delete()
return Response(
{
'status': '200',
'code': 'OK_CANCEL_FRIEND_REQUEST',
'detail': code['OK_CANCEL_FRIEND_REQUEST']
},
status=200)
def get_analytic_player(request):
staff = get_or_none(GolfCourseStaff, user=request.user)
if not staff:
return Response({
'status': 403,
'detail': 'Permission denied'
},
status=403)
golfcourse = staff.golfcourse
date = request.QUERY_PARAMS.get('date', '')
if date == '':
date = datetime.date.today()
else:
date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
get_by = request.QUERY_PARAMS.get('get_by', 'date')
if get_by == 'day':
results = analytic_player_by_day(golfcourse, date)
elif get_by == 'week':
results = analytic_player_by_week(golfcourse, date)
elif get_by == 'month':
results = analytic_player_by_month(golfcourse, date)
elif get_by == 'year':
results = analytic_player_by_year(golfcourse, date)
return Response(results, status=200)
def get(self, request, format=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
query = GolfCourseBuggy.objects.filter(golfcourse=staff.golfcourse)
if not query.exists():
GolfCourseBuggy.objects.create(golfcourse=staff.golfcourse,
buggy=BUGGY_2_SEAT)
GolfCourseBuggy.objects.create(golfcourse=staff.golfcourse,
buggy=BUGGY_4_SEAT)
query = GolfCourseBuggy.objects.filter(golfcourse=staff.golfcourse)
serializer = GolfCourseBuggySerializer(query)
return Response(
{
'status': '200',
'code': 'SUCCESS',
'detail': serializer.data
},
status=200)
def retrieve(self, request, pk=None, **kwargs):
user = get_or_none(User, pk=pk)
if user is None:
return Response(
{
'status': '404',
'code': 'E_NOT_FOUND',
'detail': 'Cannot find user'
},
status=404)
privacy = UserPrivacy.objects.filter(user=user,
target=request.user,
action='D').first()
context = {'is_block': True if privacy else False}
# get usersetting by PK
setting_queryset = UserSetting.objects.get(user_id=pk)
# if user not public and not get itself
if not setting_queryset.public_profile and request.user.id != int(pk):
return Response(
{
'status': '405',
'code': 'E_GET_NOT_ALLOW',
'detail': code['E_GET_NOT_ALLOW']
},
status=405)
serializer = UserSerializer(user, context=context)
response_data = serializer.data
# checking friend with current user
response_data['current_user_id'] = request.user.id
return Response(response_data, status=200)
def create(self, request):
self.permission_classes = (permissions.IsAuthenticated, )
category_id = request.DATA.get('category_id', "''")
if category_id == '':
return Response({"details": "Some Field Is Missing"}, status=400)
category = get_or_none(Category, pk=category_id)
if category is None:
return Response(status=404)
ctype = ContentType.objects.get_for_model(category)
data = {
'user': request.user.id,
'content_type': ctype.id,
'object_id': category.id,
'title': request.DATA['title'],
'content': request.DATA['content']
}
new_post = NewPostSeri(data=data)
if new_post.is_valid():
new_post_post = new_post.save()
html_content = str(
request.user
) + ' vừa đăng bài mới trên diễn đàn: https://golfconnect24.com/#/forum/post/' + str(
new_post_post.id)
html_content += ' Với nội dung :' + str(request.DATA['content'])
# Send email
send_email('Nội dung mới trên diễn đàn', html_content,
['*****@*****.**'])
return Response(new_post.data, status=200)
return Response(new_post.errors, status=400)
def get(self, request):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
timerange = request.QUERY_PARAMS.get('timerange')
dealteetime = self.get_object(timerange=timerange)
undeal = self.get_teetime(timerange=timerange)
serializer = DealEffective_TeeTimeSerializer(dealteetime)
list_id = [data['id'] for data in serializer.data]
serializer2 = UnEffectTeeTimeSerializer(undeal, timerange)
data = [d for d in serializer2.data if not d['id'] in list_id]
data = data + serializer.data
return Response(
{
'status': '200',
'code': 'SUCCESS',
'detail': data or []
},
status=200)
def get_teetime(self, bookingtime=None, timerange=None):
try:
tr = get_or_none(DealEffective_TimeRange, pk=timerange)
if not tr:
return []
from_time = tr.timerange.from_time
to_time = tr.timerange.to_time
golfcourse = tr.timerange.golfcourse
date = tr.date
filter_condition = {
'date': date,
'time__gte': from_time,
'time__lte': to_time,
'golfcourse_id': golfcourse
}
arguments = {}
for k, v in filter_condition.items():
if v:
arguments[k] = v
teetimes = TeeTime.objects.filter(Q(**arguments)).filter(
is_block=False,
is_booked=False,
is_request=False,
available=True)
teetimes = sorted(teetimes, key=lambda w: w.time)
return teetimes
except:
return []
def post(self, request, key=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
data = request.DATA
tr = data['timerange']
timerange = get_or_none(DealEffective_TimeRange, pk=tr)
if not timerange:
return Response({
'status': '400',
'code': 'E_NOT_FOUND'
},
status=400)
if 'id' in data:
list_id = data['id']
dealteetime = self.get_object(timerange=timerange.id)
if dealteetime:
for deal in dealteetime:
if not deal.teetime.id in list_id:
deal.delete()
for i in list_id:
#teetimes = TeeTime.objects.filter(Q(**arguments)).filter(is_block=False, is_booked=False, is_request=False, available=True)
teetime = get_or_none(TeeTime, pk=i)
if not teetime:
continue
d, created = DealEffective_TeeTime.objects.get_or_create(
bookingtime=timerange.bookingtime, teetime=teetime)
d.timerange = tr
d.hole = timerange.bookingtime.deal.hole
d.discount = timerange.discount
d.save()
return Response({'status': '200', 'code': 'SUCCESS'}, status=200)
else:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail': 'Wrong parameters'
},
status=401)
def stop_job_real_time_deal_now(bookingtime_id):
from core.teetime.models import Deal, BookingTime, DealEffective_TeeTime
from core.teetime.models import TeeTime, TeeTimePrice, JobBookingTime
if not bookingtime_id:
return
bookingtime = get_or_none(BookingTime, pk=bookingtime_id)
if not bookingtime:
return
filter_condition = {
'bookingtime_id': bookingtime_id,
}
tz = timezone(
country_timezones(bookingtime.deal.golfcourse.country.short_name)[0])
now = datetime.datetime.utcnow()
current_tz = datetime.datetime.fromtimestamp(now.timestamp(), tz)
from_time = (
datetime.datetime.combine(current_tz.date(), current_tz.time()) +
datetime.timedelta(seconds=1)).time()
from_date = current_tz.date()
teetime_id = DealEffective_TeeTime.objects.filter(
Q(**filter_condition)).values_list('teetime__id', flat=True)
filter_deal = {
'teetime__in': teetime_id,
'bookingtime__deal__active': True,
'bookingtime__deal__is_base': False,
'bookingtime__date': from_date,
'bookingtime__from_time__lte': from_time,
'bookingtime__to_time__gte': from_time
}
filter_exclude1 = {
'bookingtime__deal__effective_date': from_date,
'bookingtime__deal__effective_time__gte': from_time
}
filter_exclude2 = {
'bookingtime__deal__expire_date': from_date,
'bookingtime__deal__expire_time__lte': from_time
}
dealteetime = DealEffective_TeeTime.objects.filter(
Q(**filter_deal)).exclude(Q(**filter_exclude1)
| Q(**filter_exclude2)).order_by('-modified')
list_id = []
if dealteetime.exists():
for d in dealteetime:
if d.teetime.id not in list_id:
channel = 'booking-' + str(d.teetime.date)
notify_discount(d.teetime.id, d.discount, channel,
d.teetime.teetime_price.all()[0].cash_discount)
list_id.append(d.teetime.id)
remainid = [tid for tid in teetime_id if tid not in list_id]
if remainid:
teetime_price = TeeTimePrice.objects.filter(teetime_id__in=remainid,
is_publish=True,
hole=18)
if teetime_price.exists():
for tt in teetime_price:
channel = 'booking-' + str(tt.teetime.date)
notify_discount(tt.teetime.id, tt.online_discount, channel,
tt.cash_discount)
def post(request, key=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
data = request.DATA
gc = staff.golfcourse
if data is None:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Empty data input"
},
status=400)
lq = []
for d in data:
#if 'is_base' in d.keys() and d['is_base']:
# query = get_or_none(Deal, golfcourse=staff.golfcourse, active=True, is_base=True)
# if query and query.deal_code != d['deal_code']:
# return Response({'status': '400', 'code': 'EXIST DEAL',
# 'detail': 'Cannot update'}, status=400)
query, created = Deal.objects.get_or_create(
deal_code=d['deal_code'], golfcourse=staff.golfcourse)
if not query.active and query.end_date and not query.is_base:
serializer = DealSerializer(query)
return Response(
{
'status': '400',
'code': 'CANNOT UPDATE ENDED DEAL',
'detail': serializer.data
},
status=400)
for k in d.keys():
if 'end_date' in k or 'end_time' in k or 'active' in k:
continue
elif 'time' in k:
setattr(query, k, parse_time(d[k]))
elif 'date' in k:
setattr(query, k, parse_date(d[k]))
else:
setattr(query, k, d[k])
query.save()
query = validate_deal(query)
lq.append(query)
serializer = DealSerializer(lq)
return Response(
{
'status': '200',
'code': 'UPDATE/CREATE SUCCESS',
'detail': serializer.data
},
status=200)
def list(self, request, *args, **kwargs):
email = request.QUERY_PARAMS.get('email', '')
if email:
user = get_or_none(User, username=email)
if user:
serialize = UserDisplaySerializer(user)
return Response(serialize.data, status=200)
return Response([], status=200)
def validate_email(attrs, source):
""" ensure email is in the database
"""
email = attrs[source]
user = get_or_none(User, username=email)
if not user:
raise serializers.ValidationError(code['E_EMAIL_NOT_FOUND'])
return attrs
def put(self, request, pk, format=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
query = self.get_object(pk=pk)
data = request.DATA
query.date = parse_date(data['date'])
query.from_time = parse_time(data['from_time'])
query.to_time = parse_time(data['to_time'])
if 'timerange' in data.keys() and data['timerange']:
for t in data['timerange']:
tr = get_or_none(TimeRangeType, pk=t['timerange'])
if not tr:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Not found Time range"
},
status=400)
q, c = DealEffective_TimeRange.objects.get_or_create(
bookingtime=query,
timerange=tr,
date=parse_date(t['date']))
q.discount = t['discount']
q.save()
if not q.bookingtime.deal.is_base:
self.check_and_update_deal_teetime(q)
query.save()
serializer = BookingTimeSerializer(query)
return Response(
{
'status': '200',
'code': 'UPDATE/CREATE SUCCESS',
'detail': serializer.data
},
status=200)
def put(self, request, pk, format=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
query = self.get_object(pk=pk)
query = validate_deal(query)
data = request.DATA
if data is None:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Empty data input"
},
status=400)
#Deal not active and have end_date: DEAL ENDED
if not query.active and query.end_date:
serializer = DealSerializer(query)
return Response(
{
'status': '400',
'code': 'CANNOT UPDATE ENDED DEAL',
'detail': serializer.data
},
status=400)
else:
deal_status = query.active
for k in data.keys():
if 'end_date' in k or 'end_time' in k:
continue
elif 'time' in k:
setattr(query, k, parse_time(data[k]))
elif 'date' in k:
setattr(query, k, parse_date(data[k]))
else:
setattr(query, k, data[k])
#Last active, now deactive: STOP DEAL
if not query.active and deal_status:
query.end_date = datetime.datetime.today()
query.end_time = datetime.datetime.now().time()
query.save()
serializer = DealSerializer(query)
return Response(
{
'status': '200',
'code': 'UPDATE/CREATE SUCCESS',
'detail': serializer.data
},
status=200)
def post(self, request, key=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
data = request.DATA
gc = staff.golfcourse
if data is None:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Empty data input"
},
status=400)
for d in data:
booking_date = self.check_date(d['booking_date'])
teetime_date = self.check_date(d['teetime_date'])
from_time = self.check_time(d['from_time'])
to_time = self.check_time(d['to_time'])
if booking_date and teetime_date and from_time is not None and to_time is not None and d[
'discount']:
pfix = str(booking_date).replace('-', '')
name = "Deal_{0}".format(pfix)
deal, c = Deal.objects.get_or_create(
golfcourse=gc,
deal_code=name,
effective_date=booking_date,
expire_date=booking_date)
bookingt, c2 = BookingTime.objects.get_or_create(
deal=deal,
date=booking_date,
from_time=from_time,
to_time=to_time)
teetime = TeeTime.objects.filter(golfcourse=gc,
date=teetime_date)
if teetime.exists():
for tt in teetime:
deal_teetime, c3 = DealEffective_TeeTime.objects.get_or_create(
bookingtime=bookingt, timerange=0, teetime=tt)
deal_teetime.discount = d['discount']
deal_teetime.save()
deal.save()
bookingt.save()
return Response({
'status': '200',
'code': 'IMPORT SUCCESS'
},
status=200)
def fn_update_caddy_price(p9, p18, p27, p36, gc):
obj = get_or_none(GolfCourseCaddy, golfcourse=gc)
if obj:
obj.price_9 = p9
obj.price_18 = p18
obj.price_27 = p27
obj.price_36 = p36
obj.save()
else:
return False
return True
def update_version(userid, version, source):
if userid.isdigit():
user = get_or_none(User, pk=userid)
else:
user = User.objects.filter(email=userid.replace('%40', '@')).first()
version = 1
if user:
userversion, created = UserVersion.objects.get_or_create(user=user,
source=source)
userversion.version = version
userversion.save()
def get_analytic_booking_by_week(request):
staff = get_or_none(GolfCourseStaff, user=request.user)
results = {}
if staff:
golfcourse = staff.golfcourse
date = request.QUERY_PARAMS.get('date', '')
if date == '':
date = datetime.date.today()
else:
date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
results = analytic_booking_by_week(golfcourse, date)
return Response(results, status=200)
def email_exist(current_user, email):
"""
Validate email if an email already exist or not
This is mainly used in serializer
Parameter:
- currentUser: User object of current user
- email: email to check
return:
- True: if email already exists
- False: if email does not eixist
"""
# This is the case in registration, when there's no current user
if current_user is None:
user = get_or_none(User, email=email)
else:
user = get_or_none(User, ~Q(id=current_user.id), email=email)
if user is None:
return False
else:
return True
def to_native(self, obj):
if obj is not None:
serializers = super(MyBookingDetailSerializer, self).to_native(obj)
checkin = 0
if obj.status == 'I':
checkin = 1
book_partner = obj.book_partner.all()[0]
customer_name = book_partner.customer.name
customer_phone = book_partner.customer.phone_number
customer_email = book_partner.customer.email
setting = get_or_none(GolfCourseBookingSetting, golfcourse=obj.golfcourse)
if setting:
cancel_day = str(int(setting.cancel_hour / 24))
else:
cancel_day = ''
teetime_price = get_or_none(TeeTimePrice, teetime_id=obj.teetime.id, hole=18)
teetime_price2 = get_or_none(TeeTimePrice, teetime_id=obj.teetime.id, hole=obj.hole)
discount = float(obj.discount)
green_fee = (100 - discount) * int(teetime_price2.price) / 100
serializers.update({
'golfcourse_name': obj.golfcourse.name,
'golfcourse_id': obj.golfcourse.id,
'payment_status': obj.payment_status,
'golfcourse_address': obj.golfcourse.address,
'golfcourse_phone': obj.golfcourse.phone,
'golfcourse_website':obj.golfcourse.website,
'golfcourse_contact':obj.golfcourse.contact_info,
# 'subgolfcourse_name': obj.subgolfcourse.name,
'created' : round(obj.created.timestamp() * 1000),
'teetime_date' : obj.teetime.date,
'teetime_time' : obj.teetime.time,
'customer_name': customer_name,
'customer_phone': customer_phone,
'customer_email': customer_email,
'teetime_id' : obj.teetime.id,
'unit_price' : green_fee,
'checkin' : checkin,
'cancel_day' : cancel_day
})
return serializers
def post(self, request):
""" Changing password in database.
Returns:
200 -- Change successfully - OK_CHANGE_PASSWORD.
404 -- Can't find this user - E_USER_NOT_FOUND.
411 -- Password is required - E_INVALID_PARAMETER_VALUES.
"""
serializer = self.serializer_class(data=request.DATA)
# validate
if not serializer.is_valid():
return Response(
{
'status': '400',
'code': 'E_INVALID_PARAMETER_VALUES',
'detail': serializer.errors
},
status=400)
# check user is not null
user = get_or_none(User, pk=int(request.user.id))
if user is None:
# return fail
return Response(
{
'status': '404',
'code': 'E_NOT_FOUND',
'detail': 'Cannot find user'
},
status=404)
# edit password
if user.check_password(request.DATA['password']):
user.set_password(request.DATA['new_password'])
# save password
user.save()
user.user_profile.date_pass_change = datetime.date.today()
user.user_profile.save()
return Response(
{
'status': '200',
'code': 'OK_CHANGE_PASSWORD',
'detail': code['OK_CHANGE_PASSWORD']
},
status=200)
else:
return Response(
{
'status': '400',
'code': 'E_INVALID_PASSWORD',
'detail': 'invalid password'
},
status=400)
def post(self, request, key=None):
staff = get_or_none(GolfCourseStaff, user=request.user)
if staff is None:
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
data = request.DATA
gc = staff.golfcourse
if not data:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Empty data input"
},
status=400)
lq = []
deal_id = None
d = data[0]
if 'deal_id' in d.keys() and d['deal_id']:
deal_id = Deal.objects.get(pk=d['deal_id'])
if not deal_id:
return Response(
{
"code": "E_NOT_FOUND",
"detail": "Empty data input"
},
status=400)
deal_id.deal.all().delete()
for d in data:
query, created = TimeRangeType.objects.get_or_create(
type_name=d['type_name'],
golfcourse=staff.golfcourse,
deal=deal_id)
query.from_time = parse_time(d['from_time']) or query.from_time
query.to_time = parse_time(d['to_time']) or query.to_time
query.save()
lq.append(query)
lq = sorted(lq, key=lambda w: w.id)
#query = self.get_object(golfcourse=staff.golfcourse)
serializer = TimeRangeTypeSerializer(lq)
return Response(
{
'status': '200',
'code': 'UPDATE/CREATE SUCCESS',
'detail': serializer.data or []
},
status=200)
def start_job_real_time_deal(bookingtime_id, end_deal_now):
from core.teetime.models import Deal, BookingTime, DealEffective_TeeTime
from core.teetime.models import TeeTime, TeeTimePrice, JobBookingTime
#Recheck information again
if not bookingtime_id:
return
bookingtime = get_or_none(BookingTime, pk=bookingtime_id)
if not bookingtime:
return
filter_condition = {
'bookingtime_id': bookingtime_id,
'bookingtime__deal__active': True,
'bookingtime__deal__is_base': False,
}
from_time = bookingtime.from_time
from_date = bookingtime.date
mydeal_teetime = DealEffective_TeeTime.objects.filter(
Q(**filter_condition))
if not mydeal_teetime.exists():
return
teetime_id = mydeal_teetime.values_list('teetime__id', flat=True)
filter_deal = {
'teetime__in': teetime_id,
'bookingtime__deal__active': True,
'bookingtime__deal__is_base': False,
'bookingtime__date': from_date,
'bookingtime__from_time__lte': from_time,
'bookingtime__to_time__gte': from_time
}
filter_exclude1 = {
'bookingtime__deal__effective_date': from_date,
'bookingtime__deal__effective_time__gte': from_time
}
filter_exclude2 = {
'bookingtime__deal__expire_date': from_date,
'bookingtime__deal__expire_time__lte': from_time
}
dealteetime = DealEffective_TeeTime.objects.filter(
Q(**filter_deal)).exclude(Q(**filter_exclude1)
| Q(**filter_exclude2)).order_by('-modified')
if not dealteetime.exists():
dealteetime = mydeal_teetime
list_id = []
for d in dealteetime:
if not d.teetime.id in list_id and d.bookingtime.id == bookingtime_id:
channel = 'booking-' + str(d.teetime.date)
notify_discount(d.teetime.id, d.discount, channel,
d.teetime.teetime_price.all()[0].cash_discount)
list_id.append(d.teetime.id)
def golfcourse_id_by_staff(request):
user = request.user.id
staff = get_or_none(GolfCourseStaff, user=user)
if staff is None:
return Response(
{
'status': '404',
'code': 'E_NOT_FOUND',
'detail': 'Cannot find you in golfcourse'
},
status=404)
serializer = GolfCourseSerializer(staff.golfcourse)
return Response(serializer.data, status=200)
def get(request, key=None):
user = request.user
if not user or not user.is_authenticated():
return Response(
{
'status': '401',
'code': 'E_NOT_PERMISSION',
'detail':
'You do not have permission to peform this action'
},
status=401)
res = {}
booked = get_or_none(BookedTeeTime, pk=key)
res = MyBookingDetailSerializer_v2(booked)
encode_data = base64.urlsafe_b64encode(str(
booked.id).encode('ascii')).decode('ascii')
domain = fn_getHostname(request)
if booked:
# cancel teetime url
cancel_teetime_url = 'https://' + domain + '/api/cancel-teetime/' + encode_data + '/'
res.data['cancel_url'] = cancel_teetime_url
# get gift
gtype = GuestType.objects.get(name='G')
teetime_price = get_or_none(TeeTimePrice,
teetime_id=booked.teetime_id,
hole=18,
guest_type_id=gtype.id)
res.data['gifts'] = teetime_price.gifts
res.data['food_voucher'] = teetime_price.food_voucher
res.data['buggy'] = teetime_price.buggy
res.data['caddy'] = teetime_price.caddy
buggy = get_or_none(BookedBuggy, teetime=booked)
caddy = get_or_none(BookedCaddy, teetime=booked)
res.data['buggy_qty'] = buggy.quantity if buggy else 0
res.data['caddy_qty'] = caddy.quantity if caddy else 0
return Response({'detail': res.data}, status=200)
def has_permission(self, request, view):
if request.method in permissions.SAFE_METHODS:
return True
golfcourse_id = request.DATA.get('golfcourse', '')
if golfcourse_id:
golfcourse = get_or_none(GolfCourse, id=golfcourse_id)
if golfcourse:
groups = request.user.groups.all()
for group in groups:
match = re.match(PATTERN, group.name, re.I | re.M)
if match:
if match.group(1) == golfcourse.name:
if match.group(2) == 'Admin':
return True
return False
