def induction():
return redirect("approval")
form = InductionForm()
if request.method == 'POST':
if form.validate():
if form.correct_to_invoice.data == 'y':
correct = True
else:
correct = False
if form.replacement_available.data == 'y':
replacement = True
else:
replacement = False
if form.light_noted.data == 'y':
noted = True
else:
noted = False
if correct:
r = models.Order(
invoice_num=form.invoice_num.data,
side=form.side.data,
light_type=form.light_type.data,
correct_to_invoice=correct,
induction_employee_code=form.induction_employee_code.data,
light_noted=noted,
induction_date=datetime.now(),
status='Pending',
light_type_comments=form.light_type_comments.data)
else:
r = models.Order(
invoice_num=form.invoice_num.data,
side=form.side.data,
light_type=form.light_type.data,
correct_to_invoice=correct,
induction_employee_code=form.induction_employee_code.data,
induction_date=datetime.now(),
status='Rejected',
replacement_available=replacement,
replacement_comments=form.replacement_comments.data,
light_type_comments=form.light_type_comments.data)
db.session.add(r)
db.session.commit()
#return render_template('thanks.html')
flash('Record saved.')
return redirect("induction")
else:
print(form.errors)
return render_template('induction.html', form=form)
def post_booking(request):
print(request.POST)
property_id = request.POST['property_id']
start_date = request.POST['start_date']
end_date = request.POST['end_date']
guest_number = request.POST['guest_number']
sd = datetime.datetime.strptime(start_date, '%m/%d/%Y').date()
ed = datetime.datetime.strptime(end_date, '%m/%d/%Y').date()
if not models.Order.objects.filter(start_date__lte=ed,
end_date__gte=sd,
propertyID_id=property_id).exists():
order = models.Order()
order.propertyID = models.Property.objects.get(id=property_id)
# order.propertyID.rent_times += 1
# order.propertyID.save()
order.tenantID = request.user
order.start_date = sd
order.end_date = ed
order.tenant_number = guest_number
order.save()
return HttpResponse(1)
else:
return HttpResponse(2)
return HttpResponse(3)
def add_order():
order_id = request.json['order_id']
qty = request.json['qty']
number = request.json['number']
customer = request.json['customer']
email = request.json['email']
product = request.json['product']
status = request.json['status']
note = request.json['note']
identification = request.json['identification']
city = request.json['city']
province = request.json['province']
new_order = md.Order(
order_id = order_id,
qty = qty,
number = number,
customer = customer,
email = email,
product = product,
status = status,
note = note,
identification = identification,
city = city,
province = province
)
md.db.session.add(new_order)
md.db.session.commit()
return md.order_schema.jsonify(new_order)
def create_order():
params = request.get_json()
new_order = models.Order(params.get('customer_id'), params.get('weight'),
params.get('price_per_kilo'), datetime.now())
db.session.add(new_order)
db.session.commit()
return jsonify({"message": "OK"})
def test_create(self, session_maker):
session = session_maker()
assert 0 == session.query(models.Order).count()
user = self.create_fake_user(session)
order = models.Order(user_id=user.id)
session.add(order)
session.commit()
assert 1 == session.query(models.Order).count()
assert order == session.query(models.Order).first()
def post(self):
"""Create a new order"""
data = request.json
order = models.Order(title=data['title'], payer_id=data['contactId'])
db.session.add(order)
for appointment in data['appointments']:
app = models.Appointment(customer_id=appointment['customerId'], order_id=order.id,
timeslot_id=appointment['slotId'])
app.order = order
db.session.add(app)
db.session.commit()
db.session.refresh(order, ['id'])
return order, 201
def checkout(cart_code):
cart = models.Cart.query.filter(models.Cart.code == cart_code).first()
order_code = uuid.uuid1()
order = models.Order(code=str(order_code),
final_price=calculateTotalPriceFromCart(cart),
elements=transformCartElementsToOrderElements(
cart.elements, order_code),
discounts=cart.discounts,
final_price_decimals=2)
cart.checked_out = True
db.session.add(order)
db.session.commit()
return {'code': order_code}
def create_fake_order(self, session, user=None, create_items=True):
if not user:
user = self.create_fake_user(session)
order = models.Order(user_id=user.id)
session.add(order)
session.commit()
if create_items:
order_item = self.create_fake_order_item(session, order=order)
order.items = order_item
session.add(order)
session.commit()
return order
def post(cls):
data = api.payload
new_order = models.Order()
if data["cart_id"] > 0:
cart_id = data["cart_id"]
cart = models.Cart.query.get(cart_id)
if cart:
for cartline in cart.cart_lines:
new_orderline = models.OrderLine()
new_orderline.order = new_order
new_orderline.product_id = cartline.product_id
new_orderline.quantity = cartline.quantity
db.session.add(new_orderline)
if data["user_id"] > 0:
user_id = data["user_id"]
user = models.User.query.get(user_id)
if user:
new_order.user = user
new_order.billing_address1 = data["billing_address1"]
new_order.billing_address2 = data["billing_address2"]
new_order.billing_city = data["billing_city"]
new_order.billing_state = data["billing_state"]
new_order.billing_zip = data["billing_zip"]
new_order.shipping_address1 = data["shipping_address1"]
new_order.shipping_address2 = data["shipping_address2"]
new_order.shipping_city = data["shipping_city"]
new_order.shipping_state = data["shipping_state"]
new_order.shipping_zip = data["shipping_zip"]
new_order.contact = data["contact"]
new_order.date_created = datetime.now()
cart.status = models.Cart.CartStatus.CLOSE
else:
return api.abort(400)
try:
db.session.add(new_order)
db.session.add(cart)
db.session.commit()
except Exception as ex:
db.session.rollback()
return api.abort(500, ex)
return {"order_id": new_order.id}, 200
def populate_samples():
"""Creates default content in the database"""
vgr = models.Customer(firstname='Vincent',
lastname='Girard-Reydet',
phone='06.13.283.000',
email='vincent;girardreydet___@gmail___.com')
sd = models.Customer(firstname='Sara',
lastname='Doukkali',
phone='06.09.40.00.00',
email='sara_doukkali___@yahoo___.fr')
ts1 = models.TimeSlot(start=datetime.datetime(2017, 12, 1, 8, 45),
duration=7200,
trainers='JP,Germain',
capacity=8,
free_capacity=8)
ts2 = models.TimeSlot(start=datetime.datetime(2017, 12, 1, 11, 55),
duration=7200,
trainers='JP',
capacity=4,
free_capacity=4)
ts3 = models.TimeSlot(start=datetime.datetime(2017, 12, 1, 14, 30),
duration=7200,
trainers='JP,Germain',
capacity=8,
free_capacity=8)
ts4 = models.TimeSlot(start=datetime.datetime(2017, 12, 1, 17, 00),
duration=7200,
trainers='JP,Germain',
capacity=8,
free_capacity=8)
vgr.create()
sd.create()
ts1.create()
ts2.create()
ts3.create()
ts4.create()
o1 = models.Order(payer=vgr, title='vgr: Sample order')
o1.create()
a1 = models.Appointment(customer=vgr, order=o1, timeslot=ts1)
a2 = models.Appointment(customer=vgr, order=o1, timeslot=ts2)
a1.create()
a2.create()
def create_order(
request: schemas.OrderRequestType,
db: Session = Depends(db.db_connection),
current_user: schemas.UserRequestType = Depends(oauth2.get_current_user),
):
customer = db.query(m.Customer).first()
if db.query(m.Order).filter_by(code=request.code).first():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail="Order already existed")
else:
new_order: m.Order = m.Order(
code=request.code,
customer_id=customer.id,
)
db.add(new_order)
db.commit()
db.refresh(new_order)
return new_order
def place_order():
r = request.get_json()
account = models.Account.query.filter_by(name=r['account']).first()
o = models.Order(owner=account,
stock=r['stock'],
type=r['type'],
side=r['side'],
volume=r['volume'],
limit=r['limit'])
db.session.add(o)
db.session.commit()
response = {
"id": o.id,
"side": o.side,
"volume": o.volume,
"limit": o.limit,
"status": "open"
}
while (catan_ex.trade(r['stock'])):
pass
return make_response(jsonify({"response": response}), 200)
def test_create_with_multiple_items(self, session_maker):
session = session_maker()
user = self.create_fake_user(session)
items = self.create_fake_items(session, _quantity=10)
assert 0 == session.query(models.Order).count()
order = models.Order(user_id=user.id)
session.add(order)
session.commit()
order = session.query(models.Order).first()
order_item = self.create_fake_order_item(
session, order=order, items=items
)
session.add(order)
session.commit()
assert 1 == session.query(models.Order).count()
assert order == session.query(models.Order).first()
assert 10 == len(items)
assert 10 == len(order.items)
for item, order_item in zip(items, order.items):
assert item.id == int(order_item.item_id)
def order_fixture(_create_fake_user_and_item, session_maker):
session = session_maker()
order = models.Order(user_id=_create_fake_user_and_item.user.id, )
session.add(order)
session.flush()
items = _create_fake_user_and_item.items
for item in items:
order_item = models.OrderItem(
order_id=order.id,
item_id=item.id,
price=round(random.uniform(1, 100), 2),
discount=round(random.uniform(1, 100), 2),
quantity=random.randint(1, 20),
)
session.add(order_item)
session.flush()
session.commit()
info = collections.namedtuple('info', 'order session')
return info(order=order, session=session)
def approval():
form = ApprovalForm()
if request.method == 'POST':
if form.validate():
#Add any images to S3_Bucket
s3 = boto3.resource('s3')
"""
if image_URI_list[len(image_URI_list)-1] == None or image_URI_list[len(image_URI_list)-1] == '':
image_URI_list = image_URI_list[:-1]
print
print
print("FOUND BLANK IMAGE")
print("length of list is..")
print(len(image_URI_list))
"""
s3_image_list = []
files = request.files.getlist('files[]')
if files:
for f in files:
if (f.content_type == 'image/png'):
base64_URI = f.stream
s3_filename = uuid4(
).hex + '.png' #Generate random filename
s3.Bucket(S3_BUCKET).put_object(
Key=s3_filename,
Body=base64_URI,
ContentType='image/png',
ACL='public-read')
i = models.Image(file_name=s3_filename,
s3_bucket=S3_BUCKET,
approval_date=datetime.now())
s3_image_list.append(i)
"""
if form.approval_type.data == 'Recon':
r = Order.query.filter_by(invoice_num=form.invoice_num.data).first()
for s3_image in s3_image_list:
r.images.append(s3_image)
r.approval_employee_code = form.approval_employee_code.data
r.tracking_number = form.tracking_number.data
if form.have_repair.data == 'y':
r.have_repair = True
r.repair_comments = form.repair_comments.data
else:
r.have_repair = False
if form.stickered_engraved.data == 'y':
r.stickered_engraved = True
else:
r.stickered_engraved = False
r.light_approved = form.light_approved.data
if form.light_approved.data != 'Yes':
r.approval_comments = form.approval_comments.data
r.approval_type = 'Recon'
r.notes = form.notes.data
r.approval_date = datetime.now()
r.status = 'Approved'
else:
"""
print("SWAP: " + str(form.swap_out.data))
if form.light_approved.data != 'Yes':
comm = form.approval_comments.data
else:
comm = ''
r = models.Order(
invoice_num=form.invoice_num.data,
tracking_number=form.tracking_number.data,
approval_employee_code=form.approval_employee_code.data,
light_approved=form.light_approved.data,
notes=form.notes.data,
approval_comments=comm,
approval_type=form.approval_type.data,
light_type=form.light_type.data,
interchange=form.interchange.data,
approval_date=datetime.now(),
tested_bare=form.tested_bare.data,
repair_comments=form.repair_comments.data,
have_repair=form.have_repair.data,
swap_out=form.swap_out.data,
bake_wash=form.bake_wash.data,
light_noted=form.light_noted.data,
status='Approved')
for s3_image in s3_image_list:
r.images.append(s3_image)
db.session.add(r)
db.session.commit()
flash('Record saved.')
return redirect("approval")
else:
return json.dumps(form.errors)
return render_template('approval.html', form=form)
def create_order(self, data):
order = models.Order(customer=data['customer'])
for detail in data['detail']:
order.add_product(detail['product'], detail['quantity'])
return order
def create_order():
return jsonify(
models.Order(id=uuid.uuid4(), img=None, prd=None, box=None, price=0))
