def user (request, idnum):
if len(Person.objects.filter(id=idnum)) == 0:
if request.method == 'POST':
form = NewUserForm(request.POST)
if form.is_valid():
person = form.save(commit=False)
person.id = idnum
person.save()
else:
form = NewUserForm()
return render(request, "scanner/newuser.html", {"idnum": idnum, "form": form})
person = Person.objects.get(id=idnum)
messages = []
if request.method == 'POST':
form = ScanForm(request.POST)
if form.is_valid():
if len(CheckoutItem.objects.filter(id=form.cleaned_data["scan"])) > 0:
item = CheckoutItem.objects.get(id=form.cleaned_data["scan"])
if len(Checkout.objects.filter(person=person, item=item, checked_in=False)) > 0:
for checkout in Checkout.objects.filter(person=person, item=item, checked_in=False):
checkout.checked_in = True
checkout.date_returned = datetime.now()
checkout.save()
messages.append(item.name + " successfully checked in.")
else:
new_checkout = Checkout(person=person, item=CheckoutItem.objects.get(id=form.cleaned_data["scan"]), date_checked_out=datetime.now() , date_due=datetime.now() + timedelta(CheckoutItem.objects.get(id=form.cleaned_data["scan"]).default_checkout_time))
new_checkout.save()
messages.append(item.name + " successfully checked out.")
else:
messages.append("That item is not in the database.")
form = ScanForm()
return render(request, "scanner/user.html", {"person": person, "form": form, "checkouts": Checkout.objects.filter(person=person, checked_in=False), "messages": messages})
def checkouts_checkout(user_id, asset_id):
"""
Checkouts out the specified asset to the specified user.
@path '/checkouts/:user_id/new/:asset_id'
@param 'user_id'
@param 'asset_id'
"""
users = User.query.filter_by(_id=user_id)
if users.count() == 0:
abort(404)
assets = Asset.query.filter_by(_id=asset_id)
if assets.count() == 0:
abort(404)
asset = assets[0]
if asset.stock == 0:
asset.total += 1
asset.save()
checkout = Checkout()
checkout.user_id = user_id
checkout.asset_id = asset_id
checkout.save()
return redirect(url_for("checkouts_list"))
def checkout(self, member: Member, book: Book) -> Checkout:
self._validate(member, book)
checkout = Checkout()
currentDate = datetimeNowProxy()
lengthOfCheckout = 7
if member.hasCheckoutHistory:
lengthOfCheckout = 14
self._bookInventory.removeBook(book)
checkout.dueDate = currentDate + timedelta(days=+lengthOfCheckout)
return checkout
def ccbasket_adapter(request):
"""An adapter function for django-ccbasket"""
# get the checkout
try:
checkout = Checkout.objects.get(session_id=request.session.session_key)
except Checkout.DoesNotExist:
checkout = Checkout()
checkout.session_id = request.session.session_key
checkout.save()
# get the basket
basket_name = getattr(settings, "CCBASKET_SESSION_KEY_NAME", ccbasket_settings.CCBASKET_SESSION_KEY_NAME)
basket = request.session[basket_name]
# now set up the items
checkout.items = basket.basketitem_set.all()
# and item total
checkout.item_total = basket.total_price()
# and the lines
lines = 0
for b in basket.basketitem_set.all():
lines += b.quantity
checkout.lines = lines
# attatch and save the session
request.session["cccheckout"] = checkout
request.session.save()
# return it
return checkout
def checkout():
#store directory of folder
working_dir = os.path.dirname(os.path.abspath( __file__ ))
main_dir = os.path.dirname(working_dir)
showbooks = []
len_books = 0
disp_cart = session['user_cart']
print(disp_cart)
username = session.get('logged_in_user')
sub_total = 0
for i in range(len(disp_cart)):
showbooks.append(db.session.query(Books.title, Books.isbn, Books.price).filter_by(isbn = disp_cart[i]).first())
sub_total += float(db.session.query(Books.price).filter_by(isbn = disp_cart[i]).first().price)
sub_total = round(sub_total + 5.99,2)
total = round(sub_total*1.13,2)
#print(sub_total)
#print(total)
len_books = len(showbooks)
if request.method == 'POST':
if request.form['confirm'] == "Confirm Purchase":
#update tables views, checkout, and confirm-purchase
#and update-order track
checkoutid = db.session.query(Checkout.c_out_id).count() + 1
#add checkout
add_checkout = Checkout(checkoutid, request.form['credit_card'], date.today(),"5.99",request.form['total'])
db.session.add(add_checkout)
db.session.commit()
#add order_track
orderid = db.session.query(Order_track.order_id).count() + 1
add_order_track = Order_track(orderid, date.today(), str(datetime.now() + timedelta(hours=5)), str(datetime.now() + timedelta(hours=200)), "Seattle")
db.session.add(add_order_track)
db.session.commit()
#add a view for this customer
id = session['user_id']
add_viewer = Views(id,checkoutid)
db.session.add(add_viewer)
db.session.commit()
#add complete purchase
add_cp = Confirm_purchase(checkoutid, orderid, request.form['total'])
db.session.add(add_cp)
db.session.commit()
return redirect(url_for('ordercomplete'))
return render_template('checkout.html', username=username, showbooks=showbooks, len_books=len_books,\
sub_total=sub_total, total=total)
def checkout(d_id, staff):
note = request.json['note']
desk = Desk.query.get(d_id)
uuid = desk.token
if not uuid:
abort(403)
orders = desk.orders
checkout_info = []
time = time_translate(datetime.utcnow())
for order in orders:
order.status = True
order_products = order.order_products
checkout_info.append(order_products)
checkout = Checkout(token=uuid,
staff=staff,
total_price=desk.price,
note=note,
desk_name=desk.name)
try:
pos = POS.query.get(1)
# only pos machine at the checkout counter prints the checkout info
print_bill(pos, checkout, checkout_info, desk.price)
except Exception as e:
checkout.printed = False
return json_err(str(e))
finally:
db.session.add(checkout)
desk.token = None
desk.occupied = False
db.session.commit()
if not config.checkout_pos_working:
return {'state': 'printer error'}
return {'state': 'ok'}
def populate_db(app):
book1 = Book(isbn13='7796594424423', title='foo', inside_cover_id='A')
book2 = Book(isbn13='9781491946008', title='fluent python') # Fluent Python book
# book2.append_google_book_data() # too slow sometimes...
room1 = Room(id='1', name='Ms Foo')
room2 = Room(id='2', name='Mr Spam')
alice = Person(first_name='Alice', middle_name='X', last_name='Aaronson')
bob = Person(first_name='Bob', last_name='Bobberson')
inactive_student = Person(first_name='Inactive', last_name='Student', active=False)
co1 = Checkout(book=book1, room=room1, person=alice, return_date=datetime.now())
co2 = Checkout(book=book2, room=room2, person=bob)
admin = Admin(username='******', password='******')
with app.app_context():
for rec in (book1, book2, room1, room2, alice, bob, inactive_student, co1, co2, admin):
db.session.add(rec)
print repr(rec), 'added'
db.session.commit()
print 'added some data'
def checkout(book_id):
selected_book = Book.query.get_or_404(book_id)
if not selected_book.is_available:
flash('"%s" (ID: %s) is already checked out. It must be returned before you can check it out.' % (selected_book.title, selected_book.inside_cover_id), category='danger')
return redirect(url_for('.books'))
checkout_form = CheckoutForm()
if checkout_form.validate_on_submit():
new_checkout = Checkout(checkout_date=checkout_form.checkout_date.data, book=selected_book, person=checkout_form.person.data, room=checkout_form.room.data)
db.session.add(new_checkout)
db.session.commit()
flash('Checked out %s to Room %s' % (selected_book.title, checkout_form.room.data.id), category='success')
return redirect(url_for('.books'))
# return render_template('checkout.html', book=bk, people=people, rooms=rooms)
return render_template('checkout.html', book=selected_book, form=checkout_form)
def load_checkout(checkoutlist):
i = 0
while i < len(checkoutlist):
newentry = None
newentry = Checkout(bibnum=int(checkoutlist[i]['bibnum']),
itemtype=checkoutlist[i]['itemtype'],
checkoutmonth=checkoutlist[i]['checkoutmonth'],
checkoutyear=checkoutlist[i]['checkoutyear'],
checkoutday=checkoutlist[i]['checkoutday'],
checkouttime=checkoutlist[i]['checkouttime'])
book = db.session.query(Book).filter(
Book.bibnum == int(checkoutlist[i]['bibnum'])).first()
if book is not None:
db.session.add(newentry)
book.checkoutentry.append(newentry)
db.session.commit()
i += 1
def create(cart_number) -> dict:
""" Create Checkout """
result: dict = {}
try:
data_cart = Cart.query.filter_by(cart_number=cart_number).all()
result_messages = []
for res_cart in data_cart:
data_stock = Stock.query.filter_by(
product_id=res_cart.product_id).first()
if (data_stock is not None and data_stock.stock > 0):
if ((data_stock.stock - res_cart.qty) >= 0):
current_stock = data_stock.stock - res_cart.qty
data_stock.stock = current_stock
remark = "Stock Decreased from " + str(
data_stock.stock) + " to " + str(current_stock)
data_stock.commit()
result = {
'product_id': res_cart.product_id,
'message': remark
}
LogStockRepository.create(current_stock,
res_cart.product_id, remark)
else:
result = {
'product_id': res_cart.product_id,
'message': 'Stock is not Enough'
}
else:
result = {
'product_id': res_cart.product_id,
'message': 'Stock Unavailable'
}
result_messages.append(result)
data = Checkout(cart_number)
data.save()
result = {
'cart_number': cart_number,
'date_created': str(data.date_created),
'message': result_messages
}
except IntegrityError:
Checkout.rollback()
raise ResourceExists('file_name already exists')
return result
def fix_pos_error(staff):
new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(new_loop)
loop = asyncio.get_event_loop()
tasks = []
# send empty requests to test pos machines
for pos in POS.query.filter(POS.ip != '').all():
tasks.append(loop.create_task(send_req(pos)))
try:
loop.run_until_complete(asyncio.gather(*tasks))
finally:
config.order_pos_working = POS.order_pos_all_working()
save_printer_status({
'order_pos_working': config.order_pos_working,
'checkout_pos_working': config.checkout_pos_working
})
if config.order_pos_working is False:
return {'state': 'error'}
else:
tasks = []
# reprint orders
for pos in POS.query.filter(POS.ip != '').all():
for print_failed in pos.fails:
order = print_failed.order
uuid = order.token
time = time_translate(order.order_time)
desk_name = Desk.query.get(order.desk_id).name
staff_name = order.staff.name
note = order.note
data = []
for op in order.order_products:
quantity = op.quantity
data.append(
[op.product_name, op.product_price, quantity])
_format = print_order_format(uuid,
time,
desk_name,
staff_name,
pos.split,
note,
data,
reprint=True)
tasks.append(
loop.create_task(send_req(pos, _format, order)))
# reprint checkout
pos = POS.query.get(1)
for c in Checkout.query.filter_by(printed=False).all():
uuid = c.token
time = time_translate(c.checkout_time)
d_name = c.desk_name
s_name = c.staff.name
check_price = c.total_price
checkout_info = []
for order in Order.query.filter_by(token=uuid).all():
checkout_info.append(order.order_products)
_format = print_bill_format(uuid,
time,
d_name,
s_name,
checkout_info,
check_price,
reprint=True)
tasks.append(
loop.create_task(send_req(pos, _format, checkout=c)))
try:
loop.run_until_complete(asyncio.gather(*tasks))
finally:
config.order_pos_working = POS.order_pos_all_working()
config.checkout_pos_working = Checkout.all_printed()
save_printer_status({
'order_pos_working':
POS.order_pos_all_working(),
'checkout_pos_working':
Checkout.all_printed()
})
if config.order_pos_working or config.checkout_pos_working is False:
return {'state': 'error'}
loop.close()
return {'state': 'ok'}
from models import Item, Checkout
from rules import pricingRules, catalogue
cc = Checkout(pricingRules)
user = None
while True:
user = input("Enter SKU (or type 'end' to quit): ")
if user in catalogue:
cc.scan(Item(user))
elif user == "end":
break
else:
print("[Error] SKU not found")
cc.get_total()
def schedule(request):
schedule=[]
today = date.today()
while today.weekday() >= 5 or ScheduleDay.objects.filter(date=today).count() > 0 and ScheduleDay.objects.get(date=today).day_off:
today += timedelta(1)
schedule_day = None
if ScheduleDay.objects.filter(date=today).count() > 0:
schedule_day = ScheduleDay.objects.get(date=today)
else:
done = False
one_day = timedelta(1)
today_dt = datetime.combine(today, time())
today_dt -= one_day
new_date = today_dt.date()
days_ellapsed = 0
day = 0
while not done:
if new_date.weekday() < 5 and ScheduleDay.objects.filter(date=new_date).count() == 0:
days_ellapsed += 1
elif new_date.weekday() < 5 and not ScheduleDay.objects.get(date=new_date).day_off:
done = True
day = (ScheduleDay.objects.get(date=new_date).day + days_ellapsed) % 7
new_dt = datetime.combine(new_date, time())
new_dt -= one_day
new_date = new_dt.date()
schedule_day = ScheduleDay(date=today, day_off=False, day=day, schedule="")
schedule_day.save()
print(schedule_day.day)
if (schedule_day.schedule == ""
schedule_day.schedule = master_schedule[schedule_day.day]
s
if len(schedule_day.period_set.all()) == 0:
for i in range(len(schedule_day.schedule)):
period = Period(day=schedule_day, period_number=i, period_letter=schedule_day.schedule[i:i + 1])
period.save()
schedule.append([["Day " + str(schedule_day.day + 1)]])
for period in schedule_day.schedule:
schedule.append([[period]])
return render(request, "scanner/schedule.html", {'schedule_table': schedule})
@not_login_required
def checkin (request):
messages = []
if request.method == 'POST':
form = ScanForm(request.POST)
if form.is_valid():
data = form.cleaned_data
idnum = data["scan"]
if len(Person.objects.filter(id=idnum)) != 0:
person = Person.objects.get(id=idnum)
checkins = Checkin.objects.filter(person=person, completed=False)
if len(checkins) == 0:
messages.append("Successfully checked in " + person.first_name + " " + person.last_name)
new_checkin = Checkin(person=person, checkin=datetime.now(), checkout=datetime.now())
new_checkin.save()
else:
for obj in checkins:
obj.checkout = datetime.now()
obj.completed = True
obj.save()
person.hours += float((obj.checkout - obj.checkin).total_seconds()) / 3600
person.save()
messages.append("Successfully checked out " + person.first_name + " " + person.last_name)
form = ScanForm()
return render(request, "scanner/checkin.html", {"form": form, "messages": messages})
@not_login_required
def scan (request, idnum):
idnum = int(idnum)
if idnum < 10000 or idnum > 20000:
return user(request, idnum)
if idnum > 10000 and idnum < 20000:
return checkout_item(request, idnum)
return render(request, "scanner/item.html", {"idnum": idnum})
@not_login_required
def user (request, idnum):
if len(Person.objects.filter(id=idnum)) == 0:
if request.method == 'POST':
form = NewUserForm(request.POST)
if form.is_valid():
person = form.save(commit=False)
person.id = idnum
person.save()
else:
form = NewUserForm()
return render(request, "scanner/newuser.html", {"idnum": idnum, "form": form})
person = Person.objects.get(id=idnum)
messages = []
if request.method == 'POST':
form = ScanForm(request.POST)
if form.is_valid():
if len(CheckoutItem.objects.filter(id=form.cleaned_data["scan"])) > 0:
item = CheckoutItem.objects.get(id=form.cleaned_data["scan"])
if len(Checkout.objects.filter(person=person, item=item, checked_in=False)) > 0:
for checkout in Checkout.objects.filter(person=person, item=item, checked_in=False):
checkout.checked_in = True
checkout.date_returned = datetime.now()
checkout.save()
messages.append(item.name + " successfully checked in.")
else:
new_checkout = Checkout(person=person, item=CheckoutItem.objects.get(id=form.cleaned_data["scan"]), date_checked_out=datetime.now() , date_due=datetime.now() + timedelta(CheckoutItem.objects.get(id=form.cleaned_data["scan"]).default_checkout_time))
new_checkout.save()
messages.append(item.name + " successfully checked out.")
else:
messages.append("That item is not in the database.")
form = ScanForm()
return render(request, "scanner/user.html", {"person": person, "form": form, "checkouts": Checkout.objects.filter(person=person, checked_in=False), "messages": messages})
@not_login_required
def checkout_item (request, idnum):
if len(CheckoutItem.objects.filter(id=idnum)) == 0:
if request.method == 'POST':
form = NewItemForm(request.POST)
if form.is_valid():
item = form.save(commit=False)
item.id = idnum
item.save()
else:
form = NewItemForm()
return render(request, "scanner/newitem.html", {"idnum": idnum, "form": form})
else:
form = NewItemForm()
return render(request, "scanner/newitem.html", {"idnum": idnum, "form": form})
return render(request, "scanner/item.html", {"item": CheckoutItem.objects.get(id=idnum)})
@not_login_required
def checkout(request, personid, itemid):
return render(request, "scanner/item.html", {"item": CheckoutItem.objects.get(id=itemid)})
@login_required
def admin(request):
person = request.user.leadershipmember
return render(request, "scanner/admin.html", {"person": person})
@not_login_required
def admin_login(request):
if request.method == 'POST':
form = AdminLoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
username = data["id"]
password = data["password"]
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return HttpResponseRedirect(reverse("admin"))
form = AdminLoginForm()
return render(request, "scanner/admin_login.html", {"form": form})
@login_required
def admin_add_leadership(request):
if not request.user.leadershipmember.can_add_leadership_members:
return HttpResponseRedirect(reverse("admin"))
if request.method == 'POST':
form = NewLeadershipMemberForm(request.POST)
if form.is_valid():
data = form.cleaned_data
person = Person.objects.get(id=data["id"])
if len(User.objects.filter(username=data["id"])) == 0:
print(data["password"])
user = User.objects.create_user(data["id"], data["email"], data["password"])
user.save()
user = User.objects.get(username=data["id"])
leadershipmember = LeadershipMember(first_name=person.first_name, last_name=person.last_name, id=person.id, hours=person.hours, periods=data["periods"], user=user)
person.delete()
leadershipmember.save()
return HttpResponseRedirect(reverse("admin"))
form = NewLeadershipMemberForm()
return render(request, "scanner/admin_add_leadership.html", {"form": form})
@login_required
def admin_change_permissions(request):
if not request.user.leadershipmember.can_change_leadership_permissions:
return HttpResponseRedirect(reverse("admin"))
leadershipmembers = LeadershipMember.objects.exclude(id=request.user.leadershipmember.id)
return render(request, "scanner/admin_change_permissions.html", {'leadershipmembers': leadershipmembers})
@login_required
def admin_edit_info(request):
if request.method == 'POST':
form = LeadershipEditInfoForm(request.POST, instance=request.user.leadershipmember)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("admin"))
form = LeadershipEditInfoForm(instance=request.user.leadershipmember)
return render(request, "scanner/admin_edit_info.html", {"form": form})
@login_required
def admin_change_user_permissions(request, id):
if not request.user.leadershipmember.can_change_leadership_permissions:
return HttpResponseRedirect(reverse("admin"))
if request.method == 'POST':
form = ChangePermissionsForm(request.POST)
if form.is_valid():
print("1")
data = form.cleaned_data
lm = LeadershipMember.objects.get(id=id)
lm.can_add_leadership_members = data["can_add_leadership_members"]
lm.can_change_leadership_permissions = data["can_change_leadership_permissions"]
lm.save()
return HttpResponseRedirect(reverse("admin change permissions"))
person = request.user.leadershipmember
form = ChangePermissionsForm(instance=LeadershipMember.objects.get(id=id))
return render(request, "scanner/admin_change_user_permissions.html", {"form": form, "person": person, "id": id})
def checkout(self, outdate, who, hw, reason, quantity, user):
c = Checkout(outdate=outdate, who=who, hardware=hw,
what=hw.id, reason=reason, quantity=quantity, out_auth_user=user,
out_auth_email=user.id)
self.add(c)
from models import Item, Checkout
from rules import pricingRules
# Test case 1
cc = Checkout(pricingRules)
cc.scan(Item("atv"))
cc.scan(Item("atv"))
cc.scan(Item("atv"))
cc.scan(Item("vga"))
cc.get_total()
# Test case 2
cc = Checkout(pricingRules)
cc.scan(Item("atv"))
cc.scan(Item("ipd"))
cc.scan(Item("ipd"))
cc.scan(Item("atv"))
cc.scan(Item("ipd"))
cc.scan(Item("ipd"))
cc.scan(Item("ipd"))
cc.get_total()
# Test case 3
cc = Checkout(pricingRules)
cc.scan(Item("mbp"))
cc.scan(Item("vga"))
cc.scan(Item("ipd"))
cc.get_total()
