def compare(uuid, view, font_size, font_position='before'):
families = list(
r.table('families').filter({
'uuid': uuid
}).run(g.rdb_conn))[0]
families_diffs = list(
r.table('families_diffs').filter({
'uuid': uuid,
'view': view
}).run(g.rdb_conn))
user_agent = UserAgent(request.user_agent.string)
if families['has_vfs'] and not browser_supports_vfs(user_agent):
raise Exception("Browser does not support variable fonts!")
if not families_diffs and view not in ['editor', 'waterfall']:
return render_template('404.html'), 404
if 'screenshot' in request.path:
html_page = "screenshot.html"
else:
html_page = "test_fonts.html"
return render_template(html_page,
family=families,
font_diffs=families_diffs,
font_position=font_position,
limit=DIFF_LIMIT,
view=view,
views=VIEWS,
uuid=uuid,
font_size=int(font_size))
def get_meta(self, capture_uuid: str, /) -> Dict[str, str]:
'''Get the meta informations from a capture (mostly, details about the User Agent used.)'''
capture_dir = self._get_capture_dir(capture_uuid)
metafile = capture_dir / 'meta'
if metafile.exists():
with metafile.open('r') as f:
return json.load(f)
meta = {}
ct = self.get_crawled_tree(capture_uuid)
ua = UserAgent(ct.root_hartree.user_agent)
meta['user_agent'] = ua.string
if ua.platform:
meta['os'] = ua.platform
if ua.browser:
if ua.version:
meta['browser'] = f'{ua.browser} {ua.version}'
else:
meta['browser'] = ua.browser
if ua.language:
meta['language'] = ua.language
if not meta:
# UA not recognized
self.logger.info(f'Unable to recognize the User agent: {ua}')
with metafile.open('w') as f:
json.dump(meta, f)
return meta
def build_ua_file(self) -> None:
yesterday = (date.today() - timedelta(days=1))
self_generated_ua_file_path = get_homedir() / 'own_user_agents' / str(
yesterday.year) / f'{yesterday.month:02}'
safe_create_dir(self_generated_ua_file_path)
self_generated_ua_file = self_generated_ua_file_path / f'{yesterday.isoformat()}.json'
if self_generated_ua_file.exists():
return
entries = self.redis.zrevrange(f'user_agents|{yesterday.isoformat()}',
0, -1)
if not entries:
return
to_store: Dict[str, Any] = {'by_frequency': []}
uas = Counter([entry.split('|', 1)[1] for entry in entries])
for ua, count in uas.most_common():
parsed_ua = UserAgent(ua)
if not parsed_ua.platform or not parsed_ua.browser:
continue
if parsed_ua.platform not in to_store:
to_store[parsed_ua.platform] = {}
if f'{parsed_ua.browser} {parsed_ua.version}' not in to_store[
parsed_ua.platform]:
to_store[parsed_ua.platform][
f'{parsed_ua.browser} {parsed_ua.version}'] = []
to_store[parsed_ua.platform][
f'{parsed_ua.browser} {parsed_ua.version}'].append(
parsed_ua.string)
to_store['by_frequency'].append({
'os': parsed_ua.platform,
'browser': f'{parsed_ua.browser} {parsed_ua.version}',
'useragent': parsed_ua.string
})
with self_generated_ua_file.open('w') as f:
json.dump(to_store, f, indent=2)
def authenticate():
"""Sends POST to Apple API Token Server to Get Token
to send back to app to attach to request. This is not working yet"""
if 'code' not in request.form: #args:
response = redirect(auth_uri)
return response
else:
if request.form['state'] != app.secret_key:
return jsonify(
Error='State Returned does Not match that of client '), '403'
#code is sent in form, will need to have my app send the code and verify then ... send it back token?
auth_code = request.form['code']
data = {
'code': auth_code,
'client_id': config.CLIENT_ID,
'client_secret': config.CLIENT_SECRET,
'redirect_uri': config.REDIRECT_URI,
'grant_type': 'authorization_code'
}
user_agent = UserAgent(request.headers.get('User-Agent'))
headers = {'User-Agent': '{}'.format(user_agent)}
req = requests.post('https://appleid.apple.com/auth/token',
data=data,
headers=headers)
jsonreturn = req.json()
id_token = jsonreturn['id_token']
session['id_token'] = id_token
session['credentials'] = req.text
return redirect(url_for('oauth2callback'))
def panel(trans_id):
"""
This method calls index.html to render the erd tool.
Args:
panel_title: Title of the panel
"""
params = {'trans_id': trans_id, 'title': request.form['title']}
if request.args:
params.update({k: v for k, v in request.args.items()})
if 'gen' in params:
params['gen'] = True if params['gen'] == 'true' else False
close_url = request.form['close_url']
# We need client OS information to render correct Keyboard shortcuts
user_agent = UserAgent(request.headers.get('User-Agent'))
"""
Animations and transitions are not automatically GPU accelerated and by
default use browser's slow rendering engine. We need to set 'translate3d'
value of '-webkit-transform' property in order to use GPU. After applying
this property under linux, Webkit calculates wrong position of the
elements so panel contents are not visible. To make it work, we need to
explicitly set '-webkit-transform' property to 'none' for .ajs-notifier,
.ajs-message, .ajs-modal classes.
This issue is only with linux runtime application and observed in Query
tool and debugger. When we open 'Open File' dialog then whole Query tool
panel content is not visible though it contains HTML element in back end.
The port number should have already been set by the runtime if we're
running in desktop mode.
"""
is_linux_platform = False
from sys import platform as _platform
if "linux" in _platform:
is_linux_platform = True
s = Server.query.filter_by(id=params['sid']).first()
params.update({
'bgcolor': s.bgcolor,
'fgcolor': s.fgcolor,
'client_platform': user_agent.platform,
'is_desktop_mode': app.PGADMIN_RUNTIME,
'is_linux': is_linux_platform
})
return render_template(
"erd/index.html",
title=underscore_unescape(params['title']),
close_url=close_url,
requirejs=True,
basejs=True,
params=json.dumps(params),
)
def panel(trans_id, is_query_tool, editor_title):
"""
This method calls index.html to render the data grid.
Args:
trans_id: unique transaction id
is_query_tool: True if panel calls when query tool menu is clicked.
editor_title: Title of the editor
"""
# Let's fetch Script type URL from request
if request.args and request.args['query_url'] != '':
sURL = request.args['query_url']
else:
sURL = None
# Fetch server type from request
if request.args and request.args['server_type'] != '':
server_type = request.args['server_type']
else:
server_type = None
# We need client OS information to render correct Keyboard shortcuts
user_agent = UserAgent(request.headers.get('User-Agent'))
"""
Animations and transitions are not automatically GPU accelerated and by default use browser's slow rendering engine.
We need to set 'translate3d' value of '-webkit-transform' property in order to use GPU.
After applying this property under linux, Webkit calculates wrong position of the elements so panel contents are not visible.
To make it work, we need to explicitly set '-webkit-transform' property to 'none' for .ajs-notifier, .ajs-message, .ajs-modal classes.
This issue is only with linux runtime application and observed in Query tool and debugger.
When we open 'Open File' dialog then whole Query-tool panel content is not visible though it contains HTML element in back end.
The port number should have already been set by the runtime if we're running in desktop mode.
"""
is_linux_platform = False
from sys import platform as _platform
if "linux" in _platform:
is_linux_platform = True
pref = Preferences.module('sqleditor')
if pref.preference('new_browser_tab').get():
new_browser_tab = 'true'
else:
new_browser_tab = 'false'
return render_template("datagrid/index.html",
_=gettext,
uniqueId=trans_id,
is_query_tool=is_query_tool,
editor_title=editor_title,
script_type_url=sURL,
is_desktop_mode=app.PGADMIN_RUNTIME,
is_linux=is_linux_platform,
is_new_browser_tab=new_browser_tab,
server_type=server_type,
client_platform=user_agent.platform)
def email_setup_wizard_exception(traceback, args):
if not frappe.local.conf.setup_wizard_exception_email:
return
pretty_args = prettify_args(args)
if frappe.local.request:
user_agent = UserAgent(
frappe.local.request.headers.get("User-Agent", ""))
else:
user_agent = frappe._dict()
message = """
#### Traceback
<pre>{traceback}</pre>
---
#### Setup Wizard Arguments
<pre>{args}</pre>
---
#### Request Headers
<pre>{headers}</pre>
---
#### Basic Information
- **Site:** {site}
- **User:** {user}
- **Browser:** {user_agent.platform} {user_agent.browser} version: {user_agent.version} language: {user_agent.language}
- **Browser Languages**: `{accept_languages}`""".format(
site=frappe.local.site,
traceback=traceback,
args="\n".join(pretty_args),
user=frappe.session.user,
user_agent=user_agent,
headers=frappe.local.request.headers,
accept_languages=", ".join(
frappe.local.request.accept_languages.values()),
)
frappe.sendmail(
recipients=frappe.local.conf.setup_wizard_exception_email,
sender=frappe.session.user,
subject="Setup failed: {}".format(frappe.local.site),
message=message,
delayed=False,
)
def parse_browser(self, params):
ua = UserAgent(params.get('ua'))
if ua.browser:
params['ua_platform'] = ua.platform
params['ua_browser'] = ua.browser
params['ua_version'] = ua.version
else:
params['ua_platform'] = '-'
params['ua_browser'] = params.get('ua', '-')
params['ua_version'] = '-'
def index():
output = ''
command = ''
isWindows = False
user_agent = UserAgent(request.headers.get('User-Agent'))
platform = sys.platform
cwd = os.getcwd()
if platform.startswith('win32'): # 'linux', 'darwin', 'win32'
isWindows = True
if request.method == 'POST':
output = ''
# for key in request.form:
# output+=key+': '
# output+=request.form[key]+', '
#p = subprocess.Popen(['powershell.exe', script], stdout=sys.stdout)
#p.communicate()
#psxmlgen = subprocess.Popen([r'C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe',
# '-ExecutionPolicy',
# 'Unrestricted',
# './helloworld.ps1',
# 'Hello'],
# cwd=os.getcwd())
#result = psxmlgen.wait()
command = request.form['command']
try:
p = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
output += line.decode('utf-8', 'slashescape')
except:
output = sys.exc_info()[0]
#retval = p.wait()
command = ': ' + command
try:
return render_template('index.html',
output=output,
command=command,
user_agent=user_agent,
platform=platform,
isWindows=isWindows,
cwd=cwd)
except:
return render_template('error.html', errormessage=sys.exc_info())
def map_to_path(url):
mapped = url.replace('file://', '//')
ua = UserAgent(request.httprequest.environ['HTTP_USER_AGENT'])
_logger.info('UA ' + ua.platform)
if (ua.platform == 'windows'):
return mapped.replace('/', '\\')
return mapped
def wrapper(*args, **kwargs):
ua_string = request.headers.get('User-Agent')
if not ua_string:
return method(*args, **kwargs)
ua = UserAgent(request.headers.get('User-Agent'))
if ua.browser == 'msie':
try:
if int(float(ua.version)) < 8:
return render_template("noie.html")
except:
return render_template("noie.html")
return method(*args, **kwargs)
def _get_download_filename(env, filename):
from uliweb.utils.common import safe_str
from werkzeug.useragents import UserAgent
agent = UserAgent(env)
fname = safe_str(filename, 'utf8')
if agent.browser == 'msie':
result = 'filename=' + quote(fname)
elif agent.browser == 'safari':
result = 'filename=' + fname
else:
result = "filename*=UTF-8''" + quote(fname)
return result
def _sendgrid_metadata(self, sendgrid_event_type, event, metadata):
# Get sendgrid timestamp when found
ts = event.get('timestamp')
try:
ts = float(ts)
except ValueError:
ts = False
if ts:
dt = datetime.utcfromtimestamp(ts)
metadata.update({
'timestamp': ts,
'time': fields.Datetime.to_string(dt),
'date': fields.Date.to_string(dt),
})
# Common field mapping (sendgrid_field: odoo_field)
mapping = {
'email': 'recipient',
'ip': 'ip',
'url': 'url',
}
for k, v in mapping.iteritems():
if event.get(k, False):
metadata[v] = event[k]
# Special field mapping
if event.get('useragent'):
user_agent = UserAgent(event['useragent'])
metadata.update({
'user_agent':
user_agent.string,
'os_family':
user_agent.platform,
'ua_family':
user_agent.browser,
'mobile':
user_agent.platform in ['android', 'iphone', 'ipad']
})
# Mapping for special events
if sendgrid_event_type == 'bounce':
metadata.update({
'error_type': event.get('type', False),
'bounce_type': event.get('type', False),
'error_description': event.get('reason', False),
'bounce_description': event.get('reason', False),
'error_details': event.get('status', False),
})
elif sendgrid_event_type == 'dropped':
metadata.update({
'error_type': event.get('reason', False),
})
return metadata
def error_email(params):
ua = UserAgent(params.get('ua'))
if ua.browser:
browser = '{0} {1} {2} {3}'
lang = ua.language or ''
browser = browser.format(ua.platform, ua.browser, ua.version,
lang)
params['browser'] = browser
else:
params['browser'] = ua.string
params['time'] = params['time'][:19]
return params
def get_context(context):
user_agent = UserAgent(frappe.request.headers.get("User-Agent"))
platform = user_agent.platform
context.download_links = get_download_links()
context.default_download_link = "https://github.com/frappe/books/releases/latest"
if platform == "macos":
context.platform = "macOS"
elif platform == "windows":
context.platform = "Windows"
elif platform == "linux":
context.platform = "Linux"
context.developer_mode = frappe.conf.developer_mode
def show(app, request, pasteid):
"""Show pasteid either as nice HTML or, when headless client, as pure text."""
p = join(app.data_dir, pasteid)
headless = lambda req: UserAgent(req.environ).browser is None
source = lambda html: ''.join(Strip(html).code)
if isfile(p):
if not request.accept_mimetypes.accept_html or headless(request):
return Response(source(io.open(p).read()),
200,
content_type='text/plain')
return Response(io.open(p), 200, content_type='text/html')
else:
return Response('Not Found', 404)
def _build_ua_file(self):
'''Build a file in a format compatible with the capture page'''
yesterday = (date.today() - timedelta(days=1))
self_generated_ua_file_path = get_homedir() / 'own_user_agents' / str(
yesterday.year) / f'{yesterday.month:02}'
safe_create_dir(self_generated_ua_file_path)
self_generated_ua_file = self_generated_ua_file_path / f'{yesterday.isoformat()}.json'
if self_generated_ua_file.exists():
self.logger.info(
f'User-agent file for {yesterday} already exists.')
return
self.logger.info(f'Generating user-agent file for {yesterday}')
redis = Redis(unix_socket_path=get_socket_path('cache'),
decode_responses=True)
entries = redis.zrevrange(f'user_agents|{yesterday.isoformat()}', 0,
-1)
if not entries:
self.logger.info(
f'No User-agent file for {yesterday} to generate.')
return
to_store: Dict[str, Any] = {'by_frequency': []}
uas = Counter([entry.split('|', 1)[1] for entry in entries])
for ua, _ in uas.most_common():
parsed_ua = UserAgent(ua)
if not parsed_ua.platform or not parsed_ua.browser:
continue
if parsed_ua.platform not in to_store:
to_store[parsed_ua.platform] = {}
if f'{parsed_ua.browser} {parsed_ua.version}' not in to_store[
parsed_ua.platform]:
to_store[parsed_ua.platform][
f'{parsed_ua.browser} {parsed_ua.version}'] = []
to_store[parsed_ua.platform][
f'{parsed_ua.browser} {parsed_ua.version}'].append(
parsed_ua.string)
to_store['by_frequency'].append({
'os': parsed_ua.platform,
'browser': f'{parsed_ua.browser} {parsed_ua.version}',
'useragent': parsed_ua.string
})
with self_generated_ua_file.open('w') as f:
json.dump(to_store, f, indent=2)
# Remove the UA / IP mapping.
redis.delete(f'user_agents|{yesterday.isoformat()}')
self.logger.info(f'User-agent file for {yesterday} generated.')
def decorated_function(*args, **kwargs):
template_name = template
if template_name is None:
template_name = request.endpoint \
.replace('.', '/') + '.html'
ctx = f(*args, **kwargs)
if ctx is None:
ctx = {}
elif not isinstance(ctx, dict):
return ctx
return render_template("mobile/" + template_name, **ctx)
ua_string = request.headers.get('User-Agent')
if not ua_string:
return render_template("mobile/" + template_name, **ctx)
ua = UserAgent(ua_string)
if ua.platform and ua.platform.lower() in ["android", "iphone"]:
return render_template("mobile/" + template_name, **ctx)
return render_template(template_name, **ctx)
def analytics():
# TODO: move this to different module
ua = UserAgent(request.headers.get('User-Agent'))
os = ua.platform
browser = ua.browser + ' ' + ua.version
lat = request.args.get('lat')
lon = request.args.get('lon')
dev = request.args.get('dev')
dur = request.args.get('dur')
seconds = request.args.get('time')
t = datetime.fromtimestamp(int(seconds) / 1e3).time()
db.session.add(
Analytics(device=dev,
os=os,
browser=browser,
duration=dur,
traffic=t,
lat=lat,
lon=lon))
db.session.commit()
return make_response('ok')
def create_session(now=None, expires_delta=None, user_id=None):
user_id = user_id if user_id else g.current_user_id
now = datetime.utcnow() if not now else now
expires_delta = expires_delta if expires_delta else current_app.config[
'JWT_SESSION_EXPIRES']
token = token_urlsafe(32)
session_exp = now + expires_delta
user_agent = request.headers.get('User-Agent')
os = UserAgent(user_agent).platform if user_agent else ''
session = Session(user_id=user_id,
ip=request.remote_addr,
os=os,
user_agent=request.headers.get('User-Agent'),
token=token,
expired_at=session_exp,
created_at=now,
updated_at=now)
current_app.redis.set(token, 'false', expires_delta)
db.session.add(session)
db.session.commit()
return session
def _ensure_meta(self, capture_dir: Path, tree: CrawledTree) -> None:
metafile = capture_dir / 'meta'
if metafile.exists():
return
ua = UserAgent(tree.root_hartree.user_agent)
to_dump = {}
if ua.platform:
to_dump['os'] = ua.platform
if ua.browser:
if ua.version:
to_dump['browser'] = f'{ua.browser} {ua.version}'
else:
to_dump['browser'] = ua.browser
if ua.language:
to_dump['language'] = ua.language
if not to_dump:
# UA not recognized
self.logger.info(f'Unable to recognize the User agent: {ua}')
to_dump['user_agent'] = ua.string
with metafile.open('w') as f:
json.dump(to_dump, f)
def compare(uuid, view, font_size, font_position='before'):
families = list(r.table('families')
.filter({'uuid': uuid}).run(g.rdb_conn))[0]
families_diffs = list(r.table('families_diffs')
.filter({'uuid': uuid, 'view': view}).run(g.rdb_conn))
# if user includes <url>?styles=Regular,Bold etc
# only show Regular and Bold styles
filter_styles = request.args.get("styles")
filter_styles = filter_styles.split(",") if filter_styles else []
filter_styles = [s for s in filter_styles if s in families['styles']]
if filter_styles:
families['styles'] = [s for s in families['styles'] if s in filter_styles]
if filter_styles and families_diffs:
families_diffs = [d for d in families_diffs if d['font_before'] in filter_styles]
user_agent = UserAgent(request.user_agent.string)
if families['has_vfs'] and not browser_supports_vfs(user_agent):
raise Exception("Browser does not support variable fonts!")
if not families_diffs and view not in ['editor', 'waterfall', 'text']:
return render_template('404.html'), 404
if 'screenshot' in request.path:
html_page = "screenshot.html"
else:
html_page = "test_fonts.html"
return render_template(
html_page,
family=families,
font_diffs=families_diffs,
font_position=font_position,
limit=DIFF_LIMIT,
view=view,
views=VIEWS,
uuid=uuid,
font_size=int(font_size)
)
def ua_allows_obj_proxy(self, opts):
ua = opts.get('ua')
if not ua:
ua_string = opts.get('ua_string')
if ua_string:
ua = UserAgent(ua_string)
if ua is None:
return True
supported = {
'chrome': '49.0',
'firefox': '44.0',
'safari': '10.0',
'opera': '36.0',
'edge': '12.0',
'msie': None,
}
min_vers = supported.get(ua.browser)
return (min_vers and ua.version >= min_vers)
def panel(trans_id):
"""
This method calls index.html to render the data grid.
Args:
trans_id: unique transaction id
"""
url_params = None
if request.args:
url_params = {k: v for k, v in request.args.items()}
if request.form:
url_params['title'] = request.form['title']
if 'sql_filter' in request.form:
url_params['sql_filter'] = request.form['sql_filter']
if 'query_url' in request.form:
url_params['query_url'] = request.form['query_url']
# We need client OS information to render correct Keyboard shortcuts
user_agent = UserAgent(request.headers.get('User-Agent'))
"""
Animations and transitions are not automatically GPU accelerated and by
default use browser's slow rendering engine. We need to set 'translate3d'
value of '-webkit-transform' property in order to use GPU. After applying
this property under linux, Webkit calculates wrong position of the
elements so panel contents are not visible. To make it work, we need to
explicitly set '-webkit-transform' property to 'none' for .ajs-notifier,
.ajs-message, .ajs-modal classes.
This issue is only with linux runtime application and observed in Query
tool and debugger. When we open 'Open File' dialog then whole Query tool
panel content is not visible though it contains HTML element in back end.
The port number should have already been set by the runtime if we're
running in desktop mode.
"""
is_linux_platform = False
from sys import platform as _platform
if "linux" in _platform:
is_linux_platform = True
# Fetch the server details
bgcolor = None
fgcolor = None
s = Server.query.filter_by(id=url_params['sid']).first()
if s and s.bgcolor:
# If background is set to white means we do not have to change
# the title background else change it as per user specified
# background
if s.bgcolor != '#ffffff':
bgcolor = s.bgcolor
fgcolor = s.fgcolor or 'black'
layout = get_setting('SQLEditor/Layout')
return render_template(
"datagrid/index.html",
_=gettext,
uniqueId=trans_id,
is_desktop_mode=app.PGADMIN_RUNTIME,
is_linux=is_linux_platform,
title=underscore_unescape(url_params['title']),
url_params=json.dumps(url_params),
client_platform=user_agent.platform,
bgcolor=bgcolor,
fgcolor=fgcolor,
layout=layout,
)
def handler_sendgrid(self):
message_data = request.jsonrequest
_logger.info("SENDGRID Webhook received: %s" % str(message_data))
if message_data and isinstance(message_data, list):
message_data.sort(key=lambda m: m.get('timestamp'))
for notification in message_data:
event = notification.get('event')
recipient = notification.get('email')
message_id = notification.get('odoo_id')
t_email = request.env['mail.tracking.email'].sudo().search([
('mail_id.message_id', '=', message_id),
('recipient', '=', recipient)
])
if not t_email:
_logger.error("Sendgrid e-mail not found: %s" % message_id)
continue
t_vals = {
'recipient': recipient,
'timestamp': notification.get('timestamp'),
'time': fields.Datetime.now(),
'tracking_email_id': t_email.id,
'ip': notification.get('ip'),
'smtp_server': notification.get('smtp-id'),
'url': notification.get('url')
}
if notification.get('useragent'):
user_agent = UserAgent(notification.get('useragent'))
t_vals.update({
'user_agent':
user_agent.string,
'os_family':
user_agent.platform,
'ua_family':
user_agent.browser,
'mobile':
user_agent.platform in ['android', 'iphone', 'ipad']
})
m_vals = {}
event_type = self.event_mapping[event]
if event == 'dropped':
m_vals.update({
'error_description':
notification.get('reason'),
})
elif event == 'bounce':
m_vals.update({
'error_type':
notification.get('status'),
'bounce_type':
notification.get('type'),
'bounce_description':
notification.get('reason'),
})
elif event == 'deferred':
m_vals.update({
'error_smtp_server':
notification.get('response'),
})
# Create tracking event
t_email.event_create(event_type, t_vals)
# Write email tracking modifications
if m_vals:
t_email.write(m_vals)
return {'status': 200}
else:
return {'status': 400, 'message': 'wrong request'}
def powershell():
output = ''
command = ''
isWindows = False
FileSystemRights = ''
AccessControlType = ''
IdentityReference = ''
IsInherited = ''
InheritanceFlags = ''
PropagationFlags = ''
myheader = []
mylist = []
user_agent = UserAgent(request.headers.get('User-Agent'))
platform = sys.platform
cwd = os.getcwd()
if platform.startswith('win32'): # 'linux', 'darwin', 'win32'
isWindows = True
if request.method == 'POST':
output = ''
command = r'C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe'
script = request.form['script']
argument = request.form['argument']
try:
if len(script) <= 0:
p = subprocess.Popen(
[command, '-ExecutionPolicy', 'Unrestricted', script],
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=os.getcwd())
else:
# './website/static/script/readdir.ps1'
# 'D:/Public'
if len(argument) <= 0:
p = subprocess.Popen(
[command, '-ExecutionPolicy', 'Unrestricted', script],
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=os.getcwd())
else:
argument = '"' + argument + '"'
p = subprocess.Popen([
command, '-ExecutionPolicy', 'Unrestricted', script,
argument
],
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=os.getcwd())
for line in p.stdout.readlines():
text = line.decode('utf-8', 'slashescape')
output += text
tuples = list()
if text[:
16] == 'FileSystemRights': #FileSystemRights : ReadAndExecute, Synchronize
FileSystemRights = text[19:].strip()
AccessControlType = ''
IdentityReference = ''
IsInherited = ''
InheritanceFlags = ''
PropagationFlags = ''
elif text[:
17] == 'AccessControlType': #AccessControlType : Allow
AccessControlType = text[20:].strip()
elif text[:
17] == 'IdentityReference': #IdentityReference : Everyone
IdentityReference = text[20:].strip()
elif text[:11] == 'IsInherited': #IsInherited : False
IsInherited = text[19:].strip()
elif text[:
16] == 'InheritanceFlags': #InheritanceFlags : ContainerInherit, ObjectInherit
InheritanceFlags = text[19:].strip()
elif text[:
16] == 'PropagationFlags': #PropagationFlags : None
PropagationFlags = text[19:].strip()
mylist.append([
FileSystemRights, AccessControlType, IdentityReference,
IsInherited, InheritanceFlags, PropagationFlags
])
except:
output = sys.exc_info()[0]
command = command + ' ' + script + ' ' + argument
if len(mylist) > 0:
myheader = [
'FileSystemRights', 'AccessControlType', 'IdentityReference',
'IsInherited', 'InheritanceFlags', 'PropagationFlags'
]
try:
return render_template('powershell.html',
output=output,
command=command,
user_agent=user_agent,
platform=platform,
isWindows=isWindows,
cwd=cwd,
mylist=mylist,
myheader=myheader)
except:
return render_template('error.html', errormessage=sys.exc_info())
def test_non_vf_browser_cant_view_vf_diff(self):
user_agent = UserAgent(self.mock_header_safari_vf_supported)
self.assertEqual(browser_supports_vfs(user_agent), True)
user_agent = UserAgent(self.mock_header_safari_vf_not_supported)
self.assertEqual(browser_supports_vfs(user_agent), False)
def simplify_ug(ug):
wug = UserAgent(ug)
if wug.browser is not None and wug.version is not None:
return '{} {}'.format(wug.browser, wug.version)
return ''
def __call__(self, environ, start_response):
ua = UserAgent(environ)
if ua.browser != 'msie':
return self.app(environ, start_response)
return self.run_fixed(environ, start_response)
def panel(trans_id, is_query_tool, editor_title):
"""
This method calls index.html to render the data grid.
Args:
trans_id: unique transaction id
is_query_tool: True if panel calls when query tool menu is clicked.
editor_title: Title of the editor
"""
# Let's fetch Script type URL from request
if request.args and request.args['query_url'] != '':
sURL = request.args['query_url']
else:
sURL = None
# Fetch server type from request
if request.args and request.args['server_type'] != '':
server_type = request.args['server_type']
else:
server_type = None
# We need client OS information to render correct Keyboard shortcuts
user_agent = UserAgent(request.headers.get('User-Agent'))
"""
Animations and transitions are not automatically GPU accelerated and by default use browser's slow rendering engine.
We need to set 'translate3d' value of '-webkit-transform' property in order to use GPU.
After applying this property under linux, Webkit calculates wrong position of the elements so panel contents are not visible.
To make it work, we need to explicitly set '-webkit-transform' property to 'none' for .ajs-notifier, .ajs-message, .ajs-modal classes.
This issue is only with linux runtime application and observed in Query tool and debugger.
When we open 'Open File' dialog then whole Query-tool panel content is not visible though it contains HTML element in back end.
The port number should have already been set by the runtime if we're running in desktop mode.
"""
is_linux_platform = False
from sys import platform as _platform
if "linux" in _platform:
is_linux_platform = True
pref = Preferences.module('sqleditor')
if pref.preference('new_browser_tab').get():
new_browser_tab = 'true'
else:
new_browser_tab = 'false'
if is_query_tool == 'true':
prompt_save_changes = pref.preference(
'prompt_save_query_changes').get()
else:
prompt_save_changes = pref.preference('prompt_save_data_changes').get()
# Fetch the server details
#
bgcolor = None
fgcolor = None
if str(trans_id) in session['gridData']:
# Fetch the object for the specified transaction id.
# Use pickle.loads function to get the command object
session_obj = session['gridData'][str(trans_id)]
trans_obj = pickle.loads(session_obj['command_obj'])
s = Server.query.filter_by(id=trans_obj.sid).first()
if s and s.bgcolor:
# If background is set to white means we do not have to change the
# title background else change it as per user specified background
if s.bgcolor != '#ffffff':
bgcolor = s.bgcolor
fgcolor = s.fgcolor or 'black'
return render_template(
"datagrid/index.html",
_=gettext,
uniqueId=trans_id,
is_query_tool=is_query_tool,
editor_title=editor_title,
script_type_url=sURL,
is_desktop_mode=app.PGADMIN_RUNTIME,
is_linux=is_linux_platform,
is_new_browser_tab=new_browser_tab,
server_type=server_type,
client_platform=user_agent.platform,
bgcolor=bgcolor,
fgcolor=fgcolor,
# convert python boolean value to equivalent js boolean literal before
# passing it to html template.
prompt_save_changes='true' if prompt_save_changes else 'false')