def record_form(request, hour):
day = request.session['selected_day']
user = get_current_user(request)
if request.method == 'POST':
form = RecordCreateForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
record = RPRecord()
record.user = get_current_user(request)
service = RPService.objects.get(id=int(cd['service']))
record.service = service
h,m = cd['start_time'].split(':')
s_date = datetime(day.year, day.month, day.day, int(h), int(m))
record.start_datetime = s_date
h,m = cd['stop_time'].split(':')
s_date = datetime(day.year, day.month, day.day, int(h), int(m))
record.stop_datetime = s_date
record.comment = cd['comment']
#check duble-record
finded = RPRecord.objects.filter(start_datetime__gt=datetime(day.year, day.month, day.day,0,0), stop_datetime__lt=datetime(day.year, day.month, day.day,23,59), user=record.user)
if finded:
st_dt = finded[0].start_datetime
en_dt = finded[0].stop_datetime
start_time = '%.02i:%.02i'%(st_dt.hour, st_dt.minute)
stop_time = '%.02i:%.02i'%(en_dt.hour, en_dt.minute)
return inform_message(_(u'Ви вже записані на цей день з %(start_time)s до %(stop_time)s. Якщо бажаєте змінити час запису, то відмініть ваш прийом, а потім запишіться на інший час') % {'start_time': unicode(start_time), 'stop_time' : unicode(stop_time)}, redirect_link='/my_records/')
res = record.stop_datetime - record.start_datetime
cost = ((res.seconds/60.0) / ATOM_TIME) * service.atom_money
#check current user balance
if user.balance < cost:
return inform_message(_(u'У вас недостатньо коштів для запису. Поповніть, будь ласка, свій рахунок '), '/my_balance')
record.user.balance -= cost
try:
record.user.save()
record.save()
except Exception, err:
transaction.rollback()
raise err
else:
transaction.commit()
return inform_message(_(u'Ви успішно записались на прийом з %(start_time)s до %(stop_time)s. Вартість послуги - %(cost)i гривень') % {'start_time': unicode(cd['start_time']), 'stop_time': unicode(cd['stop_time']), 'cost': int(cost)}, redirect_link='/my_records/')
raise Exception('Record form data is not valid')
def get_user_records(request):
user = get_current_user(request)
records = RPRecord.objects.filter(user=user).order_by('-start_datetime')
now = datetime.now()
for record in records:
if record.start_datetime <= now:
record.is_past = True
else:
record.is_past = False
user = get_current_user(request)
return render_to_response('user_records_form.html',locals())
def get_messages(request):
user = get_current_user(request)
is_outbox = request.REQUEST.get('is_outbox',None)
full_message_id = request.REQUEST.get('msg_id',None)
if is_outbox:
messages = RPMessage.objects.filter(sender=user).order_by('-send_datetime')
else:
messages = RPMessage.objects.filter(binded_user=user).order_by('-send_datetime')
for message in messages:
if full_message_id and int(full_message_id) == message.id:
if (not message.is_readed) and (not is_outbox):
message.is_readed = 1
message.save()
continue
if len(message.message) > 20:
message.message = message.message.split('\n')[0][0:20]+' ...'
messages = [msg for msg in messages]
if len(messages) < 20:
for i in xrange(20-len(messages)):
messages.append(RPMessage())
return render_to_response('user_messages.html',locals())
def cancel_record(request, record_id, is_admin=False):
record = RPRecord.objects.get(id=record_id)
if is_admin:
user = record.user
else:
user = get_current_user(request)
if not record:
raise Exception("Record with ID %s is not found in database!"%record_id)
if record.user != user:
raise Exception("It's not your record!!!")
if not is_admin:
if record.start_datetime < datetime.now():
return inform_message(_(u'Не можна відмінити прийом, який вже пройшов (або під час його)!'), '/my_records')
diff = record.start_datetime - datetime.now()
if diff.days == 0 and (diff.seconds/60.0 < MIN_CANCEL_TIME):
return inform_message(_(u'Відмінити прийом можна не менше ніж за %(min_time)i хвилин!')% {'min_time':MIN_CANCEL_TIME}, '/my_records')
res = record.stop_datetime - record.start_datetime
cost = ((res.seconds/60.0) / ATOM_TIME) * record.service.atom_money
#check current user balance
user.balance += cost
try:
record.delete()
user.save()
except Exception, err:
transaction.rollback()
raise err
def cancel_past_record(request, record_id):
record = RPRecord.objects.get(id=record_id)
message = _(u'Шановний %(name)s, На Ваш віртуальний рахунок була повернена оплата за прийом %(day).02i.%(month).02i%(year)i.\n') % {'name':record.user.name, 'day':record.start_datetime.day, 'month':record.start_datetime.month, 'year':record.start_datetime.year}
user = get_current_user(request)
day = '%s/%s/%s'%(record.start_datetime.day, record.start_datetime.month, record.start_datetime.year)
try:
cancel_record(request, record_id, is_admin=True)
except Exception,err:
raise err
def services_description(request):
user = get_current_user(request)
services = RPService.objects.filter(is_deleted=0)
part = 60.0 / ATOM_TIME
for service in services:
i18n_service(service, request)
service.hour_money = int( service.atom_money * part )
return render_to_response('services_description.html',locals())
def send_message(request):
if request.method != 'POST':
raise Exception('POST expected for send_message')
if not request.POST.has_key('message'):
raise Exception('message is not found at POST data')
user = get_current_user(request)
message = RPMessage(sender=user, binded_user=None, send_datetime=datetime.now(), message=request.POST['message'], is_readed=0)
message.save()
return HttpResponse('')
def delete_service(request, service_id):
user = get_current_user(request)
service = RPService.objects.get(id=int(service_id))
records = RPRecord.objects.filter(stop_datetime__gt=datetime.now(), service=service)
if records:
return inform_message(_(u'Видалення послуги неможливе тому, що є заплановані записи на дану послугу!'), '/admin_services')
service.is_deleted=1
service.save()
return inform_message(_(u'Ви успішно видалили послугу!'), '/admin_services')
def get_liqpay_form(request):
user = get_current_user(request)
money_count = request.REQUEST['money']
money_count = float(money_count)
l = liqpay.Liqpay(MERCHANT_ID, SIGNATURE)
#balance = l.get_ballances() # balance['UAH']
payment = RPPayments(user=user, money=money_count, transaction_start=datetime.now(),transaction_end=None, status=PS_INIT, phone_number='')
payment.save()
xml = l.build_merchant_xml(order_id=payment.id, amount=money_count, currency='UAH', description='Psychologist service', pay_way='card', default_phone='', result_url='http://%s/liqpay_redirect/'%hostname, server_url='http://%s/liqpay_response/'%hostname)
logger.debug('LIQPAY REQUEST:\n%s'%xml.xml)
enc_xml = xml.encoded_xml
signature = xml.encoded_signature
return HttpResponse('%s,%s'%(enc_xml, signature))
def get_day_calendar(request, day_str):
day,month,year = day_str.split('/')
day,month,year = int(day), int(month), int(year)
today = date(year, month, day)
request.session['selected_day'] = today
day = '%s %i, %s' % ( MONTHS[month], day, year)
hours_dict = _get_free_ranges(today)
keys = hours_dict.keys()
keys.sort()
hours = [hours_dict[key] for key in keys]
user = get_current_user(request)
return render_to_response('day_calendar.html', locals())
def admin_cancel_record(request, record_id):
record = RPRecord.objects.get(id=record_id)
user = get_current_user(request)
day = '%s/%s/%s'%(record.start_datetime.day, record.start_datetime.month, record.start_datetime.year)
if request.method == 'POST':
message = request.POST['message']
if message.strip() == '':
return inform_message(_(u'Ви не ввели причину відміни прийому'), '/admin_cancel_record/%s'%record_id)
message = _(u'Шановний %(name)s, Ваш прийом %(day).02i.%(month).02i.%(year)i було відмінено.\nПричина: %(message)s.\nБудь ласка, виберіть інший час прийому.\nСподіваємося на розуміння.') % {'name':record.user.name, 'day':record.start_datetime.day, 'month':record.start_datetime.month, 'year':record.start_datetime.year, 'message': message}
try:
cancel_record(request, record_id, is_admin=True)
except Exception,err:
raise err
else:
message = RPMessage(sender=user, binded_user=record.user, send_datetime=datetime.now(), message=message, is_readed=0)
message.save()
return inform_message(_(u'Ви успішно відмінили прийом'), '/manage_day/%s'%day)
def manage_day_calendar(request, day_str):
day,month,year = day_str.split('/')
day,month,year = int(day), int(month), int(year)
today = datetime(year, month, day)
if today < datetime.today():
is_past_date = True
request.session['selected_day'] = today
day = '%s %i, %s' % ( MONTHS[month], day, year)
nextday = today + timedelta(1)
work_ranges = RPWorkTime.objects.filter(start_worktime__gt=today, stop_worktime__lt=nextday).order_by('start_worktime')
record_ranges = RPRecord.objects.filter(start_datetime__gt=today, stop_datetime__lt=nextday).order_by('start_datetime')
user = get_current_user(request)
return render_to_response('manage_day.html', locals())
def manage_messages(request):
user = get_current_user(request)
full_message_id = request.REQUEST.get('msg_id',None)
is_outbox = request.REQUEST.get('is_outbox',None)
if is_outbox:
messages = RPMessage.objects.filter(sender=user).order_by('-send_datetime')[0:100]
else:
messages = RPMessage.objects.filter(binded_user=None).order_by('-send_datetime')[0:100]
for message in messages:
if full_message_id and int(full_message_id) == message.id:
if (not message.is_readed) and (not is_outbox):
message.is_readed = 1
message.save()
continue
if len(message.message) > 20:
message.message = message.message.split('\n')[0][0:20]+' ...'
return render_to_response('manage_messages.html', locals())
def manage_user(request, user_id):
m_user = RPUser.objects.get(id=user_id)
user = get_current_user(request)
if request.method == 'POST':
message = request.POST['message']
if message.strip() == '':
return inform_message(_(u'Ви не ввели текст повідомлення'), '/manage_user/%s'%user_id)
message = RPMessage(sender=user, binded_user=m_user, send_datetime=datetime.now(), message=message, is_readed=0)
message.save()
return inform_message(_(u'Повідомлення відправлено успішно'), '/manage_user/%s'%user_id)
payments = RPPayments.objects.filter(user=m_user).order_by('-transaction_end')[:100] #FIXME
for payment in payments:
if payment.status == PS_OK:
payment.status = _(u'Успішно')
elif payment.status == PS_FAIL:
payment.status = _(u'Помилка')
records = RPRecord.objects.filter(user=m_user).order_by('-stop_datetime')[:100] #FIXME
return render_to_response('manage_user.html', locals())
def manage_worktime(request):
class Day:
def __init__(self, cdate=None):
self.is_active = False
self.is_recorded = False
if not cdate:
self.num = ''
self.is_current = False
self.is_past = False
return
self.num = cdate.day
current = date.today()
if current == cdate:
self.is_current = True
if cdate < current:
self.is_past = True
else:
nextday = cdate + timedelta(1)
work_ranges = len(RPWorkTime.objects.filter(start_worktime__gt=cdate, stop_worktime__lt=nextday))
record_ranges = len(RPRecord.objects.filter(start_datetime__gt=cdate, stop_datetime__lt=nextday))
if work_ranges:
self.is_active = True
if record_ranges:
self.is_recorded = True
class Month:
def __init__(self, name, num, year):
self.name = name
self.weeks = []
self.num = num
self.year = year
cur_date = request.session.get('DATE',None)
if not cur_date:
cur_date = date.today()
cur_date = date(cur_date.year, cur_date.month, 1)
request.session['DATE'] = cur_date
month = Month(MONTHS[cur_date.month], cur_date.month, cur_date.year)
weeks = []
start_idx = cur_date.weekday()
week = [Day() for i in xrange(start_idx)]
cur_month = cur_date.month
while cur_month == cur_date.month:
week.append(Day(cur_date))
if len(week) == 7:
weeks.append(week)
week = []
cur_date = cur_date + timedelta(1)
week += [Day() for i in xrange(7-len(week))]
weeks.append(week)
month.weeks = weeks
user = get_current_user(request)
return render_to_response('admin_calendar.html',locals())
def user_balance(request):
user = get_current_user(request)
payments = RPPayments.objects.filter(status__in=[PS_OK,PS_WAIT], user=user).order_by('-transaction_end')
return render_to_response('user_balance.html',locals())
def manage_users(request):
users = RPUser.objects.filter(role='user')
user = get_current_user(request)
return render_to_response('manage_users.html', locals())
def admin_balance(request):
user = get_current_user(request)
balance = get_liqpay_balance()
return render_to_response('admin_balance.html', locals())
def admin_services(request):
user = get_current_user(request)
services = RPService.objects.filter(is_deleted=0)
return render_to_response('admin_services.html', locals())
def manage_service(request, service_id):
user = get_current_user(request)
if service_id:
service_id = int(service_id)
if request.method == 'POST':
name = request.POST['name'].strip()
name_ru = request.POST['name_ru'].strip()
time_min = int(request.POST['time_min'])
time_max = int(request.POST['time_max'])
atom_money = int(request.POST['atom_money'])
description = request.POST['description'].strip()
description_ru = request.POST['description_ru'].strip()
if not name:
raise Exception('service name should be not empty')
if atom_money <= 0:
raise Exception('service atom_money should be greater then 0')
if time_min > time_max:
raise Exception('time_max should be greater or equal then time_min')
if service_id:
service = RPService.objects.get(id=int(service_id))
else:
service = RPService(name='', time_min=0, time_max=0, atom_money=0, description='', name_ru='', description_ru='')
service.name = name
service.time_min = time_min
service.time_max = time_max
service.atom_money = atom_money
service.description = description
service.name_ru = name_ru
service.description_ru = description_ru
service.save()
return inform_message(_(u'Інформація про послугу успішно збережена!'), '/admin_services')
if service_id:
service = RPService.objects.get(id=service_id)
else:
service = RPService(name='', time_min=0, time_max=0, atom_money=0, description='', name_ru='', description_ru='')
##################################
#TODO: rewrite this f*****g code to javascript
class Time:
def __init__(self, num, descr):
self.num = num
self.descr = descr
time_min_list = [Time(30, _(u'30 хвилин')), Time(45, _(u'45 хвилин')), Time(60, _(u'1 година'))]
tmp = []
for time in time_min_list:
if service.time_min == time.num:
tmp.insert(0, time)
else:
tmp.append(time)
service.time_min = tmp
time_max_list = [Time(30, _(u'30 хвилин')), Time(45, _(u'45 хвилин')), Time(60, _(u'1 година')), Time(75, _(u'1 година 15 хвилин')), Time(90, _(u'1 година 30 хвилин')), Time(105, _(u'1 година 45 хвилин')), Time(120, _(u'2 години'))]
tmp = []
for time in time_max_list:
if service.time_max == time.num:
tmp.insert(0, time)
else:
tmp.append(time)
service.time_max = tmp
##################################
return render_to_response('manage_service.html', locals())
def manage_record(request, record_id):
user = get_current_user(request)
record = RPRecord.objects.get(id=record_id)
return render_to_response('manage_record.html', locals())