def ensure_db():
db = request.params.get('db') and request.params.get('db').strip()
# Ensure db is legit
if db and db not in http.db_filter([db]):
db = None
if db and not request.session.db:
# User asked a specific database on a new session.
request.session.db = db
return
# if db not provided, use the session one
if not db and request.session.db and http.db_filter([request.session.db]):
db = request.session.db
# if no database provided and no database in session, use monodb
if not db:
db = http.db_monodb(request.httprequest)
# always switch the session to the computed db
if db != request.session.db:
request.session.logout()
request.session.db = db
def _get_company_image_response(self,
dbname,
field,
placeholders,
default_mimetype,
company=None):
uid = request.session.uid if request.session.db else None
placeholder = self._get_company_image_placeholder()
if request.session.db:
dbname = request.session.db
elif dbname is None:
dbname = http.db_monodb()
if not dbname:
response = http.send_file(placeholder(placeholders[0]))
else:
uid = uid if uid else SUPERUSER_ID
company_data = self._get_company_image_data(
dbname, uid, field, company)
if company_data and company_data[0]:
image_data = base64.b64decode(company_data[0])
mimetype = guess_mimetype(image_data, default=default_mimetype)
extension = mimetypes.guess_extension(mimetype)
response = http.send_file(io.BytesIO(image_data),
filename=('logo%s' % extension),
mimetype=mimetype,
mtime=company_data[1])
else:
response = http.send_file(placeholder(placeholders[1]))
return response
def _render_template(self, **d):
d.setdefault('manage', True)
d['insecure'] = tools.config.verify_admin_password('admin')
d['list_db'] = tools.config['list_db']
d['langs'] = service.db.exp_list_lang()
d['countries'] = service.db.exp_list_countries()
d['pattern'] = DBNAME_PATTERN
d['system_name'] = tools.config.get("database_manager_system_name",
"Odoo")
d['system_logo'] = tools.config.get("database_manager_system_logo_url",
"/web/static/src/img/logo2.png")
d['system_favicon'] = tools.config.get(
"database_manager_system_favicon_url",
"/web/static/src/img/favicon.ico")
d['privacy_policy'] = tools.config.get(
"database_manager_privacy_policy_url",
"https://www.odoo.com/privacy")
d['databases'] = []
try:
d['databases'] = db_list()
d['incompatible_databases'] = service.db.list_db_incompatible(
d['databases'])
except exceptions.AccessDenied:
monodb = db_monodb()
if monodb:
d['databases'] = [monodb]
return env.get_template("database_manager.html").render(d)
def _render_template(self, **d):
res = super(BackupDatabase, self)._render_template(**d)
# Show button 'Restore via Odoo-backup.sh' on web/database/manager and web/database/selector pages
place_for_backup_button = re.search(
'Set Master Password</button>.*\n.*</div>', res)
if place_for_backup_button:
place_for_backup_button = place_for_backup_button.end()
else:
place_for_backup_button = re.search(
'<a role="button" data-toggle="modal" data-target=".o_database_restore" class="btn btn-link">',
res)
if place_for_backup_button:
place_for_backup_button = place_for_backup_button.start()
if place_for_backup_button:
d['list_db'] = config['list_db']
d['databases'] = []
try:
d['databases'] = http.db_list()
except odoo.exceptions.AccessDenied:
monodb = http.db_monodb()
if monodb:
d['databases'] = [monodb]
backup_button = env.get_template("backup_button.html").render(d)
res = res[:place_for_backup_button] + backup_button + res[
place_for_backup_button:]
return res
def database_list(self, **kw):
databases = []
incompatible_databases = []
try:
databases = http.db_list()
incompatible_databases = service.db.list_db_incompatible(databases)
except AccessDenied:
monodb = http.db_monodb()
if monodb:
databases = [monodb]
result = {'databases': databases, 'incompatible_databases': incompatible_databases}
content = json.dumps(result, sort_keys=True, indent=4, cls=ResponseEncoder)
return Response(content, content_type='application/json;charset=utf-8', status=200)
def authenticate(self):
params = request.params
db_name = params.get("db", db_monodb())
request.session.authenticate(db_name, params["login"], params["password"])
result = request.env["ir.http"].session_info()
# avoid to rotate the session outside of the scope of this method
# to ensure that the session ID does not change after this method
_rotate_session(request)
request.session.rotate = False
expiration = datetime.datetime.utcnow() + datetime.timedelta(days=90)
result["session"] = {
"sid": request.session.sid,
"expires_at": fields.Datetime.to_string(expiration),
}
return result
def wrapper(*args, **kwargs):
params = http.request.params
session = http.request.session
database = params.get('db') and params.get('db').strip()
if database and database not in http.db_filter([database]):
database = None
if not database and session.db and http.db_filter([session.db]):
database = session.db
if not database:
database = http.db_monodb(http.request.httprequest)
if not database:
return exceptions.common.NoDatabaseFound()
if database != session.db:
session.logout()
session.db = database
return func(*args, **kwargs)
def authentication(self, payload):
params = request.params
db_name = params.get("db", db_monodb())
request.session.authenticate(db_name, params["agentid"],
params["password"])
result = request.env["ir.http"].session_info()
_rotate_session(request)
request.session.rotate = False
expiration = datetime.datetime.utcnow() + datetime.timedelta(days=7)
return self.env.datamodels["saleforce.login.datamodel.out"](
session_id=request.session.sid,
expires_at=fields.Datetime.to_string(expiration),
uid=result.get("uid"),
agentid=result.get("username"),
name=result.get("name"),
partner_id=result.get("partner_id"),
)
def backup(self):
db_name = http.db_monodb()
Config = self.env['ir.config_parameter'].sudo()
local_backup = Config.get_param('abackup_local_backup')
backup_path = Config.get_param('abackup_local_path')
gdrive_backup = Config.get_param('abackup_gdrive_backup')
backup = None
try:
ts = datetime.utcnow().strftime(self.TIME_FORMAT)
filename = "%s_%s_%s.%s" % (self.PREFIX, db_name, ts, 'dump')
file_path = None
drive_id = None
dump_stream = odoo.service.db.dump_db(db_name, None, 'dump').read()
if local_backup:
file_path = backup_path + filename
with open(file_path, 'wb') as f:
f.write(dump_stream)
if gdrive_backup:
Drive = self.env['odoo_addon_auto_backup.google_drive']
drive_id = Drive.upload_resumable(dump_stream, filename)
# drive_id = Drive.upload(dump_stream, filename)
# Create a new backup record
backup = self.env['odoo_addon_auto_backup.backup'].create({
'created_time':
datetime.now(),
'file_name':
filename,
'local_path':
file_path,
'gdrive_id':
drive_id,
})
except Exception as e:
_logger.exception('Database.backup')
return backup
def ensure_db(redirect='/web/database/selector'):
db = request.params.get('db')
if db and db not in http.db_filter([db]):
db = None
if db and not request.session.db:
r = request.httprequest
url_redirect = r.base_url
if r.query_string:
url_redirect += '?' + r.query_string
response = werkzeug.utils.redirect(url_redirect, 302)
request.session.db = db
abort_and_redirect(url_redirect)
if not db and request.session.db and http.db_filter([request.session.db]):
db = request.session.db
if not db:
db = http.db_monodb(request.httprequest)
if not db:
werkzeug.exceptions.abort(werkzeug.utils.redirect(redirect, 303))
if db != request.session.db:
request.session.logout()
abort_and_redirect(request.httprequest.url)
request.session.db = db
