def create(self, vals, **kw): uid = access.get_active_user() try: access.set_active_user(1) return super().create(vals, **kw) finally: access.set_active_user(uid)
def default_get(self, field_names=None, context=None, **kw): user_id = get_active_user() set_active_user(1) user = get_model("base.user").browse(user_id) vals = {"name": user.name, "password": user.password, "email": user.email, "mobile": user.mobile} set_active_user(user_id) return vals
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 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 send_email(self, ids, context={}): uid = access.get_active_user() try: access.set_active_user(1) obj = self.browse(ids[0]) # XXX "=" should be changed to "=ilike" later res = get_model("base.user").search((["email", "=ilike", obj.email.strip()])) if not res: raise Exception("User with given email doesn't exist in database") request = context["request"] msg = "Somebody requested change of your Netforce password.\n\n" msg += "If you didn't do it, please ignore this message.\n\n" msg += "Otherwise if you want to reset your password click on the link below:\n\n" msg += "http://%s/ui#name=change_passwd&key=%s\n\n\n" % (request.host, obj.key) msg += "Regards,\n" msg += "Netforce Team" vals = { "type": "out", "from_addr": "*****@*****.**", "to_addrs": obj.email, "subject": "Netforce reset password request", "body": msg, "state": "to_send", } get_model("email.message").create(vals) return { "next": { "name": "forgot_passwd_done" } } finally: access.set_active_user(uid)
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): 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 remove_expired_lots(self, context={}): print("StockLot.remove_expired_lots") access.set_active_user(1) access.set_active_company(1) settings = get_model("settings").browse(1) if not settings.lot_expiry_journal_id: raise Exception("Missing lot expiry journal") journal = settings.lot_expiry_journal_id if not journal.location_to_id: raise Exception("Missing to location in lot expiry journal") t = time.strftime("%Y-%m-%d") pick_vals = {"type": "out", "journal_id": journal.id, "lines": []} n = 0 for obj in self.search_browse([["expiry_date", "<", t]]): prod = obj.product_id if not prod: continue for bal in obj.stock_balances: if bal.qty_phys <= 0: continue line_vals = { "product_id": prod.id, "location_from_id": bal.location_id.id, "location_to_id": journal.location_to_id.id, "lot_id": obj.id, "qty": bal.qty_phys, "uom_id": prod.uom_id.id, } pick_vals["lines"].append(("create", line_vals)) n += 1 if pick_vals["lines"]: pick_id = get_model("stock.picking").create(pick_vals, context={"pick_type": "out"}) get_model("stock.picking").set_done([pick_id]) get_model("stock.picking").trigger([pick_id], "lot_expired") return {"flash": "%d lots removed from stock" % n}
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 send_email(self, ids, context={}): uid = access.get_active_user() try: access.set_active_user(1) obj = self.browse(ids[0]) # XXX "=" should be changed to "=ilike" later res = get_model("base.user").search( (["email", "=ilike", obj.email.strip()])) if not res: raise Exception( "User with given email doesn't exist in database") request = context["request"] msg = "Somebody requested change of your Netforce password.\n\n" msg += "If you didn't do it, please ignore this message.\n\n" msg += "Otherwise if you want to reset your password click on the link below:\n\n" msg += "http://%s/ui#name=change_passwd&key=%s\n\n\n" % ( request.host, obj.key) msg += "Regards,\n" msg += "Netforce Team" vals = { "type": "out", "from_addr": "*****@*****.**", "to_addrs": obj.email, "subject": "Netforce reset password request", "body": msg, "state": "to_send", } get_model("email.message").create(vals) return {"next": {"name": "forgot_passwd_done"}} finally: access.set_active_user(uid)
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 post(self): #try: with database.Transaction(): #db = get_connection() print("########################################") print("#######Result Payment Online SCB########") print("############# POST ##############") print("########################################") f = open("scblog", "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() if self.request.arguments: website = get_model("website").browse(1) if not website.scb_mid: raise Exception("no merchant id in website settings") if not website.scb_terminal: raise Exception("no terminal id in website settings") if not website.scb_url: raise Exception("no URL server in website settings") mid = self.get_argument("mid", None) print(mid) if mid != website.scb_mid: raise Exception("Merchant id does not match") terminal = self.get_argument("terminal", None) print(terminal) if terminal != website.scb_terminal: raise Exception("Terminal id does not match") command = self.get_argument("command", None) print(command) if command != 'CRAUTH': raise Exception("Command does not match") payment_status = self.get_argument("payment_status", None) print(payment_status) if payment_status == '003': raise Exception("Payment host reject") if payment_status == '006': raise Exception("Payment error") ref_no = self.get_argument("ref_no", None) print(ref_no) if payment_status == '002': set_active_user(1) set_active_company(1) res = get_model("sale.order").search_browse( [["number", "=", ref_no]]) if res: # XXX Inquiry double check sale = res[0] if not sale.is_paid: sale.import_scb_payment()
def post(self): #try: with database.Transaction(): #db = get_connection() print("########################################") print("#######Result Payment Online SCB########") print("############# POST ##############") print("########################################") f = open("scblog", "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() if self.request.arguments: website = get_model("website").browse(1) if not website.scb_mid: raise Exception("no merchant id in website settings") if not website.scb_terminal: raise Exception("no terminal id in website settings") if not website.scb_url: raise Exception("no URL server in website settings") mid = self.get_argument("mid", None) print(mid) if mid != website.scb_mid: raise Exception("Merchant id does not match") terminal = self.get_argument("terminal", None) print(terminal) if terminal != website.scb_terminal: raise Exception("Terminal id does not match") command = self.get_argument("command", None) print(command) if command != 'CRAUTH': raise Exception("Command does not match") payment_status = self.get_argument("payment_status", None) print(payment_status) if payment_status == '003': raise Exception("Payment host reject") if payment_status == '006': raise Exception("Payment error") ref_no = self.get_argument("ref_no", None) print(ref_no) if payment_status == '002': set_active_user(1) set_active_company(1) res = get_model("sale.order").search_browse([["number", "=", ref_no]]) if res: # XXX Inquiry double check sale = res[0] if not sale.is_paid: sale.import_scb_payment()
def delete(self, ids, **kw): prod_ids = [] for obj in self.browse(ids): prod_ids.append(obj.product_id.id) super().delete(ids, **kw) user_id = get_active_user() set_active_user(1) get_model("product").write(prod_ids, {"update_balance": True}) set_active_user(user_id)
def migrate(self): user_id = get_active_user() set_active_user(1) for payslip in get_model("hr.payslip").search_browse([]): if not payslip.state: payslip.write({"state": "draft"}) for payrun in get_model("hr.payrun").search_browse([]): if not payrun.state: payrun.write({"state": "draft"}) set_active_user(user_id)
def auto_create_purchase_orders(self,context={}): access.set_active_user(1) access.set_active_company(1) # XXX vals={ "confirm_orders": True, } obj_id=self.create(vals) self.delete_planned_orders([obj_id]) self.fill_products([obj_id]) self.create_po([obj_id])
def auto_create_production_orders(self, context={}): access.set_active_user(1) access.set_active_company(1) # XXX vals = { "confirm_orders": True, } obj_id = self.create(vals) self.delete_planned_orders([obj_id]) self.fill_products([obj_id]) self.create_mo([obj_id])
def save_changes(self, ids, context={}): obj = self.browse(ids)[0] check_password(obj.password) vals = {"name": obj.name, "password": obj.password, "email": obj.email, "mobile": obj.mobile} user_id = get_active_user() set_active_user(1) get_model("base.user").write([user_id], vals) obj.write({"password": ""}) set_active_user(user_id) return {"next": "_close"}
def migrate(self): set_active_user(1) for user in get_model("base.user").search_browse([]): res=get_model("limit.inspect").search([['user_id','=',user.id]]) if not res: insp_ids=get_model("inspection").search([['user_id','=',user.id]]) get_model("limit.inspect").create({ 'user_id': user.id, 'record_count': len(insp_ids), })
def migrate(self): user_id=get_active_user() set_active_user(1) for leave in get_model("hr.leave").search_browse([]): if leave.time_from and leave.time_to: leave.write({ 'start_date': '%s %s:00'%(leave.start_date[0:10],leave.time_from.replace(".",":")), 'end_date': '%s %s:00'%(leave.end_date[0:10],leave.time_to.replace(".",":")), }) set_active_user(user_id)
def run_job(dbname, job): print("run_job dbname=%s pid=%s job='%s'" % (dbname, os.getpid(), job["name"])) database.connections.clear() set_active_user(1) database.set_active_db(dbname) db = database.get_connection() db.begin() clear_cache() m = get_model(job["model"]) f = getattr(m, job["method"]) if job["args"]: args = json.loads(job["args"]) else: args = [] db.execute("UPDATE cron_job SET state='running' WHERE id=%s", job["id"]) db.commit() print("starting job '%s'" % job["name"]) try: with utils.timeout(seconds=job["timeout"]): f(*args) db.commit() print("job '%s' success" % job["name"]) except Exception as e: print("WARNING: job '%s' failed: %s" % (job["name"], e)) db.rollback() t = time.strftime("%Y-%m-%d %H:%M:%S") msg = traceback.format_exc() db.execute( "UPDATE cron_job SET last_error_time=%s,error_message=%s WHERE id=%s", t, msg, job["id"]) db.commit() t1 = time.strftime("%Y-%m-%s %H:%M:%S") if job["interval_num"]: if job["interval_type"] == "second": dt = timedelta(seconds=job["interval_num"]) elif job["interval_type"] == "minute": dt = timedelta(minutes=job["interval_num"]) elif job["interval_type"] == "hour": dt = timedelta(hours=job["interval_num"]) elif job["interval_type"] == "day": dt = timedelta(days=job["interval_num"]) else: raise Exception("Missing interval unit") next_date = datetime.strptime(job["date"], "%Y-%m-%d %H:%M:%S") now = datetime.now() while next_date <= now: # TODO: make this faster next_date += dt if next_date < _check_times[dbname]: _check_times[dbname] = next_date db.execute("UPDATE cron_job SET date=%s,state='waiting' WHERE id=%s", next_date.strftime("%Y-%m-%d %H:%M:%S"), job["id"]) else: db.execute("UPDATE cron_job SET state='done' WHERE id=%s", job["id"]) db.commit()
def run_tests(): print("running tests...") access.set_active_user(1) suites = [] for test in test_cases: loader = unittest.TestLoader() suite = loader.loadTestsFromTestCase(test) suites.append(suite) suite_all = unittest.TestSuite(suites) runner = unittest.TextTestRunner(verbosity=2) res = runner.run(suite_all)
def default_get(self, field_names=None, context=None, **kw): user_id = get_active_user() set_active_user(1) user = get_model("base.user").browse(user_id) vals = { "name": user.name, "password": user.password, "email": user.email, "mobile": user.mobile, } set_active_user(user_id) return vals
def _get_number(self, context={}): while 1: num = get_model("sequence").get_number(type="job") if not num: return None user_id = get_active_user() set_active_user(1) res = self.search([["number", "=", num]]) set_active_user(user_id) if not res: return num get_model("sequence").increment(type="job")
def run_job(dbname, job): print("run_job dbname=%s pid=%s job='%s'"%(dbname, os.getpid(), job["name"])) database.connections.clear() set_active_user(1) database.set_active_db(dbname) db = database.get_connection() db.begin() clear_cache() m = get_model(job["model"]) f = getattr(m, job["method"]) if job["args"]: args = json.loads(job["args"]) else: args = [] db.execute("UPDATE cron_job SET state='running' WHERE id=%s", job["id"]) db.commit() print("starting job '%s'"%job["name"]) try: with utils.timeout(seconds=job["timeout"]): f(*args) db.commit() print("job '%s' success" % job["name"]) except Exception as e: print("WARNING: job '%s' failed: %s"%(job["name"],e)) db.rollback() t=time.strftime("%Y-%m-%d %H:%M:%S") msg=traceback.format_exc() db.execute("UPDATE cron_job SET last_error_time=%s,error_message=%s WHERE id=%s", t, msg, job["id"]) db.commit() t1 = time.strftime("%Y-%m-%s %H:%M:%S") if job["interval_num"]: if job["interval_type"] == "second": dt = timedelta(seconds=job["interval_num"]) elif job["interval_type"] == "minute": dt = timedelta(minutes=job["interval_num"]) elif job["interval_type"] == "hour": dt = timedelta(hours=job["interval_num"]) elif job["interval_type"] == "day": dt = timedelta(days=job["interval_num"]) else: raise Exception("Missing interval unit") next_date = datetime.strptime(job["date"], "%Y-%m-%d %H:%M:%S") now = datetime.now() while next_date <= now: # TODO: make this faster next_date += dt if next_date < _check_times[dbname]: _check_times[dbname] = next_date db.execute("UPDATE cron_job SET date=%s,state='waiting' WHERE id=%s", next_date.strftime("%Y-%m-%d %H:%M:%S"), job["id"]) else: db.execute("UPDATE cron_job SET state='done' WHERE id=%s", job["id"]) db.commit()
def write(self, ids, vals, context={}): prod_ids = [] for obj in self.browse(ids): prod_ids.append(obj.product_id.id) super().write(ids, vals, context=context) prod_id = vals.get("product_id") if prod_id: prod_ids.append(prod_id) self.function_store(ids) user_id = get_active_user() set_active_user(1) get_model("product").write(prod_ids, {"update_balance": True}) set_active_user(user_id)
def _get_number(self, context={}): seq_id = get_model("sequence").find_sequence(type="purchase_order") if not seq_id: return None while 1: num = get_model("sequence").get_next_number(seq_id) user_id = get_active_user() set_active_user(1) res = self.search([["number", "=", num]]) set_active_user(user_id) if not res: return num get_model("sequence").increment_number(seq_id)
def _get_number(self, context={}): seq_id = get_model("sequence").find_sequence(type="purchase_return") if not seq_id: return None while 1: num = get_model("sequence").get_next_number(seq_id) user_id = get_active_user() set_active_user(1) res = self.search([["number", "=", num]]) set_active_user(user_id) if not res: return num get_model("sequence").increment_number(seq_id)
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 migrate(self): user_id = get_active_user() set_active_user(1) for payslip in get_model("hr.payslip").search_browse([]): if not payslip.state: payslip.write({ 'state': 'draft', }) for payrun in get_model("hr.payrun").search_browse([]): if not payrun.state: payrun.write({ 'state': 'draft', }) set_active_user(user_id)
def apply_migrations(from_version): to_version = get_db_version() print("Applying migrations from version %s to %s..." % (from_version, to_version)) for mig_cls in sorted(_migrations, key=lambda m: (m._version, m._name)): if compare_version(mig_cls._version, from_version) <= 0: continue if mig_cls._max_version and compare_version(to_version, mig_cls._max_version) > 0: raise Exception( "Can not apply migration '%s', maximum version that can apply this migration is %s" % (mig._name, mig._max_version)) mig = mig_cls() print("Applying migration %s..." % mig._name) set_active_user(1) set_active_company(None) mig.migrate()
def migrate(self): user_id = get_active_user() set_active_user(1) for leave in get_model("hr.leave").search_browse([]): if leave.time_from and leave.time_to: leave.write({ 'start_date': '%s %s:00' % (leave.start_date[0:10], leave.time_from.replace(".", ":")), 'end_date': '%s %s:00' % (leave.end_date[0:10], leave.time_to.replace(".", ":")), }) set_active_user(user_id)
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 create(self, vals, context={}): pick_id = vals.get("picking_id") if pick_id: pick = get_model("stock.picking").browse(pick_id) vals["date"] = pick.date vals["picking_id"] = pick.id vals["journal_id"] = pick.journal_id.id new_id = super().create(vals, context=context) self.function_store([new_id]) prod_id = vals["product_id"] user_id = get_active_user() set_active_user(1) get_model("product").write([prod_id], {"update_balance": True}) set_active_user(user_id) return new_id
def _get_number(self, context={}): seq_id = get_model("sequence").find_sequence(type="ecom_cart") if not seq_id: return None while 1: num = get_model("sequence").get_next_number(seq_id, context=context) if not num: return None user_id = access.get_active_user() access.set_active_user(1) res = self.search([["number", "=", num]]) access.set_active_user(user_id) if not res: return num get_model("sequence").increment_number(seq_id, context=context)
def get(self): db=get_connection() try: set_active_user(1) action=self.get_argument("action") res=get_model("inline.help").search([["action","=",action]]) if not res: raise Exception("Inline help not found for action '%s'"%action) page_id=res[0] page=get_model("inline.help").browse(page_id) self.write(page.content) db.commit() except: import traceback traceback.print_exc() db.rollback()
def post(self): try: print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>") print(self.request.body) f = open("paysbuy_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")) result = self.get_argument("result", None) method = self.get_argument("method", None) cart = get_model("ecom.cart").browse(cart_id) if method: access.set_active_user(1) access.set_active_company(1) cart.update_paysbuy_method(method) db = database.get_connection() db.commit() if result.startswith("00"): # received payment already if not cart.is_paid: access.set_active_user(1) access.set_active_company(1) cart.import_paysbuy_payment() db = database.get_connection() db.commit() self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id) elif result.startswith("02"): # will receive payment later self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id) else: cart.cancel_order() db = database.get_connection() db.commit() #self.set_cookie("cart_id", str(cart_id)) self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id) except Exception as e: db = database.get_connection() db.rollback import traceback traceback.print_exc()
def gen_tax_no(self, context={}): seq_id = get_model("sequence").find_sequence(type="wht_no", context=context) if not seq_id: return None while 1: num = get_model("sequence").get_next_number(seq_id, context=context) if not num: return None user_id = get_active_user() set_active_user(1) res = self.search([["tax_invoice", "=", num]]) set_active_user(user_id) if not res: return num get_model("sequence").increment_number(seq_id, context=context)
def onchange_sequence(self, context={}): data = context["data"] context['date'] = data['date'] seq_id = data["sequence_id"] if not seq_id: seq_id = get_model("sequence").find_sequence(type="purchase_order") while 1: num = get_model("sequence").get_next_number(seq_id, context=context) user_id = get_active_user() set_active_user(1) res = self.search([["number", "=", num]]) set_active_user(user_id) if not res: break get_model("sequence").increment_number(seq_id, context=context) data["number"] = num return data
def get(self): db = get_connection() try: set_active_user(1) action = self.get_argument("action") res = get_model("inline.help").search([["action", "=", action]]) if not res: raise Exception("Inline help not found for action '%s'" % action) page_id = res[0] page = get_model("inline.help").browse(page_id) self.write(page.content) db.commit() except: import traceback traceback.print_exc() db.rollback()
def save_changes(self, ids, context={}): obj = self.browse(ids)[0] check_password(obj.password) vals = { "name": obj.name, "password": obj.password, "email": obj.email, "mobile": obj.mobile, } user_id = get_active_user() set_active_user(1) get_model("base.user").write([user_id], vals) obj.write({"password": ""}) set_active_user(user_id) return { "next": "_close", }
def get_company_logo(self, context={}): dbname = database.get_active_db() if not dbname: return None user_id = get_active_user() try: set_active_user(1) res = get_model("company").search([["parent_id", "=", None]], order="id") if not res: return None company_id = res[0] set_active_company(company_id) settings = get_model("settings").browse(1) if not settings.logo: return None return "/static/db/%s/files/%s" % (dbname, settings.logo) finally: set_active_user(user_id)
def get_ui_params(self, context={}): user_id = access.get_active_user() if not user_id: return try: access.set_active_user(1) db = database.get_connection() if not db: return user = self.browse(user_id) params = { "name": user.name, } prof = user.profile_id params["default_model_perms"] = prof.default_model_perms params["model_perms"] = [] for p in prof.perms: params["model_perms"].append({ "model": p.model_id.name, "perm_read": p.perm_read, "perm_create": p.perm_create, "perm_write": p.perm_write, "perm_delete": p.perm_delete, }) params["field_perms"] = [] for p in prof.field_perms: params["field_perms"].append({ "model": p.field_id.model_id.name, "field": p.field_id.name, "perm_read": p.perm_read, "perm_write": p.perm_write, }) params["default_menu_access"] = prof.default_menu_access params["menu_perms"] = [] for p in prof.menu_perms: params["menu_perms"].append({ "action": p.action, "menu": p.menu, "access": p.access, }) params["other_perms"] = [p.code for p in prof.other_perms] return params finally: access.set_active_user(user_id)
def get(self): #url="https://v5.inspection.in.th/inspectionreport/checkqr?id=1541844&password=f45681f1" current_local=get_active_locale() set_active_user(1) #admin set_active_locale('th_TH') db=get_connection() # prevent to error get transaction try: db.begin() id=self.get_argument("id") if not id: self.write("Missing ID") return password=self.get_argument("password") if not password: self.write("Missing Password") return ctx={ 'obj': None, } #res=db.query("select * from inspection where number=%s and password=%s",id,password) dom=[ ['number','=', id], ['password','=', password] ] res=get_model("inspection").search_read(dom) if res: #t0=res[-1]['date'] #t1=t0.split(" ") #res[-1]['date']='%s %s'%(sale_utils.date2thai(t1[0], format='%(d)s %(Tm)s %(BY)s'), t1[1]) #res[-1]['date_register']=sale_utils.date2thai(res[-1]['date_register'], format='%(d)s %(Tm)s %(BY)s') ctx['obj']=res[-1] else: ctx['nothing']=True data=ctx['obj'] html=render("checkqr",context=ctx, data=data) self.write(html) except Exception as e: self.write("ERROR : %s"%str(e)) finally: if db: db.commit() set_active_locale(current_local)
def remove_expired_lots(self, context={}): print("StockLot.remove_expired_lots") access.set_active_user(1) access.set_active_company(1) settings = get_model("settings").browse(1) if not settings.lot_expiry_journal_id: raise Exception("Missing lot expiry journal") journal = settings.lot_expiry_journal_id if not journal.location_to_id: raise Exception("Missing to location in lot expiry journal") t = time.strftime("%Y-%m-%d") pick_vals = { "type": "out", "journal_id": journal.id, "lines": [], } n = 0 for obj in self.search_browse([["expiry_date", "<", t]]): prod = obj.product_id if not prod: continue for bal in obj.stock_balances: if bal.qty_phys <= 0: continue line_vals = { "product_id": prod.id, "location_from_id": bal.location_id.id, "location_to_id": journal.location_to_id.id, "lot_id": obj.id, "qty": bal.qty_phys, "uom_id": prod.uom_id.id, } pick_vals["lines"].append(("create", line_vals)) n += 1 if pick_vals["lines"]: pick_id = get_model("stock.picking").create( pick_vals, context={"pick_type": "out"}) get_model("stock.picking").set_done([pick_id]) get_model("stock.picking").trigger([pick_id], "lot_expired") return { "flash": "%d lots removed from stock" % n, }
def post(self): print("POST >>>>>>>>>>>>>>>>>>>") with database.Transaction(): cart_id = int(self.get_argument("cart_id")) cart = get_model("ecom.cart").browse(cart_id) website=cart.website_id base_url=(website.url or "").strip() if base_url.endswith("/"): base_url=base_url[:-1] response = self.get_argument("response") if response == "declined": cart.cancel_order() #self.set_cookie("cart_id", str(cart_id)) self.redirect(base_url+"/ecom_order_cancelled?cart_id=%s" % cart_id) return if not cart.is_paid: access.set_active_user(1) access.set_active_company(1) cart.import_scb_payment() self.redirect(base_url+"/ecom_order_confirmed?cart_id=%s" % cart_id)
def _get_number(self, context={}): pick_type = context.get("pick_type") journal_id = context.get("journal_id") seq_id = None if journal_id: journal = get_model("stock.journal").browse(journal_id) seq_id = journal.sequence_id.id if not seq_id and pick_type: seq_type = "pick_" + pick_type seq_id = get_model("sequence").find_sequence(seq_type) if not seq_id: return None while 1: num = get_model("sequence").get_next_number(seq_id) user_id = get_active_user() set_active_user(1) res = self.search([["number", "=", num]]) set_active_user(user_id) if not res: return num get_model("sequence").increment_number(seq_id)
def post(self): with database.Transaction(): print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>") print(self.request.body) f = open("paysbuy_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")) result = self.get_argument("result", None) method = self.get_argument("method", None) cart = get_model("ecom.cart").browse(cart_id) f = open("record_return", "a") x = "cart_id:" + str(cart_id) x += "\nrestut:" + result f.write(x) f.close() if method: access.set_active_user(1) access.set_active_company(1) cart.update_paysbuy_method(method) if result.startswith("00"): # received payment already if not cart.is_paid: access.set_active_user(1) access.set_active_company(1) cart.import_paysbuy_payment() self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id) elif result.startswith("02"): # will receive payment later self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id) else: cart.cancel_order() self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id) self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id)
def log(self, msg, details=None, ip_addr=None, related_id=None): uid = get_active_user() if not ip_addr: ip_addr = get_ip_addr() try: country_code = get_ip_country(ip_addr) res = get_model("country").search([["code", "=", country_code]]) country_id = res[0] except Exception as e: #print("Failed to get IP country: %s"%e) country_id = None vals = { "user_id": uid, "ip_addr": ip_addr, "message": msg, "details": details, "country_id": country_id, "related_id": related_id, } set_active_user(1) self.create(vals) set_active_user(uid)