def create_order(db: Session, order: schemas.OrderCreate):
fake_hashed_password = user.password + "notreallyhashed"
db_user = models.Order(email=user.email, hashed_password=fake_hashed_password)
db.add(db_order)
db.commit()
db.refresh(db_order)
return db_order
def create_order(db: Session, date: datetime, status: str,
order: schemas.OrderCreate):
db_order = models.Order(status=status, date=date)
db.add(db_order)
db.commit()
db.refresh(db_order)
return db_order
def createOrder(params):
'''
:param params: Dictionary of elements to be inserted in Order model
:return: status code and message
Status = 200 and message = records created successfully if data will be saved successfully to models
Status = 200 and message = record already exist if record with same id already exists
Status = 400 and message = error message if there is any error while inserting record
'''
try:
orderid = int(params['orderid'])
customer_name = params['customer_name']
if validateOrder(orderid):
resp = {
'payload': {'message': 'Record already exists'},
'status_code': 200
}
else:
neworder= models.Order(orderid, customer_name)
models.db.session.add(neworder)
models.db.session.commit()
resp = {
'payload': {'message': 'Record created successfully'},
'status_code': 200
}
except Exception as e:
resp = {
'payload': {'message': str(e)},
'status_code': 400
}
return resp
def AddStandardKitOrder(request, prefix):
user, _, _ = common.GetUser(request)
skos = models.OrderSheet.all().filter('code = ', 'SDK').get()
if not skos:
logging.warn('can not find SDK order sheet')
return http.HttpResponse(
urlresolvers.reverse(AddStandardKitOrder, args=[prefix]))
i = skos.item_set.get()
if not i:
logging.warn('can not find item for SDK order sheet')
return http.HttpResponse(
urlresolvers.reverse(AddStandardKitOrder, args=[prefix]))
for site in models.NewSite.all().filter('program =',
user.program_selected):
if not site.number.startswith(prefix):
logging.info('skipping site %r because wrong prefix %r',
site.number, prefix)
continue
if site.order_set.filter('order_sheet = ', skos).count():
logging.info('skipping site %r because has SDK order', site.number)
continue
sko = models.Order(site=site, order_sheet=skos, state='Received')
sko.put()
oi = models.OrderItem(order=sko, item=i, quantity_float=1)
oi.put()
logging.info('created SDK order for site %r', site.number)
sko.UpdateSubTotal()
sko.put()
return http.HttpResponse(
urlresolvers.reverse(AddStandardKitOrder, args=[prefix]))
def post(self):
"""Make an order for a copy of book"""
body = request.get_json()
borrower = body.get('borrower')
borrower = query_user_by_name(borrower)
if borrower is None:
return 'User does not exit', 404
if invalid_user(borrower.username):
return 'Unauthorized user, please login as a user/borrower', 401
copy_id = body.get('copy_id')
copy = db.session.query(models.Copy).filter_by(id=copy_id).first()
if copy is None:
return 'Copy ID not found ' + str(copy_id), 409
if copy.status == BOOK_COPY_STATUS_UNAVAILABLE:
return 'The copy of the book is not available', 400
copy_owner = body.get('copy_owner')
owner = query_user_by_name(copy_owner)
if owner is None:
return 'Copy owner not found ' + copy_owner, 409
new_order = models.Order()
new_order.parse_body(body)
new_order.status = ORDER_STATUS_REQUESTED
db.session.add(new_order)
db.session.commit()
return new_order.serialize(), 201
def machine(request):
# Generate a unique token for this order.
curr_time = time.time()
seed = request.form["seed"]
prices = rates.WeightedRates(settings.BTC_MARGIN)
price = prices.sell
rand = random.SystemRandom(seed + str(curr_time) + str(price)).random()
token = hashlib.sha256(str(rand)).hexdigest().upper()[0:9]
usd = Decimal(request.form["usd"])
btc = (usd / price).quantize(
Decimal('.00000001'), rounding = ROUND_DOWN)
# Save the order.
app.db.session.add(models.Order(
token, seed, rand, usd, btc, price, request.remote_addr
))
app.db.session.commit()
# Return amount bought.
return {
"order_token": token,
"btc_ordered": str(btc),
"btc_price": str(price),
"usd_to_send": str(usd),
"mailing_address": settings.BTC_MAILING_ADDRESS
}
def order(name):
orderform = forms.OrderForm()
if orderform.main.data != 'Nothing' or orderform.side.data != 'Nothing' or orderform.drink.data != 'Nothing':
order = models.Order(
status='Order Received',
date_in=datetime.datetime.now(),
date_out=orderform.date.data,
user=models.User.query.filter_by(username=name).first())
if orderform.main.data != 'Nothing':
ofl = models.OrderFoodLog(food=models.Food.query.filter_by(
item=orderform.main.data).first(),
order=order)
flash(f'{orderform.main.data} has been ordered successfully!!')
if orderform.side.data != 'Nothing':
ofl = models.OrderFoodLog(food=models.Food.query.filter_by(
item=orderform.side.data).first(),
order=order)
flash(f'{orderform.side.data} has been ordered successfully!!')
if orderform.drink.data != 'Nothing':
ofl = models.OrderFoodLog(food=models.Food.query.filter_by(
item=orderform.drink.data).first(),
order=order)
flash(f'{orderform.drink.data} has been ordered successfully!!')
models.db.session.add(order)
models.db.session.commit()
return redirect(url_for('home', name=name))
else:
flash(f'Sorry! You must choose atleast one item to make an order.')
return redirect(url_for('home', name=name))
def index():
# login session
if 'user_id' not in session:
return redirect(url_for('view.login'))
user_id = session['user_id']
Session = sessionmaker(bind=maco_db)
s = Session()
user = s.query(models.User).filter_by(id=user_id).first()
if user is None:
current_app.logger.error(f'Unexpected error: {user_id} is not found in DB')
return redirect(url_for('view.login'))
menu = s.query(models.Menu).filter_by(finish=0).first()
if menu is None:
return redirect(url_for('view.addmenu'))
menulist = [menu.menu1, menu.menu2, menu.menu3]
date = menu.date
if request.method == 'POST':
order_num = int(request.form['menunum'])
tmp = s.query(models.Order).filter_by(date=date, user_id=user_id).first()
if tmp is None:
s.add(models.Order(date, user_id, order_num))
else:
tmp.order_num = order_num
s.commit()
tmp = s.query(models.Order).filter_by(date=date, user_id=user_id).first()
if tmp is None:
myorder = 0
else:
myorder = tmp.order_num
order = s.query(models.Order).filter_by(date=date).all()
orderlist = []
ordersum = [0, 0, 0]
for row in order:
if row.order_num < 1:
continue
tmp = s.query(models.User).filter_by(id=row.user_id).first()
num = row.order_num - 1
orderlist.append([tmp.name, menulist[num]])
ordersum[num] = ordersum[num] + 1
message = ''
for i in range(len(menulist)):
if ordersum[i] > 0:
message = message + f'{menulist[i]}\t{ordersum[i]}つ\n'
if message != '':
message = message + 'お願いします'
dt = datetime.datetime.strptime(str(date), '%Y%m%d')
month = int(dt.strftime('%m'))
day = int(dt.strftime('%d'))
week = int(dt.strftime('%j')) - int(dt.strftime('%W')) * 7
date = f'{month}月{day}日({weekstr[week]}) '
return render_template('index.html', date=date, menu=menulist, myorder=myorder, order=orderlist, message=message)
def new(self, request):
order = models.Order(creation_date=datetime.datetime.now(),
status=models.Order.INCOMPLETE)
if request.user.is_authenticated():
order.user = request.user
order.save()
request.session[ORDER_ID] = order.pk
return order
async def create_order(
new_order: schemas.OrderInDB,
current_account: schemas.Account = Depends(get_current_account),
db: Session = Depends(get_db)):
if not current_account.role_id in [0, 1]:
raise HTTPException(status_code=403,
detail="Permission Not Found with role id =" +
str(current_account.role_id))
sent_date = datetime.today()
updated_date = sent_date
updated_by = current_account.user_id
student_id = current_account.user_id
db_type = db.query(models.EssayType).filter(
models.EssayType.type_id == new_order.essay.type_id).first()
db_optionlist = db.query(models.Option).all()
if not db_type:
raise HTTPException(status_code=400, detail="Type ID not found")
db_essay = models.Essay(title=new_order.essay.title,
content=new_order.essay.content,
type_id=new_order.essay.type_id,
created_at=sent_date,
updated_at=updated_date)
db.add(db_essay)
db.commit()
db.refresh(db_essay)
total_price = 0
deadline_hour = 0
for option_id in new_order.option_list:
total_price += db_optionlist[option_id].option_price
if db_optionlist[option_id].option_type == 1:
deadline_hour = int(db_optionlist[option_id].option_name)
total_price += db_type.type_price
#Set deadline
db_order = models.Order(student_id=student_id,
status_id=0,
sent_date=sent_date,
updated_date=sent_date,
updated_by=updated_by,
essay_id=db_essay.essay_id,
option_list='-'.join(
str(item) for item in new_order.option_list),
total_price=total_price,
is_disabled=False,
deadline=None)
db.add(db_order)
db.commit()
db.refresh(db_order)
return get_order_response(db_order, db)
def get_order(order_id):
data, error = models.Order(order_id).get()
if not error:
if data['orderStatus'] == "https://schema.org/OrderPaymentDue" and utils.is_date_in_past(
utils.from_datestring(data['paymentDueDate'])):
return utils.error_response('anonymous_lease_expired')
else:
return utils.json_response(data)
else:
return utils.error_response(error)
def request_order(self):
try:
self.order = models.session.query(
models.Order).filter_by(order_id=self.order_id).first()
except:
self.attempt_query += 1
if self.attempt_query < 3:
models.session.rollback()
self.request()
print('\nОшибка запроса')
self.order = models.Order()
self.attempt_query = 0
def _create_order(self):
s = self.current_suggestion
session = models.Session()
order = models.Order(s.buy_account.name, s.buy_price,
s.sell_account.name, s.sell_price, s.stock_qty)
try:
session.add(order)
session.commit()
return order
except Exception as e:
_logger.error(e)
session.rollback()
return None
def wait_for_order_to_complete(order_id):
"""
Block (repeatedly request status) of the given
order_id until it is fulfilled.
Returns the Order.
"""
time.sleep(10)
ordr = coinex_api.order_status(order_id)
while not ordr['cancelled'] and not ordr['complete']:
time.sleep(10)
ordr = coinex_api.order_status(order_id)
time.sleep(10)
return models.Order(API_resp=ordr)
def post(self):
args = Order.parser.parse_args()
data = json.loads(args['data'][0].replace(
"\'", "\"")) # json 형식에 맞게 작은따옴표를 쌍따옴표로 바꾸고 dictionary화
# Orders Table
# 총 금액
total_price = data['totalPrice']
try:
order_time = datetime.now() # 주문 시각
order = models.Order(order_time=order_time,
completed=False,
total_price=total_price) # 주문 행 생성
session.add(order)
session.flush() # 주문 메뉴 연결하기 위해 pk 생성 필요
# 넘겨받은 주문 메뉴 리스트
menu_list = data['menus']
for each in menu_list:
# Products Table
# 주문 메뉴 1개에 대한 Product Table 레코드 생성
order_menu_pk = each['menuId'] # 메뉴 pk
quantity = each['quantity'] # 수량
product = models.OrderProduct(order_pk=order.order_pk,
order_menu_pk=order_menu_pk,
quantity=quantity)
session.add(product)
session.flush() # 주문 옵션을 연결하기 위해 pk 생성 필요
product_pk = product.product_pk
# Order_options Table
# 주문 옵션 리스트
for each_option in each['options']:
option_id = each_option # 옵션 pk
product_option = models.OrderOption(
product_pk=product_pk,
option_pk=option_id) # 주문 메뉴와 연결
session.add(product_option)
session.commit() # 아무 문제 없으면 DB 반영
except Exception as err:
session.rollback() # 에러 시 rollback
return Response(status=400) # 에러코드 전송
session.close()
# 문제 없다면
return Response(status=201) # CREATED 코드 전송
def add_orders(db: Session, orders: schemas.OrdersPostRequest):
answer = defaultdict(list)
for i in orders.data:
id = schemas.OrderId(id=i.order_id)
order = models.Order(order_id=i.order_id,
weight=i.weight,
region=i.region)
_add_order(db, order)
_add_delivery_hours_for_order(db, i.order_id, i.delivery_hours)
answer['orders'].append(id)
return answer
def checkout(request):
z = check_login_cookie(request)
if z == 0:
return redirect('/login/')
if z[0] == 2:
return redirect('/')
if request.POST:
addr = request.POST['address']
oid = request.POST['oid']
md.Order.objects.filter(id=int(oid)).update(
delivery_addr=addr, status=md.Order.ORDER_STATE_PLACED)
return redirect('/search/?placed=1')
else:
cart = request.COOKIES['cart'].split(",")
cart = dict(Counter(cart))
items = []
totalprice = 0
uid = md.User.objects.filter(username=z[1])
oid = md.Order()
oid.orderedby = uid[0]
oid.save()
for x, y in cart.iteritems():
item = []
it = md.Menu.objects.filter(id=int(x))
if len(it):
oiid = md.OrderItems()
oiid.item = it[0]
oiid.quantity = int(y)
oiid.oid = oid
oiid.save()
totalprice += int(y) * it[0].price
item.append(it[0])
it[0].quantity = it[0].quantity - y
it[0].save()
item.append(y)
item.append(it[0].price * int(y))
oid.restaurant_id = it[0].restaurant_id
items.append(item)
oid.total_amount = totalprice
oid.save()
context = {
"items": items,
"totalprice": totalprice,
"oid": oid.id,
"loggedin": 1,
"username": z[1],
}
return render(request, 'order.html', context)
def setUp(self):
self.order = models.Order(orderId=1,
pickup_lat=11.0,
pickup_lon=22.0,
dropoff_lat=33.0,
dropoff_lon=44.0)
self.courier = models.Courier(courierId=1, lat=88.0, lon=99.0)
self.mkres = mcaller.MunkresCaller()
self.order1 = models.Order(orderId=1,
pickup_lat=1.0,
pickup_lon=2.0,
dropoff_lat=3.0,
dropoff_lon=4.0)
self.order2 = models.Order(orderId=2,
pickup_lat=11.0,
pickup_lon=21.0,
dropoff_lat=31.0,
dropoff_lon=41.0)
self.orders = [self.order1, self.order2]
self.courier1 = models.Courier(courierId=1, lat=11.0, lon=22.0)
self.courier2 = models.Courier(courierId=1, lat=2.0, lon=2.0)
self.couriers = [self.courier1, self.courier2]
def test_orders(self):
c1 = models.Currency(1, 'FOO', 'Foocoin')
c2 = models.Currency(2, 'BAR', 'Barcoin')
exc = models.Exchange(1, c1, c2)
ordr = models.Order(
order_id=1,
exchange=exc,
bid=True,
amount=Decimal('1.998'),
rate=Decimal(2),
filled=Decimal(1)
)
comp = ordr.get_compliment()
self.assertTrue(comp.exchange == exc, 'Exchanges should match')
self.assertTrue(comp.rate == Decimal(2), 'Rates should match')
self.assertTrue(comp.amount == Decimal('1'), 'amount should match')
async def get(self):
if await tornado.gen.Task(client.exists, "USDrate1"):
rate = await tornado.gen.Task(client.get, "USDrate1")
else:
http = AsyncHTTPClient()
response = await http.fetch("https://api.coindesk.com/v1/bpi/currentprice/USD.json")
body = loads(response.body.decode())
rate = body["bpi"]["USD"]["rate"]
await tornado.gen.Task(client.set, "USDrate1", rate, expire=settings.REDIS_TTL)
se = models.StockExchange()
i = 0
while i < 20:
se.orders.append(models.Order("buy", 10000, i))
i += 1
await tornado.gen.Task(client.lpush, "orders", *se.save_to_json())
se1 = models.StockExchange(await tornado.gen.Task(client.lrange, "orders", 0, -1))
self.render('templates/current_rate.html', rate=rate, stock_exchange=se1)
def create_order(db: Session, customer_id: int, food_id: int, q: int):
validate_customer(db=db, customer_id=customer_id)
food_available(db=db, food_id=food_id, q=q)
db_order = models.Order()
db_order.customer_id = customer_id
db_order.food_id = food_id
db_order.status = "Order Created"
db_order.quantity = q
db.add(db_order)
update_quantity = db.query(
models.Food).filter(models.Food.food_id == food_id).first()
update_quantity.food_quantity -= q
db.commit()
db.refresh(db_order)
return db_order
def OrderNew(request, site_id=None, order_sheet_code=None):
"""Create a new order and forward to the edit screen."""
user, _, _ = common.GetUser(request)
if user is None:
return http.HttpResponseRedirect(users.CreateLoginURL(request.path))
site = models.NewSite.get_by_id(int(site_id))
order_sheet = models.OrderSheet.all().filter('code = ',
order_sheet_code).get()
# TODO: error if order_sheet is None
order = models.Order(site=site, order_sheet=order_sheet, state='new')
order.put()
for item in order.order_sheet.item_set:
order_item = models.OrderItem(order=order, item=item)
order_item.put()
redirect, template_dict = _OrderPut(request, user, order)
if redirect is not None:
return redirect
else:
return common.Respond(request, 'order', template_dict)
def orders():
if request.method == "GET":
branch_id = request.args.get("branch_id")
if not branch_id:
return "Branch missing"
branch = models.Branch.query.filter_by(id=branch_id).first()
return make_response(
jsonify(list(map(lambda order: order.serialize(), branch.orders))))
elif request.method == "POST":
if not request.json["products"] or not request.json[
"station_id"] or not request.json["branch_id"]:
return "Parameter missing"
products = request.json["products"]
order = models.Order(total=0,
station_id=request.json["station_id"],
branch_id=request.json["branch_id"])
total = 0
for item in products:
op = models.OrderProduct(quantity=item["quantity"])
product = models.Product.query.filter_by(id=item["id"]).first()
op.product_id = product.id
order.products.append(op)
total += Decimal.from_float(product.price) * Decimal.from_float(
item["quantity"])
if len(item["selectedCustomizations"]) > 0:
for customization in item["selectedCustomizations"]:
opc = models.OrderProductCustomization()
opc.customization_id = customization["id"]
op.customizations.append(opc)
total += Decimal.from_float(
customization["price"]) * Decimal.from_float(
item["quantity"])
order.total = total
db.session.add(order)
db.session.commit()
return order.serialize()
def register_order(self, first_name, last_name, email, phone, country,
region, locality, postal_code, label, shipment_method,
line_items):
"""
@param line_items list of dictionaries, each representing a product. Each
has keys 'sku' and 'quantity'
@type line_items list
@return order id
"""
order = models.Order(first_name=first_name,
last_name=last_name,
email=email,
phone=phone,
country=country,
region=region,
locality=locality,
postal_code=postal_code,
label=label)
try:
order.shipment_method = models.ShipmentMethod.objects.get(
name=shipment_method, active=True)
except models.ShipmentMethod.DoesNotExist:
raise exceptions.InvalidOrderException(
'shipment method %s not found' % (shipment_method))
order.save()
try:
for item in line_items:
models.LineItem.objects.create(sku=item['sku'],
quantity=item['quantity'],
order=order)
except KeyError:
raise exceptions.InvalidOrderException(
'each line item must include a sku and quantity')
return order.id
async def create_order(
new_order: schemas.OrderInDB,
status_id: int,
current_account: schemas.Account = Depends(get_current_account),
db: Session = Depends(get_db)):
if not current_account.role_id == 1:
raise HTTPException(status_code=403,
detail="Permission Not Found with role id =" +
str(current_account.role_id))
sent_date = date.today().strftime("%Y/%m/%d")
updated_date = sent_date
updated_by = current_account.user_id
student_id = current_account.user_id
db_type = db.query(models.EssayType).filter(
models.EssayType.type_id == new_order.essay.type_id).first()
db_optionlist = db.query(models.Option).all()
if not db_type:
raise HTTPException(status_code=400, detail="Type ID not found")
db_essay = models.Essay(
title=new_order.essay.title,
content=new_order.essay.content,
type_id=new_order.essay.type_id,
)
db.add(db_essay)
db.commit()
db.refresh(db_essay)
total_price = 0
for option_id in new_order.option_list:
total_price += db_optionlist[0].option_price
total_price += db_type.type_price
db_order = models.Order(student_id=current_account.user_id,
status_id=status_id,
sent_date=sent_date,
updated_date=sent_date,
updated_by=current_account.user_id,
essay_id=db_essay.essay_id,
option_list='-'.join(
str(item) for item in new_order.option_list),
total_price=total_price)
db.add(db_order)
db.commit()
db.refresh(db_order)
create_order_response = schemas.OrderResponse(
status_id=db_order.status_id,
order_id=db_order.order_id,
student_id=db_order.student_id,
teacher_id=db_order.teacher_id,
sent_date=sent_date,
updated_date=sent_date,
updated_by=db_order.student_id,
essay=schemas.EssayResponse(essay_id=db_essay.essay_id,
title=db_essay.title,
content=db_essay.content,
type_id=db_essay.type_id),
option_list=[int(item) for item in db_order.option_list.split("-")],
total_price=db_order.total_price)
return create_order_response
# os.mkdir(scratch) # if not os.path.exists(os.path.join(scratch, scratchgdb)): # arcpy.CreateFileGDB_management(scratch, "scratch.gdb") # return scratch, scratchgdb # arcpy parameter OrderIDText = arcpy.GetParameterAsText(0) BufsizeText = arcpy.GetParameterAsText(1) yesBoundary = arcpy.GetParameterAsText(2) multipage = arcpy.GetParameterAsText(3) gridsize = arcpy.GetParameterAsText(4) scratch = arcpy.env.scratchFolder scratchgdb = arcpy.env.scratchGDB # order info order_obj = models.Order().get_order(OrderIDText) # # parameters # gridsize = "0.3 KiloMeters" # BufsizeText ='0.17' resolution = "600" # # flags # multipage = False # True/False # yesBoundary = "yes" # yes/no/fixed # delyearFlag = "Y" # Y/N nrf = 'N' # Y/N # scratch file # scratch, scratchgdb = createScratch() orderGeometry = os.path.join(scratch, scratchgdb, "orderGeometry")
def add_order():
"""Add order to data base."""
if request.method == 'POST':
type_ = None
country = None
zip_ = None
city = None
address = None
vval = None
year = None
month = None
cnb = None
data = request.form.to_dict()
if user_loggined():
uid = session.get('user_id')
user = models.User.query.get(uid)
name = data.get('name')
email = data.get('email')
card = data.get('card')
u_cards = user.cards.all()
for _card in u_cards:
if _card.type[:4] == card[:4] and _card.cnb[-9:] == card[-9:]:
type_ = _card.type
cnb = _card.cnb
month = _card.month
year = _card.year
vval = _card.vval
adr = data.get('adr')
u_addresses = user.addresses.all()
for _adr in u_addresses:
if adr == _adr.address:
address = _adr.address
city = _adr.city
zip_ = _adr.zip
country = _adr.country
clothes_name = data.get('clothes_name')
clothes_colors = data.get('clothes_colors')
size = data.get('size')
tel = data.get('tel')
if name is not None and \
email is not None and \
type_ is not None and \
cnb is not None and \
month is not None and \
year is not None and \
vval is not None and \
address is not None and \
city is not None and \
zip_ is not None and \
country is not None and \
clothes_name is not None and \
clothes_colors is not None and \
size is not None and \
tel is not None:
_max = 1
for _order in models.Order.query.all():
_max = max(_max, _order.order_id)
colors = pickle.dumps(clothes_colors.split(' '))
order = models.Order(order_id=_max + 1,
user_id=uid,
name=name,
email=email,
clothes_name=clothes_name,
size=size,
tel=tel,
card=card,
adr=adr,
clothes_colors=colors)
db.session.add(order)
db.session.commit()
return redirect(url_for('index'))
def pay(request):
pays = models.PayMethod.objects.all()
cart = request.session.get("cart")
orderid = request.session.get("orderid")
conn = models.Consignees.objects.all()
if request.method == "POST":
uname = request.session.get("myuser")
print "用户", uname
name = request.POST.get('name')
print "收货人", name
addr = request.POST.get('addr')
print "地址", addr
code = request.POST.get('code')
print "邮编", code
tel = request.POST.get('tel')
print "电话", tel
beizhu = request.POST.get('beizhu')
print "备注", beizhu
payid = request.POST.get('pay')
print "付款id", payid
pay = models.PayMethod.objects.get(id=payid)
user = models.Fuser.objects.get(username=uname)
print "用户对象", user
try:
conobj = models.Consignees.objects.get(user=user,
name=name,
addr=addr,
code=code,
tel=tel)
except Exception, e:
con = models.Consignees(user=user,
name=name,
addr=addr,
code=code,
tel=tel)
con.save()
conobj = models.Consignees.objects.get(user=user,
name=name,
addr=addr,
tel=tel)
orderstatus = models.OrderStatus.objects.get(status='等待收货')
buser = models.Buser.objects.get(id=1)
order = models.Order(order_serial=orderid,
user=user,
name=conobj,
pay=pay,
descriptiont=beizhu,
status=orderstatus,
operator=buser,
amount=cart.total_price)
order.save()
orderobj = models.Order.objects.get(order_serial=orderid)
for item in cart.items:
good = models.Goods.objects.get(id=item.good.id)
ordergoodnew = models.OrderGoods(good=good,
price=item.price,
amount=item.count)
ordergoodnew.save()
ordergoodnew.order_id.add(orderobj.id)
del request.session['cart']
del request.session['orderid']
return HttpResponseRedirect('/myorder/')
def create_testdata():
click.echo('Create test data.')
member = models.Member()
member.username = '******'
member.password = views.membership.bcrypt.generate_password_hash('123123')
member.realname = 'Liszt'
member.email = '*****@*****.**'
member.sex = 'male'
member.phone = '0356225446'
member.permission = 0x1
models.db.session.add(member)
goods_type = models.GoodsType()
goods_type.size = 'L'
goods_type.state = 'test'
goods_type.price = 682
models.db.session.add(goods_type)
goods_type_m = models.GoodsType()
goods_type_m.size = 'M'
goods_type_m.state = 'test'
goods_type_m.price = 881
models.db.session.add(goods_type_m)
for i in range(1,730):
goods = models.Goods()
goods_image1 = models.GoodsImages()
goods_image1.goods = goods
goods.state = 'To sell'
if i % 2 == 0:
goods_image2 = models.GoodsImages()
goods_image2.goods = goods
goods.name = 'KITTEN 曉貓'+ str(i)
goods.type = goods_type
goods_image1.image = '/static/images/cat4.jpg'
models.db.session.add(goods_image1)
goods_image2.image = '/static/images/cat2.jpg'
models.db.session.add(goods_image2)
else:
goods.name = 'BIRD_AND_CAT 鳥&貓 '+ str(i)
goods.type = goods_type_m
goods_image1.image = '/static/images/cat3.jpg'
models.db.session.add(goods_image1)
goods.author = member
goods.description = '''ka[dsg ks[dkfm[aosdkr]papsk f]pok kapflklkalks [pk[
dgkds sd;lf';l d;s
[ a[lsdf'
sd; klsdk; lfkps;dlpfl, sp;l
sdf ;lkl;sdk ;lksd;lkf[pqle[prk '''
models.db.session.add(goods)
order = models.Order()
order.amount = 881
order.purchaser = member
models.db.session.add(order)
order_item = models.OrderItem()
order_item.quantity = 1
order_item.goods = goods
order_item.order = order
models.db.session.add(order_item)
comment1 = models.Comment()
comment1.author = member
comment1.goods = goods
comment1.message = '?????????渣SA{DQ@ㄉ@``CSCf;ll;z;'
models.db.session.add(comment1)
comment2 = models.Comment()
comment2.author = member
comment2.goods = goods
comment2.message = '爛!!!!!!!!!afgbbxvxv豬ad45675O--i092I0U302909JPJR3'
models.db.session.add(comment2)
comment3 = models.Comment()
comment3.author = member
comment3.goods = goods
comment3.message = 'xafaxoooooofafos@肥豬鷹!XXXXXXXXXXXXXXXXXXXXX'
models.db.session.add(comment3)
rating2 = models.Rating()
rating2.author = member
rating2.for_order_item = order_item
rating2.score = 1
rating2.message = '爛!!!!!!!!!afasjfjKJEPKRJPO--i092I0U302909JPJR3'
models.db.session.add(rating2)
rating = models.Rating()
rating.author = member
rating.for_order_item = order_item
rating.score = 3
rating.message = 'sdogkpa!I@(_)_)UafF())I#){(RU)USJOJIJLKJlj ojroqi *&:((((('
models.db.session.add(rating)
rating2 = models.Rating()
rating2.author = member
rating2.for_order_item = order_item
rating2.score = 1
rating2.message = '爛!!!!!!!!!afasjfjKJEPKRJPO--i092I0U302909JPJR3'
models.db.session.add(rating2)
models.db.session.commit()
ShipOrder("T5_"+str(neworder.id), oldguy['fname']+" "+oldguy['lname'], oldguy['ship_address1'], oldguy['ship_address2'], oldguy['ship_city'], oldguy['ship_state'], oldguy['ship_zipcode'], "US", p)
else: # declined
future = datetime.datetime.now() + datetime.timedelta(days=1) #retry tomorrow
theretrynum = x['retrynum'] + 1
if (x['retrynum'] >= MAX_RETRY_MAIL) and (not process.success):
try: # we declined repeatedly...
mailservs = models.Smtpserver.objects(storeid=str(nmiaccount['id']))[0]
except:
mailservs = models.Smtpserver.objects()[0]
nmiCancel(str(prod['id']), str(nmiaccount['id'])) # take us out of monthly_willbill
sm = tMail(mailservs['host'], mailservs['port']) # send "update your card" email
sm.login(mailservs['username'], mailservs['password'], oldguy['email'])
with open(os.path.join('emails', mailservs['theme'], 'updatecard.html')) as fd:
macros = {'fname': oldguy['fname'], # set keywords
'lname': oldguy['lname'],
'email': oldguy['email'],
'prod': prodname,
'total': str(prodamount),
'ccnum': ('*'*12)+newcard['card_number'][-4:],
'decline_times': x['retrynum']}
email = fd.read()
for x in macros.keys(): # replace {KEYWORD} with macro value
email = email.replace("{"+x+"}", macros[x])
sm.send(email) # shoot it off
x['batched'] = True
x.save() # mark rebill as ran
x = models.Rebill(card=str(oldcard.id), customer=str(oldguy.id), pid=x['pid'], date=future.strftime("%d/%m/%Y"), retrynum=theretrynum, nmi_id=x['nmi_id'])
x.save() # rebill them again
neworder = models.Order(creditcard=str(oldcard.id), products=x['pid'], tracking="rebill", order_date=datetime.datetime.now(), success=process.success, server_response=process.str_response, nmi_id=x['nmi_id'])
neworder.save() # record that transaction
