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