def post(self): try: db = get_connection() result = self.get_argument("result") method = self.get_argument("method", None) cart_no = result[2:] res = get_model("ecom.cart").search([["number", "=", cart_no]]) if not res: raise Exception("Invalid cart number") cart_id = res[0] cart = get_model("ecom.cart").browse(cart_id) if method: cart.update_paysbuy_method(method) if result.startswith("00") and not cart.is_paid: set_active_user(1) set_active_company(1) cart.import_paysbuy_payment() # Inquiry Doublecheck db.commit() except Exception as e: db = get_connection() db.rollback import traceback audit_log("Failed to get result payment from paysbuy", details=traceback.format_exc()) traceback.print_exc()
def post(self): try: db = get_connection() result = self.get_argument("result") method = self.get_argument("method", None) cart_no = result[2:] res = get_model("ecom.cart").search([["number", "=", cart_no]]) if not res: raise Exception("Invalid cart number") cart_id=res[0] cart=get_model("ecom.cart").browse(cart_id) if method: cart.update_paysbuy_method(method) db = database.get_connection() db.commit() if result.startswith("00") and not cart.is_paid: set_active_user(1) set_active_company(1) cart.import_paysbuy_payment() # Inquiry Doublecheck db.commit() except Exception as e: db = get_connection() db.rollback import traceback audit_log("Failed to get result payment from paysbuy", details=traceback.format_exc()) traceback.print_exc()
def login(self, context={}): set_active_user(None) data = context["data"] db_name = data.get("db_name") if not db_name: raise Exception("Missing db name") database.set_active_db(db_name) login = data["login"] password = data["password"] user_id = get_model("base.user").check_password(login, password) if not user_id: audit_log("Invalid login (%s)" % login) db = database.get_connection() db.commit() raise Exception("Invalid login") try: print("login ok", login) set_active_user(1) user = get_model("base.user").browse(user_id) if user.profile_id.prevent_login or not user.active: raise Exception("User not allowed to login") t = time.strftime("%Y-%m-%d %H:%M:%S") user.write({"lastlog": t}) profile = user.profile_id action = profile.home_action or "account_board" token = new_token(db_name, user_id) db = database.get_connection() res = db.get("SELECT * FROM pg_class WHERE relname='settings'") settings = get_model("settings").browse(1) version = settings.version mod_version = get_module_version() if version != mod_version: raise Exception("Database version (%s) is different than modules version (%s), please upgrade database before login." % ( version, mod_version)) company_id = user.company_id.id or profile.login_company_id.id if not company_id: res = get_model("company").search([["parent_id", "=", None]]) if not res: raise Exception("No company found") company_id = res[0] comp = get_model("company").browse(company_id) return { "cookies": { "dbname": database.get_active_db(), "user_id": user_id, "token": token, "user_name": user.name, "package": settings.package, "company_id": company_id, "company_name": comp.name, }, "next": { "type": "url", "url": "/ui#name=%s" % action, }, "login_action": action, } finally: set_active_user(user_id) audit_log("Login")
def post(self): try: db = get_connection() print("########################################") print("###########Result Paypal Ipn############") print("########################################") payment_status = self.get_argument("payment_status", None) if payment_status != "Completed": raise Exception("Paypal transaction is not completed") invoice = self.get_argument("invoice") set_active_user(1) set_active_company(1) res = get_model("ecom.cart").search([["number", "=", invoice]]) if not res: raise Exception("Invalid cart number: %s"%invoice) cart_id = res[0] cart=get_model("ecom.cart").browse(cart_id) website=cart.website_id receiver_email = self.get_argument("receiver_email", None) if receiver_email != website.paypal_user: raise Exception("Wrong paypal receiver email") if not website.paypal_user: raise Exception("Missing paypal user in cms setting") if not website.paypal_password: raise Exception("Missing paypal password in cms setting") if not website.paypal_signature: raise Exception("Missing paypal signature in cms setting") if not website.paypal_url: raise Exception("Missing paypal URL Server in cms setting") params = {} for argument in self.request.arguments: params[argument] = argument[0].decode('utf-8') params['cmd'] = '_notify-validate' if website.paypal_url == "test": url = "https://www.sandbox.paypal.com/cgi-bin/webscr" else: url = "https://www.paypal.com/cgi-bin/webscr" data = urllib.parse.urlencode(params) data = data.encode('utf-8') req = urllib.request.Request(url, data) response = urllib.request.urlopen(req) word = response.read() verify = word.decode('utf-8') if verify != "VERIFIED": raise Exception("Failed to verify payment") mc_gross = float(self.get_argument("mc_gross", None)) if cart.amount_total != mc_gross: raise Exception("Amount total doesn't match") cart.import_paypal_payment() # TODO Add Token print("Payment Created") db.commit() except Exception as e: db = get_connection() db.rollback import traceback audit_log("Failed to get IPN from paypal", details=traceback.format_exc()) traceback.print_exc()
def post(self): db = get_connection() try: try: fields = ["old_password", "new_password", "re_password"] field_errors = {} form_vals = {} for n in fields: v = self.get_argument(n, None) form_vals[n] = v if not v: field_errors[n] = True if field_errors: raise Exception("Some required fields are missing") user_id = get_active_user() if not user_id: raise Exception("No user") user = get_model("base.user").browse(user_id) user_id = get_model("base.user").check_password( user.email, form_vals["old_password"]) if not user_id: raise Exception("Wrong password") if len(form_vals["new_password"]) < 6: raise Exception( "New password must be more than 6 character") if form_vals["new_password"] != form_vals["re_password"]: raise Exception( "New password does not match confirmed password") get_model("base.user").write( [user_id], {"password": form_vals["new_password"]}) get_model("base.user").trigger( [user_id], "change_password", context={"new_password": form_vals["new_password"]}) self.redirect( "/cms_account?message=Your%20password%20has%20been%20changed" ) db.commit() except Exception as e: db = get_connection() error_message = str(e) ctx = self.context ctx["form_vals"] = form_vals ctx["error_message"] = error_message ctx["field_errors"] = field_errors content = render("cms_change_pass", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def check_payment_online(self, ids, context={}): obj = self.browse(ids)[0] date = time.strftime('%Y%m%d%H%M%S') qs = urllib.parse.urlencode([ ('mid', 1000006741), ('terminal', 524114384), ('command', 'CRINQ'), ('ref_no', obj.number), ('ref_date', date), ('service_id', 10), ('cur_abbr', 'THB'), ('amount', obj.amount_total), ]) url = 'https://nsips-test.scb.co.th:443/NSIPSWeb/NsipsMessageAction.do?' data = qs.encode('utf-8') req = urllib.request.Request(url, data) response = urllib.request.urlopen(req) ur = response.read() te = ur.decode('utf-8') p = urllib.parse.parse_qsl(te) params = dict(list(map(lambda x: (x[0], x[1]), p))) payment_status = params['payment_status'] or '' amount = params['amount'] or '' trans_no = params['trans_no'] or '' if payment_status == "002": try: db = get_connection() vals = { "type": "in", "pay_type": "invoice", "contact_id": obj.contact_id.id, "date": time.strftime("%Y-%m-%d"), "ref": trans_no, "account_id": obj.account_id.id, "currency_id": obj.currency_id.id, "lines": [("create", { "type": "invoice", "invoice_id": obj.id, "account_id": obj.account_id.id, "amount": amount, })] } pmt_id = get_model("account.payment").create(vals, context={"type": vals["type"]}) get_model("account.payment").post([pmt_id]) db.commit() except Exception as e: db = get_connection() db.rollback import traceback audit_log("Failed to get result payment from scb", details=traceback.format_exc()) traceback.print_exc()
def post(self): db = get_connection() try: try: print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") print(self.request.protocol) print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") fields = ["email", "password"] field_errors = {} form_vals = {} for n in fields: v = self.get_argument(n, None) form_vals[n] = v if not v: field_errors[n] = True if field_errors: raise Exception("Some required fields are missing") user_id = get_model("base.user").check_password( form_vals["email"], form_vals["password"]) if not user_id: raise Exception("Invalid login") set_active_user(user_id) dbname = get_active_db() token = new_token(dbname, user_id) self.set_cookie("user_id", str(user_id)) self.set_cookie("token", token) cart_id = self.get_cookie("cart_id") if cart_id: cart_id = int(cart_id) get_model("ecom.cart").set_default_address([cart_id]) db.commit() url = self.get_argument("return_url", None) if not url: url = "/cms_account" self.redirect(url) except Exception as e: db = get_connection() error_message = str(e) ctx = self.context ctx["form_vals"] = form_vals ctx["error_message"] = error_message ctx["field_errors"] = field_errors content = render("cms_login", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def post(self): db=get_connection() try: try: print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") print(self.request.protocol) print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") fields=["email","password"] field_errors={} form_vals={} for n in fields: v=self.get_argument(n,None) form_vals[n]=v if not v: field_errors[n]=True if field_errors: raise Exception("Some required fields are missing") user_id=get_model("base.user").check_password(form_vals["email"],form_vals["password"]) if not user_id: raise Exception("Invalid login") set_active_user(user_id) dbname=get_active_db() token=new_token(dbname,user_id) self.set_cookie("user_id",str(user_id)) self.set_cookie("token",token) cart_id=self.get_cookie("cart_id") if cart_id: cart_id=int(cart_id) get_model("ecom.cart").set_default_address([cart_id]) db.commit() url=self.get_argument("return_url",None) if not url: url="/cms_account" self.redirect(url) except Exception as e: db=get_connection() error_message=str(e) ctx=self.context ctx["form_vals"]=form_vals ctx["error_message"]=error_message ctx["field_errors"]=field_errors content=render("cms_login",ctx) ctx["content"]=content html=render("cms_layout",ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def money_out(self, context={}): company_id = get_active_company() company_ids = get_model("company").search([["id", "child_of", company_id]]) db = get_connection() res = db.query( "SELECT COALESCE(l.due_date,l.move_date) AS due_date,SUM(l.credit-l.debit) as amount FROM account_move_line l JOIN account_account a ON a.id=l.account_id LEFT JOIN account_reconcile r ON r.id=l.reconcile_id WHERE l.move_state='posted' AND a.type='payable' AND l.reconcile_id IS NULL AND a.company_id IN %s GROUP BY COALESCE(l.due_date,l.move_date)", tuple(company_ids), ) amounts = {} for r in res: amounts[r.due_date] = r.amount values = [] d0 = date.today() d1 = d0 + timedelta(days=60) d = d0 while d < d1: ds = d.strftime("%Y-%m-%d") values.append((js_time(d), amounts.get(ds, 0))) d += timedelta(days=1) data = {"value": [{"key": "Payable", "values": values}]} res = db.get( "SELECT count(*) AS count,SUM(amount_total_cur) AS amount FROM account_invoice WHERE type='in' AND inv_type='invoice' AND state='draft' AND company_id IN %s", tuple(company_ids), ) if res: data["draft_count"] = res.count data["draft_amount"] = res.amount res = db.get( "SELECT count(*) AS count,SUM(amount_total_cur) AS amount FROM account_invoice WHERE type='in' AND inv_type='invoice' AND state='waiting_payment' AND due_date<now() AND company_id IN %s", tuple(company_ids), ) if res: data["overdue_count"] = res.count data["overdue_amount"] = res.amount return data
def get_report_data(self, ids, context={}): company_id = get_active_company() comp = get_model("company").browse(company_id) if ids: params = self.read(ids, load_m2o=False)[0] else: params = self.default_get(load_m2o=False, context=context) settings = get_model("settings").browse(1) if not params.get("account_id"): return account_id = int(params.get("account_id")) date_from = params.get("date_from") date_to = params.get("date_to") if not date_from and not date_to: date_from = date.today().strftime("%Y-%m-01") date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d") acc = get_model("account.account").browse(account_id, context={"date_to": date_to}) acc_balance = acc.balance acc_unrec = get_model("account.account").browse( account_id, context={"date_to": date_to, "bank_rec_state": "not_reconciled"}) unrec_paid_amt = acc_unrec.credit unrec_received_amt = acc_unrec.debit rec_paid = [] condition = [["account_id", "=", account_id], ["move_id.state", "=", "posted"], ["move_id.date", ">=", date_from], [ "move_id.date", "<=", date_to], ["state", "=", "reconciled"], ["credit", ">", 0]] for line in get_model("account.move.line").search_browse(condition, order="move_id.date,id"): vals = { "date": line.move_id.date, "description": line.description, "ref": line.move_id.number, "amount": line.credit - line.debit, } rec_paid.append(vals) rec_received = [] condition = [["account_id", "=", account_id], ["move_id.state", "=", "posted"], ["move_id.date", ">=", date_from], [ "move_id.date", "<=", date_to], ["state", "=", "reconciled"], ["debit", ">", 0]] for line in get_model("account.move.line").search_browse(condition, order="move_id.date,id"): vals = { "date": line.move_id.date, "description": line.description, "ref": line.move_id.number, "amount": line.debit - line.credit, } rec_received.append(vals) db = database.get_connection() data = { "company_name": comp.name, "date_from": date_from, "date_to": date_to, "account_name": acc.name, "rec_paid": rec_paid, "total_rec_paid": sum([l["amount"] for l in rec_paid]), "rec_received": rec_received, "total_rec_received": sum([l["amount"] for l in rec_received]), "acc_balance": acc_balance, "unrec_paid_amt": unrec_paid_amt, "unrec_received_amt": unrec_received_amt, "st_balance": acc_balance + unrec_paid_amt - unrec_received_amt, } return data
def get(self): db = get_connection() try: cart_id = int(self.get_argument("cart_id")) print("cart_id", cart_id) cart = get_model("ecom.cart").browse(cart_id) set_active_company(1) user_id = get_active_user() website = self.context["website"] ctx = self.context ctx["cart"] = cart if not cart.is_paid and website.payment_slip_template_id and (cart.pay_method_id.id == website.bank_method_id.id): tmpl_name = website.payment_slip_template_id.name url = "/report?type=report_jasper&model=ecom.cart&convert=pdf&ids=[%d]&template=%s" % ( cart.id, tmpl_name) ctx["payment_slip_report_url"] = url content = render("ecom_order_confirmed", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get_report_data(self, ids, context={}): if ids: params = self.read(ids, load_m2o=False)[0] else: params = self.default_get(load_m2o=False, context=context) company_id = get_active_company() comp = get_model("company").browse(company_id) settings = get_model("settings").browse(1) date_from = params.get("date_from") date_to = params.get("date_to") if not date_from: date_from = date.today().strftime("%Y-%m-01") if not date_to: date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d") data = { "company_name": comp.name, "date_from": date_from, "date_to": date_to, "total_qty": 0, "total_amount": 0, } db = get_connection() res = db.query( "SELECT l.product_id,p.name AS product_name,p.sale_price AS product_price,SUM(l.amount) AS amount,SUM(l.qty) AS qty FROM account_invoice_line l,account_invoice i,product p WHERE i.id=l.invoice_id AND p.id=l.product_id AND i.date>=%s AND i.date<=%s GROUP BY l.product_id,p.name,p.sale_price ORDER BY p.name", date_from, date_to) lines = [] for r in res: line = r line["avg_price"] = line["amount"] / line["qty"] if line["qty"] else None lines.append(line) data["total_qty"] += line["qty"] data["total_amount"] += line["amount"] data["lines"] = lines data["total_avg_price"] = data["total_amount"] / data["total_qty"] if data["total_qty"] else None pprint(data) return data
def post(self): db = get_connection() try: data_json = self.get_argument("json_str", None) if not data_json: raise Exception("Can't get json_str") data = json.loads(data_json) cart_id = self.get_cookie("cart_id", None) if not cart_id: raise Exception("Can't get cart id") cart_id = int(cart_id) cart = get_model("ecom.cart").browse(cart_id) order = 0 for line in cart.lines: for item in data: if item.get('order') == order: line.write({"ship_method_id": item.get('method_id')}) order += 1 cart.calc_shipping() amount_ship = "{:0,.2f}".format(float(cart.amount_ship)) amount_total = "{:0,.2f}".format(float(cart.amount_total)) total = { "amount_ship": amount_ship, "amount_total": amount_total, } data = json.dumps(total) self.write(data) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get(self): raise Exception("Polling is disabled") # XXX #print("ListenPoll.get",os.getpid()) global sending_notifs t=time.strftime("%Y-%m-%d %H:%M:%S") dbname=get_active_db() if not dbname: raise Exception("Missing dbname in long poll request") db=None try: db=get_connection() user_id=self.get_cookie("user_id",None) if user_id: user_id=int(user_id) res=db.get("INSERT INTO ws_listener (user_id,last_check_time) VALUES (%s,%s) RETURNING id",user_id,t) self.listener_id=res.id self.dbname=dbname listen_handlers[self.listener_id]=self if not sending_notifs: io_loop=tornado.ioloop.IOLoop.instance() io_loop.add_timeout(time.time()+POLL_WAIT,send_notifs) # XXX: should start this directly when process is started? sending_notifs=True db.commit() except: print("#########################################################") print("ERROR: ListenPoll.get failed") if db: db.rollback() import traceback traceback.print_exc()
def get(self): db = get_connection() try: user_id = self.get_cookie("user_id", None) if user_id: user_id = int(user_id) user = get_model("base.user").browse(user_id) ctx = self.context ctx["coupons_available"] = get_model( "sale.coupon").search_browse( [["contact_id", "=", user.contact_id.id], ["state", "=", "available"]]) ctx["coupons_in_use"] = get_model("sale.coupon").search_browse( [["contact_id", "=", user.contact_id.id], ["state", "=", "in_use"]]) ctx["coupons_used"] = get_model("sale.coupon").search_browse( [["contact_id", "=", user.contact_id.id], ["state", "=", "used"]]) ctx["coupons_expired"] = get_model( "sale.coupon").search_browse( [["contact_id", "=", user.contact_id.id], ["state", "=", "expired"]]) content = render("ecom_coupons", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) else: self.redirect("cms_login") db.commit() except: import traceback traceback.print_exc() db.rollback()
def post(self): db = get_connection() try: user_id = self.get_cookie("user_id", None) product_id = self.get_argument("product_id") if user_id: user_id = int(user_id) user = get_model("base.user").browse(user_id) if not user.contact_id: raise Exception("Cannot find contact with user_id: ", user_id) vals = { "contact_id": user.contact_id.id, "product_id": product_id, "date": time.strftime("%Y-%m-%d %H:%M:%S"), } res = db.query( "SELECT COUNT(*) FROM ecom_wishlist WHERE contact_id = %s AND product_id = %s" % (user.contact_id.id, product_id) ) res = res[0]["count"] or 0 if res == 0: get_model("ecom.wishlist").create(vals) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get(self): db = get_connection() try: ctx = self.context brand_id=self.get_argument("brand_id",None) if brand_id: brand_id = int(brand_id) else: brand_code=self.get_argument("brand_code",None) res=get_model("product.brand").search([["code","=",brand_code]]) if not res: raise Exception("Product brand not found: '%s'"%brand_code) brand_id=res[0] res = get_model("product.brand").browse([brand_id]) if not res: raise Exception("Can't find product brand id: ",brand_id) brand = res[0] ctx["product_brand"] = brand ctx["parent_brand_list"] = list_brand_parent(brand, brand_list=[]) content = render("ecom_product_brand", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: self.redirect("/cms_page_not_found") import traceback traceback.print_exc() db.rollback()
def round(self, cur_id, amt, scale=2): db = database.get_connection() if not amt: return 0 amt = Decimal( db.query('select round(%s,%s) as out' % (amt, scale))[0]['out']) return amt
def get(self): self.get_argument("token") # TODO: check token dbname=database.get_active_db() db=database.get_connection() try: db.begin() set_active_user(None) user_id=1 user=get_model("base.user").browse(user_id) t=time.strftime("%Y-%m-%d %H:%M:%S") user.write({"lastlog":t}) comp=get_model("company").browse(1) set_active_user(user_id) audit_log("Login token") url="http://nf1.netforce.com/update_lastlogin?dbname=%s"%dbname req=urllib.request.Request(url) try: urllib.request.urlopen(req).read() except: print("ERROR: failed to update last login time") token=new_token(dbname,user_id) self.set_cookie("dbname",dbname) self.set_cookie("user_id",str(user_id)) self.set_cookie("token",token) self.set_cookie("user_name",quote(user.name)) # XXX: space self.set_cookie("company_name",quote(comp.name)) self.set_cookie("package",comp.package) self.redirect("http://%s.my.netforce.com/action#name=account_board"%dbname.replace("_","-")) db.commit() except: db.rollback()
def post(self): db = database.get_connection() data = {} try: data["barcode"] = self.get_argument("barcode", None) data["qty"] = self.get_argument("qty", None) barcode = data["barcode"] if not barcode: raise Exception("Missing barcode!") barcode = int(barcode) qty = data["qty"] if not qty: raise Exception("Missing qty!") qty = int(qty) res = get_model("production.component").search( [["id", "=", barcode]]) if not res: raise Exception("Invalid barcode") comp_id = res[0] # TODO: create goods issue for that component db.commit() self.redirect("/issue_rm") except Exception as e: data["error"] = "ERROR: %s" % e html = template.render("issue_rm", data) self.write(html) db.rollback() import traceback traceback.print_exc()
def get(self): db = get_connection() try: country_id = self.get_argument("country_id") print(country_id) country = get_model("country").browse(int(country_id)) if not country: raise Exception("Country not found") provinces = [] for province in country.provinces: vals = { 'name': province.name, 'id': province.id, 'code': province.code, } provinces.append(vals) provinces = sorted(provinces, key=lambda k: k['name']) print(provinces) data = json.dumps(provinces) self.write(data) db.commit() except: import traceback traceback.print_exc() db.rollback()
def send_notifs(): #print("send_notifs",os.getpid(),list(listen_handlers.keys())) t=time.strftime("%Y-%m-%d %H:%M:%S") db_handlers={} for listener_id,h in listen_handlers.items(): # XXX db_handlers.setdefault(h.dbname,[]).append(listener_id) for dbname,listener_ids in db_handlers.items(): set_active_db(dbname) db=get_connection() try: ids_sql="("+",".join(str(x) for x in listener_ids)+")" res=db.query("SELECT listener_id,name FROM ws_event WHERE listener_id IN "+ids_sql) if res: handler_events={} for r in res: handler_events.setdefault(r.listener_id,[]).append(r.name) for listener_id,events in handler_events.items(): print("NOTIFY %s %s %s"%(dbname,listener_id,events)) handler=listen_handlers[listener_id] handler.write(json.dumps(events)) handler.finish() del listen_handlers[listener_id] db.execute("DELETE FROM ws_event WHERE listener_id IN "+ids_sql) db.execute("UPDATE ws_listener SET last_check_time=%s WHERE id IN "+ids_sql,t) # XXX: do this less often db.execute("DELETE FROM ws_listener WHERE last_check_time<TIMESTAMP %s-INTERVAL '10 seconds'",t) # XXX: do this less often, FIXME db.commit() except: print("#########################################################") print("ERROR: send_notifs failed") db.rollback() import traceback traceback.print_exc() io_loop=tornado.ioloop.IOLoop.instance() io_loop.add_timeout(time.time()+POLL_WAIT,send_notifs)
def get(self): db = get_connection() try: ctx = self.context edit_form_vals = {} for addr in ctx["customer"].addresses: edit_form_vals[addr.id] = { "first_name": addr.first_name, "last_name": addr.last_name, "company": addr.company, "address": addr.address, "address2": addr.address2, "province": addr.province, "province_id": addr.province_id.id, "district_id": addr.district_id.id, "subdistrict_id": addr.subdistrict_id.id, "postal_code": addr.postal_code, "country": addr.country_id.name, "phone": addr.phone, } ctx["edit_form_vals"] = edit_form_vals content = render("ecom_addresses", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def migrate(self): res = get_model("stock.journal").search([]) if res: print("Stock journals already created") return vals = { "name": "Goods Receipts", "type": "in", } in_id = get_model("stock.journal").create(vals) vals = { "name": "Goods Transfers", "type": "internal", } internal_id = get_model("stock.journal").create(vals) vals = { "name": "Goods Issues", "type": "out", } out_id = get_model("stock.journal").create(vals) db = get_connection() db.execute("UPDATE stock_picking SET journal_id=%s WHERE type='in'", in_id) db.execute( "UPDATE stock_picking SET journal_id=%s WHERE type='internal'", internal_id) db.execute("UPDATE stock_picking SET journal_id=%s WHERE type='out'", out_id)
def get(self): db = get_connection() try: ctx = self.context seller_id = int(self.get_argument("seller_id")) comp = get_model("company").browse(seller_id) #products=get_model("product").search_browse([["company_id","=",seller_id]]) res = get_model("product.group").search_browse([["code","=","seller_new"],["company_id","=",seller_id]]) if not res: raise Exception("No product group code 'seller_new' in company: ",comp.name) new_product_group = res[0] res = get_model("product.group").search_browse([["code","=","seller_rec"],["company_id","=",seller_id]]) if not res: raise Exception("No product group code 'seller_new' in company: ",comp.name) rec_product_group = res[0] ctx["seller"]={ "name": comp.name, "new_product_group": new_product_group, "rec_product_group": rec_product_group, } content = render("ecom_seller", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: self.redirect("/cms_page_not_found") import traceback traceback.print_exc() db.rollback()
def get(self): db = get_connection() try: ctx = self.context page_code = self.get_argument("page") res = get_model("cms.page").search([["code", "=", page_code]]) if not res: self.redirect("/cms_page_not_found") return page_id = res[0] page = get_model("cms.page").browse(page_id) if page.state == "inactive": self.redirect("/cms_page_not_found") return ctx["page"] = page tmpl_name = page.template or "cms_page" content = render(tmpl_name, ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get_balance_90d(self, ids, context={}, nocache=False): if not nocache: min_ctime = time.strftime("%Y-%m-%d 00:00:00") vals = get_model("field.cache").get_value("account.account", "balance_90d", ids, min_ctime=min_ctime) remain_ids = [id for id in ids if id not in vals] if remain_ids: res = self.get_balance_90d(remain_ids, context=context, nocache=True) for id, data in res.items(): vals[id] = data get_model("field.cache").set_value("account.account", "balance_90d", id, data) return vals print("#########################################################################") print("get_balance_90d CACHE MISS", ids) date_from = datetime.date.today() - datetime.timedelta(days=90) date_to = datetime.date.today() db = database.get_connection() vals = {} for id in ids: balance = self.get_balance([id], context={"date_to": date_from.strftime("%Y-%m-%d")})[id]["balance"] q = "SELECT move_date,debit,credit FROM account_move_line WHERE account_id=%s AND move_date>%s AND move_date<=%s AND move_state='posted' ORDER BY move_date" res = db.query(q, id, date_from, date_to) d = date_from data = [] for r in res: while d.strftime("%Y-%m-%d") < r["move_date"]: data.append([time.mktime(d.timetuple()) * 1000, balance]) d += datetime.timedelta(days=1) balance += (r["debit"] or 0) - (r["credit"] or 0) while d <= date_to: data.append([time.mktime(d.timetuple()) * 1000, balance]) d += datetime.timedelta(days=1) vals[id] = data return vals
def post(self): db = get_connection() try: user_id = self.get_cookie("user_id", None) product_id = self.get_argument("product_id") if user_id: user_id = int(user_id) user = get_model("base.user").browse(user_id) if not user.contact_id: raise Exception("Cannot find contact with user_id: ", user_id) vals = { "contact_id": user.contact_id.id, "product_id": product_id, "date": time.strftime("%Y-%m-%d %H:%M:%S"), } res = db.query( "SELECT COUNT(*) FROM ecom_wishlist WHERE contact_id = %s AND product_id = %s" % (user.contact_id.id, product_id)) res = res[0]['count'] or 0 if res == 0: get_model("ecom.wishlist").create(vals) db.commit() except: import traceback traceback.print_exc() db.rollback()
def init_db(): db = database.get_connection() db.execute("INSERT INTO settings (id) VALUES (1)") enc_pass=encrypt_password('1234') db.execute("INSERT INTO profile (id,name) VALUES (1,'System Admin')") db.execute("INSERT INTO base_user (id,login,password,name,profile_id,active) VALUES (1,'admin',%s,'Admin',1,true)",enc_pass) db.execute("INSERT INTO company (id,name) VALUES (1,'Test Company')")
def get_report_data(self, ids, context={}): company_id = get_active_company() company_ids = get_model("company").search([["id", "child_of", company_id]]) comp = get_model("company").browse(company_id) if ids: params = self.read(ids, load_m2o=False)[0] else: params = self.default_get(load_m2o=False, context=context) settings = get_model("settings").browse(1) date_from = params.get("date_from") if not date_from: date_from = date.today().strftime("%Y-%m-01") date_to = params.get("date_to") if not date_to: date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d") data = { "company_name": comp.name, "date_from": date_from, "date_to": date_to, "by_rate": params.get("by_rate"), "by_comp": params.get("by_comp"), } db = database.get_connection() if params.get("by_comp"): res = db.query("SELECT c.id AS comp_id,c.name AS comp_name,c.rate AS comp_rate,r.name AS rate_name,SUM(l.credit-l.debit) AS tax_total,SUM(l.tax_base*sign(l.credit-l.debit)) AS base_total FROM account_move_line l,account_move m,account_tax_component c,account_tax_rate r WHERE m.id=l.move_id AND m.state='posted' AND m.date>=%s AND m.date<=%s AND c.id=l.tax_comp_id AND r.id=c.tax_rate_id AND m.company_id IN %s GROUP BY comp_id,comp_name,comp_rate,rate_name ORDER BY comp_name,rate_name", date_from, date_to, tuple(company_ids)) data["comp_taxes"] = [dict(r) for r in res] if params.get("by_rate"): res = db.query("SELECT c.id AS comp_id,c.name AS comp_name,c.rate AS comp_rate,r.name AS rate_name,SUM(l.credit-l.debit) AS tax_total,SUM(l.tax_base*sign(l.credit-l.debit)) AS base_total FROM account_move_line l,account_move m,account_tax_component c,account_tax_rate r WHERE m.id=l.move_id AND m.state='posted' AND m.date>=%s AND m.date<=%s AND c.id=l.tax_comp_id AND r.id=c.tax_rate_id AND m.company_id IN %s GROUP BY comp_id,comp_name,comp_rate,rate_name ORDER BY rate_name,comp_name", date_from, date_to, tuple(company_ids)) data["rate_taxes"] = [dict(r) for r in res] return data
def post(self): print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>") print(self.request.body) f = open("paypal_return", "a") s = "################################################################################################################" + \ "\n" s += "Date : " + time.strftime("%Y-%m-%d %H:%M:%S") + "\n" s += "Request : " + str(self.request) + "\n" if self.request.body: s += "Body : " + str(self.request.body) + "\n" s += "################################################################################################################" + \ "\n" f.write(s) f.close() cart_id = int(self.get_argument("cart_id")) token = self.get_argument("token", None) payer_id = self.get_argument("PayerID", None) cart = get_model("ecom.cart").browse(cart_id) if not cart.is_paid: access.set_active_user(1) access.set_active_company(1) cart.import_paypal_payment(token, context={}) db = database.get_connection() db.commit() self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
def get(self): db = get_connection() try: ctx = self.context brand_id = self.get_argument("brand_id", None) if brand_id: brand_id = int(brand_id) else: brand_code = self.get_argument("brand_code", None) res = get_model("product.brand").search([["code", "=", brand_code]]) if not res: raise Exception("Product brand not found: '%s'" % brand_code) brand_id = res[0] res = get_model("product.brand").browse([brand_id]) if not res: raise Exception("Can't find product brand id: ", brand_id) brand = res[0] ctx["product_brand"] = brand ctx["parent_brand_list"] = list_brand_parent(brand, brand_list=[]) content = render("ecom_product_brand", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: self.redirect("/cms_page_not_found") import traceback traceback.print_exc() db.rollback()
def post(self): db=get_connection() try: ctx=self.context coupon_id=int(self.get_argument("coupon_id")) action=self.get_argument("action") try: if action=="use_coupon": coupon=get_model("sale.coupon").browse(coupon_id) coupon.use_coupon() db.commit() self.redirect("/ecom_coupon?coupon_id=%s"%coupon.id) except Exception as e: ctx["error_message"]=str(e) coupon=get_model("sale.coupon").browse(coupon_id) ctx["coupon"]=coupon content=render("ecom_coupon",ctx) ctx["content"]=content html=render("cms_layout",ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get(self): db = get_connection() if db: db.begin() ctx = { "dbname": get_active_db(), "locale": netforce.locale.get_active_locale(), "css_file": static.get_css_file(), "js_file": static.get_js_file(), } static.check_ui_params_db() html = netforce.template.render("action_local", {"context": ctx}) self.write(html) db = get_connection() if db: db.commit() # XXX
def get_amount(self, ids, context={}): all_vals = {} db = database.get_connection() for obj in self.browse(ids): q = "SELECT SUM(opp.amount) AS amount,SUM(opp.qty) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='won' AND opp.date_close>=%s AND opp.date_close<=%s" a = [obj.date_from, obj.date_to] if obj.user_id: q += " AND opp.user_id=%s" a.append(obj.user_id.id) if obj.prod_categ_id: q += " AND prod.categ_id=%s" a.append(obj.prod_categ_id.id) res_won = db.get(q, *a) q = "SELECT SUM(opp.amount*opp.probability/100) AS amount,SUM(opp.qty*opp.probability/100) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='open' AND opp.date_close>=%s AND opp.date_close<=%s" a = [obj.date_from, obj.date_to] if obj.user_id: q += " AND opp.user_id=%s" a.append(obj.user_id.id) if obj.prod_categ_id: q += " AND prod.categ_id=%s" a.append(obj.prod_categ_id.id) res_open = db.get(q, *a) vals = { "amount_actual": res_won.amount or 0, "amount_expected": res_open.amount or 0, "qty_actual": res_won.qty or 0, "qty_expected": res_open.qty or 0, } all_vals[obj.id] = vals return all_vals
def get(self): db = get_connection() try: keyword = self.get_argument("keyword") domain = [["or",["name","ilike",keyword],["description","ilike",keyword],["code","ilike",keyword]],["parent_id","=",None],["is_published","=",True]] result = get_model("product").search_browse(domain) #if not result: #raise Exception("Product not found") products = [] for product in result: vals = { "name": product.name, "id": product.id, "desc": product.description[:20]+"..." if product.description else "" } products.append(vals) products = sorted(products, key=lambda k: k['name']) print(products) data = json.dumps(products) self.write(data) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get_attend_hist(self, context={}): db = database.get_connection() date_from = datetime.date.today() - datetime.timedelta(days=30) res = db.query( "SELECT user_id,action,time FROM hr_attendance WHERE time>=%s ORDER BY time", date_from) days = {} sign_ins = {} for r in res: if r.action == "sign_in": sign_ins[r.user_id] = r.time elif r.action == "sign_out": last_in = sign_ins.get(r.user_id) if not last_in: continue day = r.time[:10] if last_in[:10] != day: continue t = days.get(day, 0) t += (datetime.datetime.strptime(r.time, "%Y-%m-%d %H:%M:%S") - datetime.datetime.strptime( last_in, "%Y-%m-%d %H:%M:%S")).seconds / 3600.0 days[day] = t vals = sorted(days.items()) return { "value": vals, }
def get(self): db = get_connection() try: cart_id = int(self.get_argument("cart_id")) print("cart_id", cart_id) cart = get_model("ecom.cart").browse(cart_id) set_active_company(1) user_id = get_active_user() website = self.context["website"] ctx = self.context ctx["cart"] = cart if not cart.is_paid and website.payment_slip_template_id and ( cart.pay_method_id.id == website.bank_method_id.id): tmpl_name = website.payment_slip_template_id.name url = "/report?type=report_jasper&model=ecom.cart&convert=pdf&ids=[%d]&template=%s" % ( cart.id, tmpl_name) ctx["payment_slip_report_url"] = url content = render("ecom_order_confirmed", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def send_notifs(): print("send_notifs", os.getpid(), list(listen_handlers.keys())) t = time.strftime("%Y-%m-%d %H:%M:%S") db_handlers = {} for listener_id, h in listen_handlers.items(): # XXX db_handlers.setdefault(h.dbname, []).append(listener_id) for dbname, listener_ids in db_handlers.items(): set_active_db(dbname) db = get_connection() ids_sql = "(" + ",".join(str(x) for x in listener_ids) + ")" res = db.query( "SELECT listener_id,name FROM ws_event WHERE listener_id IN " + ids_sql) if res: for r in res: print("NOTIFY %s %s %s" % (dbname, r.listener_id, r.name)) handler = listen_handlers[r.listener_id] handler.write_message("NOTIFY %s" % r.name) db.execute("DELETE FROM ws_event WHERE listener_id IN " + ids_sql) db.execute("UPDATE ws_listener SET last_check_time=%s WHERE id IN " + ids_sql, t) # XXX: do this less often db.execute( "DELETE FROM ws_listener WHERE last_check_time<TIMESTAMP %s-INTERVAL '10 seconds'", t) # XXX: do this less often, FIXME db.commit() io_loop = tornado.ioloop.IOLoop.instance() io_loop.add_timeout(time.time() + POLL_WAIT, send_notifs)
def open(self): print("Listen.open", os.getpid()) global sending_notifs t = time.strftime("%Y-%m-%d %H:%M:%S") dbname = config.get("database") if not dbname: dbname = self.get_cookie("dbname", None) if not dbname: raise Exception("Can't open websocket, missing dbname") set_active_db(dbname) db = get_connection() user_id = self.get_cookie("user_id", None) if user_id: user_id = int(user_id) res = db.get( "INSERT INTO ws_listener (user_id,last_check_time) VALUES (%s,%s) RETURNING id", user_id, t) self.listener_id = res.id self.dbname = dbname listen_handlers[self.listener_id] = self if not sending_notifs: io_loop = tornado.ioloop.IOLoop.instance() io_loop.add_timeout( time.time() + POLL_WAIT, send_notifs ) # XXX: should start this directly when process is started? sending_notifs = True db.commit()
def get(self): db = get_connection() try: ctx = self.context categ_id=self.get_argument("categ_id",None) if categ_id: categ_id = int(categ_id) else: categ_code=self.get_argument("categ_code",None) res=get_model("product.categ").search([["code","=",categ_code]]) if not res: raise Exception("Product categ not found: '%s'"%categ_code) categ_id=res[0] res = get_model("product.categ").browse([categ_id]) if not res: raise Exception("Can't find product category id: ",categ_id) categ = res[0] ctx["product_categ"] = categ ctx["parent_categ_list"] = list_categ_parent(categ, categ_list=[]) content = render("ecom_product_categ", ctx) ctx["content"] = content html = render("cms_layout", ctx) self.write(html) db.commit() except: self.redirect("/cms_page_not_found") import traceback traceback.print_exc() db.rollback()
def post(self): db = database.get_connection() data = {} try: data["barcode"] = self.get_argument("barcode", None) data["qty"] = self.get_argument("qty", None) barcode = data["barcode"] if not barcode: raise Exception("Missing barcode!") barcode = int(barcode) qty = data["qty"] if not qty: raise Exception("Missing qty!") qty = int(qty) res = get_model("production.component").search([["id", "=", barcode]]) if not res: raise Exception("Invalid barcode") comp_id = res[0] # TODO: create goods issue for that component db.commit() self.redirect("/issue_rm") except Exception as e: data["error"] = "ERROR: %s" % e html = template.render("issue_rm", data) self.write(html) db.rollback() import traceback traceback.print_exc()
def get_balance(self, ids, context={}): print("account.track.categ get_balance") db = database.get_connection() child_ids = self.search([["id", "child_of", ids]]) print("child_ids", child_ids) res = db.query( "SELECT track_id,SUM(amount) AS total FROM account_track_entry WHERE track_id IN %s GROUP BY track_id", tuple(child_ids)) totals = {} for r in res: totals[r.track_id] = r.total res = db.query( "SELECT id,parent_id FROM account_track_categ WHERE id IN %s", tuple(child_ids)) sub_ids = {} for r in res: sub_ids.setdefault(r.parent_id, []) sub_ids[r.parent_id].append(r.id) def _get_total(track_id): amt = totals.get(track_id, 0) for child_id in sub_ids.get(track_id, []): amt += _get_total(child_id) return amt vals = {} for obj in self.browse(ids): vals[obj.id] = _get_total(obj.id) return vals
def post(self): db = get_connection() try: data_json = self.get_argument("json_str",None) if not data_json: raise Exception("Can't get json_str") data = json.loads(data_json) cart_id = self.get_cookie("cart_id",None) if not cart_id: raise Exception("Can't get cart id") cart_id = int(cart_id) cart = get_model("ecom.cart").browse(cart_id) order = 0 for line in cart.lines: for item in data: if item.get('order') == order: line.write({"ship_method_id": item.get('method_id')}) order += 1 cart.calc_shipping() amount_ship = "{:0,.2f}".format(float(cart.amount_ship)) amount_total = "{:0,.2f}".format(float(cart.amount_total)) total = { "amount_ship": amount_ship, "amount_total": amount_total, } data = json.dumps(total) self.write(data) db.commit() except: import traceback traceback.print_exc() db.rollback()
def get(self): db=get_connection() try: ctx=self.context page_code=self.get_argument("page") res=get_model("cms.page").search([["code","=",page_code]]) if not res: self.redirect("/cms_page_not_found") return page_id=res[0] page=get_model("cms.page").browse(page_id) if page.state=="inactive": self.redirect("/cms_page_not_found") return ctx["page"]=page tmpl_name=page.template or "cms_page" content=render(tmpl_name,ctx) ctx["content"]=content html=render("cms_layout",ctx) self.write(html) db.commit() except: import traceback traceback.print_exc() db.rollback()
def approve(self, ids, context={}): print("ApproveWizard.approve", ids) obj = self.browse(ids)[0] pin_code = obj.pin_code obj.write({"pin_code": ""}) # XXX m = get_model(obj.approve_model) f = getattr(m, obj.approve_method, None) if not f: raise Exception("Invalid method %s of %s" % (obj.approve_method, obj.approve_model)) if not obj.approver_id: res = f([obj.approve_id], context=context) else: db = database.get_connection() res = db.get("SELECT pin_code FROM base_user WHERE id=%s", obj.approver_id.id) enc_pin_code = res.pin_code if not utils.check_password(pin_code, enc_pin_code): raise Exception("Wrong PIN") user_id = get_active_user() set_active_user(obj.approver_id.id) try: res = f([obj.approve_id], context=context) finally: set_active_user(user_id) return res
def compute_balance(self, ids, product_id, date=None, lot_id=None, container_id=None, uom_id=None): print("compute_balance", ids, product_id, date) prod = get_model("product").browse(product_id) if not uom_id: uom_id = prod.uom_id.id db = database.get_connection() q = "SELECT uom_id,SUM(qty) AS total_qty,SUM(cost_amount) AS total_amount,SUM(qty2) AS total_qty2 FROM stock_move WHERE location_to_id IN %s AND product_id=%s AND state='done'" args = [tuple(ids), product_id] if date: q += " AND date<=%s" args.append(date) if lot_id: q += " AND lot_id=%s" args.append(lot_id) if container_id: q += " AND container_to_id=%s" args.append(container_id) q += " GROUP BY uom_id" res = db.query(q, *args) in_qty = 0 in_amount = 0 in_qty2 = 0 for r in res: qty = get_model("uom").convert(r.total_qty, r.uom_id, uom_id) in_qty += qty in_amount += r.total_amount or 0 in_qty2 += r.total_qty2 or 0 q = "SELECT uom_id,SUM(qty) AS total_qty,SUM(cost_amount) AS total_amount,SUM(qty2) AS total_qty2 FROM stock_move WHERE location_from_id IN %s AND product_id=%s AND state='done'" args = [tuple(ids), product_id] if date: q += " AND date<=%s" args.append(date) if lot_id: q += " AND lot_id=%s" args.append(lot_id) if container_id: q += " AND container_from_id=%s" args.append(container_id) q += " GROUP BY uom_id" res = db.query(q, *args) out_qty = 0 out_amount = 0 out_qty2 = 0 for r in res: qty = get_model("uom").convert(r.total_qty, r.uom_id, uom_id) out_qty += qty out_amount += r.total_amount or 0 out_qty2 += r.total_qty2 or 0 return { "bal_qty": in_qty - out_qty, "bal_amount": in_amount - out_amount, "bal_qty2": in_qty2 - out_qty2, }
def get_permissions(model): uid = get_active_user() if uid == 1: return { "read": True, "create": True, "write": True, "delete": True, "view_all": True, "modif_all": True, } db = database.get_connection() if uid: res = db.get("SELECT profile_id FROM base_user WHERE id=%s", uid) profile_id = res.profile_id if res else None else: res = db.get("SELECT anon_profile_id FROM settings WHERE id=1") profile_id = res.anon_profile_id if res else None if not profile_id: return { "read": False, "create": False, "write": False, "delete": False, "view_all": False, "modif_all": False, } res = db.get( "SELECT a.* FROM profile_access a JOIN model m ON m.id=a.model_id WHERE a.profile_id=%s AND m.name=%s", profile_id, model) if res: perms = { "read": res.perm_read, "create": res.perm_create, "write": res.perm_write, "delete": res.perm_delete, "view_all": res.view_all, "modif_all": res.modif_all, } else: res = db.get("SELECT default_model_perms FROM profile WHERE id=%s", profile_id) if res.default_model_perms == "full": perms = { "read": True, "create": True, "write": True, "delete": True, "view_all": False, "modif_all": False, } else: perms = { "read": False, "create": False, "write": False, "delete": False, "view_all": False, "modif_all": False, } return perms
def get_online_status(self, ids, context={}): vals = {} db = database.get_connection() res = db.query("SELECT user_id FROM ws_listener") online_ids = set([r.user_id for r in res]) for obj in self.browse(ids): vals[obj.id] = obj.id in online_ids and "online" or "offline" return vals
def get_unrec_num(self, ids, context={}): db = database.get_connection() res = db.query( "SELECT st.account_id,count(*) FROM account_statement_line stl JOIN account_statement st ON st.id=stl.statement_id WHERE stl.state='not_reconciled' AND st.account_id IN %s GROUP BY st.account_id", tuple(ids)) vals = {} for r in res: vals[r.account_id] = r.count return vals