def POST(self):
i = web.input(accountType=[], accountStatus=[],)
searchString = i.get('searchString', '')
if len(searchString) == 0:
raise web.seeother('/search?msg=EMPTY_STRING')
accountType = i.get('accountType', [])
accountStatus = i.get('accountStatus', [])
try:
connutils = connUtils.Utils()
qr = connutils.search(searchString,
accountType=accountType,
accountStatus=accountStatus,
)
if qr[0] is False:
return web.render(
'mysql/search.html',
msg=qr[1],
searchString=searchString,
)
except Exception, e:
return web.render(
'mysql/search.html',
msg=str(e),
searchString=searchString,
)
def GET(self):
page = self.page
table = inc.tablesort.table()
table.header.titles = ['Type', 'Date', 'Message', 'User', 'Operation']
table.header.fields = ['type', 'timestamp', 'message', 'name']
table.header.sorts = ['asc', 'desc', 'asc', 'asc']
table.default_order_by = 'timestamp'
sql = '''SELECT w.wid, \
w.uid, w.severity, w.type, w.timestamp, w.message, w.link, \
u.name FROM watchdog w INNER JOIN users u \
ON w.uid = u.uid'''+table.order_sql()
iter_entries, page_nums = inc.pager.query(sql, limit=100)
#TODO: i don't quite understand why this line is needed,
# but i do know things stop working without it
table.rows = []
for entry in iter_entries:
table.rows.append( (str(entry.type),
str(inc.common.format_date(entry.timestamp)),
str(entry.message),
str(entry.name),
'put operation here') )
content = sql
content += table.render()
content += page_nums.render()
web.render('generic.html')
def POST(self, node_type):
page = self.page
form = _form_node(node_type,
page.user.roles.keys()) # checks if this node_type exists too
checkaccess(page.user, ''.join(('create ',node_type,' content')))
if form.validates():
node = form.d
node.time_now = int(time.time())
node.uid = page.user.uid
# Get publishing settings.
options = mod[node_type].defaults
# Insert main entry in 'node' table
node.nid = web.insert('node',uid=page.user.uid,created=node.time_now,
changed=node.time_now, title=node.title, type=node_type,
**options)
# Do module specific insertions.
if hasattr(mod[node_type], 'node_insert'):
mod[node_type].node_insert(node)
web.redirect('/node/'+str(node.nid))
content = '<form method="post" name="new_node">'
content += form.render()
content += '<input type="submit" /></form>'
web.render('generic.html')
def GET(self, cur_page=1,):
i = web.input()
try:
cur_page = int(cur_page) or 1
except:
cur_page = 1
domainLib = domainlib.Domain()
result = domainLib.listAccounts(cur_page=cur_page)
if result[0] is True:
allDomains = result[2]
return web.render(
'pgsql/domain/list.html',
cur_page=cur_page,
total=result[1],
allDomains=allDomains,
msg=i.get('msg', None),
)
else:
return web.render(
'pgsql/domain/list.html',
cur_page=cur_page,
total=0,
allDomains=[],
msg=result[1],
)
def GET(self,nid):
page = self.page
node = mod.node.load(nid)
if node is None:
pagenotfound()
else:
links = ''
page.title = node.title
#controls are for the edit/delete/revisions/etc links for a node
#is there a better place to do this than here?
controls = []
if hasaccess(self.page.user, ''.join(('edit ', node.type, ' content'))) \
or (hasaccess(page.user, ''.join(('edit own ', node.type, ' content'))) \
and page.user.uid == node.uid):
controls.append( (''.join(('/node/', str(node.nid), '/edit')),'edit') )
if hasaccess(self.page.user, ''.join(('delete ', node.type, ' content'))) \
or (hasaccess(page.user, ''.join(('delete own ', node.type, ' content'))) \
and page.user.uid == node.uid):
controls.append( (''.join(('/node/', str(node.nid), '/delete')),'delete') )
controls = web.render('node_controls.html', asTemplate=True)
try:
web.render(''.join(('node-',node.type,'.html')))
except:
web.render('node.html')
def GET(self):
user_stats = UserStats(count=10).get()
week_ago = datetime.now() - timedelta(days=7)
unix_week = int(mktime(week_ago.timetuple()))
story_stats = StoryStats(time_offset = unix_week, count=15).get()
web.render('stats.tpl.html', {'user_stats': user_stats, 'story_stats': story_stats})
def GET(self):
form = web.input(_unicode=False)
is_api_login = False
# check if trying API Login with GET Method
try:
if form.get('key', '').strip() != "" and form.get(
'key', '').strip() != None:
is_api_login = True
api_key = str(form.get('key', '').strip())
else:
is_api_login = False
except AttributeError:
raise web.seeother('/api?msg=Something_Went_Wrong_E:AuthAPIChk')
# return if trying API Login with GET Method
if is_api_login:
raise web.seeother(
'/api?msg=Login_with_API_KEY_must_be_via_POST_method')
if not session.get('logged'):
form = web.input(_unicode=False)
if not iredutils.is_allowed_admin_login_ip(client_ip=web.ctx.ip):
return web.render('error_without_login.html',
error='NOT_ALLOWED_IP')
# Show login page.
return web.render('login.html',
languagemaps=iredutils.get_language_maps(),
msg=form.get('msg'))
else:
if settings.REDIRECT_TO_DOMAIN_LIST_AFTER_LOGIN:
raise web.seeother('/domains')
else:
raise web.seeother('/dashboard')
def GET(self, cur_page=1,):
i = web.input()
try:
cur_page = int(cur_page) or 1
except:
cur_page = 1
domainLib = domainlib.Domain()
result = domainLib.listAccounts(cur_page=cur_page)
if result[0] is True:
allDomains = result[2]
return web.render(
'pgsql/domain/list.html',
cur_page=cur_page,
total=result[1],
allDomains=allDomains,
msg=i.get('msg', None),
)
else:
return web.render(
'pgsql/domain/list.html',
cur_page=cur_page,
total=0,
allDomains=[],
msg=result[1],
)
def POST(self):
page = self.page
i = web.input()
captcha = recaptcha.submit(i.recaptcha_challenge_field,
i.recaptcha_response_field,
private_key, web.ctx.ip)
content = captcha.is_valid, captcha.error_code
web.render('generic.html')
def GET(self):
page = self.page
form = form_edit_filters()
content = 'filters available:'+str(_filters_available())
content += '<form method="post">'
content += form.render()
content += '<input type="submit" /></form>'
web.render('generic.html')
def GET(self):
path = web.ctx.path
variable = glbl.variable
user = web.storage({'uid':0})
limit = int(variable['default_nodes_main'])
nodes = mod.node.node_load_many(limit)
content = mod.node.node_render_many(nodes)
web.render('index.html')
def GET(self, profile_type, mail):
self.mail = web.safestr(mail)
self.profile_type = web.safestr(profile_type)
if session.get('domainGlobalAdmin') is not True and session.get('username') != self.mail:
# Don't allow to view/update other admins' profile.
raise web.seeother('/profile/admin/general/%s?msg=PERMISSION_DENIED' % session.get('username'))
# Get admin profile.
adminLib = admin.Admin()
result = adminLib.profile(self.mail)
if result[0] is not True:
raise web.seeother('/admins?msg=' + result[1])
else:
self.admin_profile = result[1]
i = web.input()
if self.profile_type == 'general':
# Get available languages.
if result[0] is True:
###################
# Managed domains
#
# Check permission.
#if session.get('domainGlobalAdmin') is not True:
# raise web.seeother('/profile/admin/general/%s?msg=PERMISSION_DENIED' % self.mail)
# Get all domains.
domainLib = domainlib.Domain()
resultOfAllDomains = domainLib.listAccounts(attrs=['domainName', 'cn', ])
if resultOfAllDomains[0] is True:
self.allDomains = resultOfAllDomains[1]
else:
return resultOfAllDomains
return web.render(
'ldap/admin/profile.html',
mail=self.mail,
profile_type=self.profile_type,
profile=self.admin_profile,
languagemaps=languages.get_language_maps(),
allDomains=self.allDomains,
msg=i.get('msg', None),
)
else:
raise web.seeother('/profile/admin/%s/%s?msg=%s' % (self.profile_type, self.mail, result[1]))
elif self.profile_type == 'password':
return web.render('ldap/admin/profile.html',
mail=self.mail,
profile_type=self.profile_type,
profile=self.admin_profile,
min_passwd_length=settings.min_passwd_length,
max_passwd_length=settings.max_passwd_length,
msg=i.get('msg', None),
)
def GET(self):
web.header('Content-Type', 'text/html')
query = web.input().get('q')
start = time.time()
i = dolphy.Index('data/test.db')
results = i.search(query, 'simple')
duration = "%.6f" % (time.time() - start)
tmp = open('templates/results.html').read()
web.render(tmp, isString=True)
def GET(self):
page = self.page
content = ''
for key in mod:
if getattr(mod[key], 'drupy_node_module', False):
node_type = key
if hasaccess(page.user, ''.join(('create ',node_type,' content'))):
content += '<p><a href="/node/add/'+str(node_type)+'">'+str(node_type)+'</a></p>'
web.render('generic.html')
def render_many(nodes):
"""Returns a string containing the templated output of node teasers."""
t = []
for node in nodes:
try:
t.append(str(web.render(''.join(('node-',node.type,'_teaser.html')), asTemplate=True)))
except:
t.append(str(web.render('node_teaser.html', asTemplate=True)))
return ''.join(t)
def GET(self):
web.header('Content-Type', 'text/html')
query = web.input().get('q')
start = time.time()
i = dolphy.Index('data/test.db')
results = i.search(query, 'simple')
duration = "%.6f" % (time.time() - start)
tmp = open('templates/results.html').read()
web.render(tmp, isString=True)
def GET(self, tag):
bookmarks = []
bs = list(web.select("bookmarks", order="created desc"))
for b in bs:
b.tags = b.tags.split()
if tag in b.tags:
bookmarks.append(b)
empty = len(bookmarks) == 0
web.render("search.html")
def GET(self):
page = self.page
form = form_variable()
form_new = form_new_variable()
content = '<form method="post" name="settings">'
content += form_new.render()
content += form.render()
content += '<input type="submit" /></form>'
web.render('generic.html')
def GET(self, tag):
bookmarks = []
bs = list(web.select("bookmarks", order="created desc"))
for b in bs:
b.tags = b.tags.split()
if tag in b.tags:
bookmarks.append(b)
empty = (len(bookmarks) == 0)
web.render('search.html')
def pagenotfound():
"""the parameter page is self.page from the calling class"""
page = web.storage()
page.path = web.ctx.path
page.variable = glbl.variable
page.title = ''
page.message = ''
page.user = inc.session.read()
inc.session.write(page.user.sid,'',user=page.user)
web.render('pagenotfound.html')
def GET(self, id):
try:
bookmark = web.select("bookmarks", where="id = "+id)[0]
web.render('edit.html')
except IndexError:
print "This bookmark doesn't exist."
def POST(self, id):
i = web.input()
web.update('bookmarks', 'id = '+id, title=i.title, url=i.url, tags=i.tags)
web.seeother('../')
def GET(self):
page = self.page
f = form_util()
content = '<form method="post">'
content += f.render()
content += '<input type="submit" /></form>'
var = str(glbl.filter)
var = var.replace('<', '<')
content += var
web.render('generic.html')
def GET(self):
user_stats = UserStats(count=10).get()
week_ago = datetime.now() - timedelta(days=7)
unix_week = int(mktime(week_ago.timetuple()))
story_stats = StoryStats(time_offset=unix_week, count=15).get()
web.render('stats.tpl.html', {
'user_stats': user_stats,
'story_stats': story_stats
})
def POST(self):
page = self.page
form = form_login()
if form.validates():
# successful login info
data = form.d
login(email=data.email,remember_me=data.remember_me)
web.redirect('/user')
else:
web.render('login.html')
def POST(self, tag):
i = web.input()
tags = i.tags.split()
bookmarks = []
bs = list(web.select("bookmarks", order="created desc"))
for b in bs:
b.tags = b.tags.split()
if every(lambda t: t in b.tags, tags):
bookmarks.append(b)
empty = len(bookmarks) == 0
web.render("search.html")
def POST(self, tag):
i = web.input()
tags = i.tags.split()
bookmarks = []
bs = list(web.select("bookmarks", order="created desc"))
for b in bs:
b.tags = b.tags.split()
if every(lambda t: t in b.tags, tags):
bookmarks.append(b)
empty = (len(bookmarks) == 0)
web.render('search.html')
def GET(self, profile_type, mail):
self.mail = web.safestr(mail)
self.profile_type = web.safestr(profile_type)
if session.get('domainGlobalAdmin') is not True and session.get('username') != self.mail:
# Don't allow to view/update other admins' profile.
raise web.seeother('/profile/admin/general/%s?msg=PERMISSION_DENIED' % session.get('username'))
# Get admin profile.
adminLib = admin.Admin()
result = adminLib.profile(self.mail)
if result[0] is not True:
raise web.seeother('/admins?msg=' + result[1])
else:
self.admin_profile = result[1]
i = web.input()
if self.profile_type == 'general':
# Get available languages.
if result[0] is True:
###################
# Managed domains
#
# Get all domains.
domainLib = domainlib.Domain()
resultOfAllDomains = domainLib.listAccounts(attrs=['domainName', 'cn', ])
if resultOfAllDomains[0] is True:
self.allDomains = resultOfAllDomains[1]
else:
return resultOfAllDomains
return web.render(
'ldap/admin/profile.html',
mail=self.mail,
profile_type=self.profile_type,
profile=self.admin_profile,
languagemaps=languages.get_language_maps(),
allDomains=self.allDomains,
msg=i.get('msg', None),
)
else:
raise web.seeother('/profile/admin/%s/%s?msg=%s' % (self.profile_type, self.mail, result[1]))
elif self.profile_type == 'password':
return web.render('ldap/admin/profile.html',
mail=self.mail,
profile_type=self.profile_type,
profile=self.admin_profile,
min_passwd_length=settings.min_passwd_length,
max_passwd_length=settings.max_passwd_length,
msg=i.get('msg', None))
def decorated(*args, **kw):
form = web.input()
if "csrf_token" not in form:
return web.render("error_csrf.html")
if not session.get("csrf_token"):
session["csrf_token"] = iredutils.generate_random_strings(32)
if form["csrf_token"] != session["csrf_token"]:
return web.render("error_csrf.html")
return f(*args, **kw)
def GET(self, node_type):
page = self.page
self.node_type = node_type
f = _form_node(node_type, page.user.roles.keys())
if not f: pagenotfound()
else:
checkaccess(page.user, ''.join(('create ',node_type,' content')))
content = '<form method="post" name="new_node">'
content += f.render()
content += self._pub_options()
content += '<input type="submit" /></form>'
web.render('generic.html')
def GET(self, nid):
page = self.page
node = mod.node.load(nid)
if node is None:
pagenotfound()
else:
self._checkaccess(node)
f = self._form_delete()
content = "Are You Sure You Want To Delete " + str(node.title) + "? This action cannot be undone."
content += '<form method="post"><input type="submit" value="Delete" />'
content += f.render()
content += '</form>'
web.render('generic.html')
def GET(self):
page = self.page
content = ''
admin_urls = []
for key in mod:
if hasattr(mod[key], 'urls'):
p = web.group(mod[key].urls,2)
for pair in p:
if pair[0].startswith('/admin/'):
admin_urls.append(pair)
content += '<p>'+key+' <a href="'+pair[0]+'">'+pair[1]+'</a> '
content += str(getattr(mod[key],pair[1]).__doc__)
content += '</p>'
web.render('generic.html')
def POST(self):
# This is almost identical to the POST in the user class
# Could get rid of this function it by changing where the
# form posts to.
page = self.page
form = form_login()
if form.validates():
# successful login
login(email=form.d.email)
if web.input().has_key('url'):
web.redirect(web.input().url)
web.redirect('/user')
else:
self.message = 'Invalid login, try again.'
web.render('login.html')
def GET(self, nid):
page = self.page
node = mod.node.load(nid, raw = True)
if node is None:
pagenotfound()
else:
self._checkaccess(node)
form = _form_node(node.type, page.user.roles.keys())
form.fill(node)
content = '<form method="post">'
content += form.render()
content += '<button type="submit" value="Edit">Submit</button>'
content +='</form>'
web.render('generic.html')
def GET(self, generate=False):
form = web.input(_unicode=False)
_wrap = SQLWrap()
conn = _wrap.conn
if not generate:
# Get queries.
form_cur_page = web.safestr(form.get('page', '1'))
if not form_cur_page.isdigit() or form_cur_page == '0':
form_cur_page = 1
else:
form_cur_page = int(form_cur_page)
qr = conn.select('api', what='COUNT(kid) AS total')
total = qr[0].total or 0
entries = []
# Get records.
if total > 0:
qr = conn.select(
'api',
offset=(form_cur_page - 1) * PAGE_SIZE_LIMIT,
limit=PAGE_SIZE_LIMIT,
order=
'is_enabled DESC, expiry_date_time DESC, last_update_timestamp DESC,creation_timestamp DESC',
)
entries = list(qr)
for i in range(len(entries)):
if datetime.datetime.strptime(
str(entries[i].expiry_date_time),
'%Y-%m-%d %H:%M:%S') > datetime.datetime.now():
entries[i]['editable'] = True
else:
entries[i]['editable'] = False
entries[i].api_description = urllib.parse.unquote(
entries[i].api_description)
return web.render('panel/apis.html',
cur_page=form_cur_page,
total=total,
entries=entries,
page_size_limit=PAGE_SIZE_LIMIT,
msg=form.get('msg'))
else:
return web.render('panel/apis_gen.html')
def GET(self, cur_page=1, disabled_only=False):
"""List paged mail domains."""
form = web.input(_unicode=False)
cur_page = int(cur_page) or 1
all_domain_profiles = []
domain_used_quota = {}
all_first_chars = []
first_char = None
if 'starts_with' in form:
first_char = form.get('starts_with')[:1].upper()
if not iredutils.is_valid_account_first_char(first_char):
first_char = None
_wrap = SQLWrap()
conn = _wrap.conn
# Get first characters of all domains
_qr = sql_lib_domain.get_first_char_of_all_domains(conn=conn)
if _qr[0]:
all_first_chars = _qr[1]
total = sql_lib_admin.num_managed_domains(conn=conn,
disabled_only=disabled_only,
first_char=first_char)
if total:
qr = sql_lib_domain.get_paged_domains(cur_page=cur_page,
first_char=first_char,
disabled_only=disabled_only,
conn=conn)
if qr[0]:
all_domain_profiles = qr[1]
if settings.SHOW_USED_QUOTA:
domains = []
for i in all_domain_profiles:
domains.append(str(i.domain))
domain_used_quota = sql_lib_domain.get_domain_used_quota(
conn=conn, domains=domains)
if session.get('is_global_admin'):
days_to_keep_removed_mailbox = settings.DAYS_TO_KEEP_REMOVED_MAILBOX_FOR_GLOBAL_ADMIN
else:
days_to_keep_removed_mailbox = settings.DAYS_TO_KEEP_REMOVED_MAILBOX
return web.render(
'sql/domain/list.html',
cur_page=cur_page,
total=total,
all_domain_profiles=all_domain_profiles,
domain_used_quota=domain_used_quota,
local_transports=settings.LOCAL_TRANSPORTS,
first_char=first_char,
all_first_chars=all_first_chars,
disabled_only=disabled_only,
days_to_keep_removed_mailbox=days_to_keep_removed_mailbox,
msg=form.get('msg', None))
def GET(self, profile_type, domain):
i = web.input()
self.domain = web.safestr(domain.split('/', 1)[0])
self.profile_type = web.safestr(profile_type)
if not iredutils.isDomain(self.domain):
return web.seeother('/domains?msg=EMPTY_DOMAIN')
domainLib = domainlib.Domain()
result = domainLib.profile(domain=self.domain)
if result[0] is True:
r = domainLib.listAccounts(attrs=['domainName'])
if r[0] is True:
allDomains = r[1]
else:
return r
allAccountSettings = ldaputils.getAccountSettingFromLdapQueryResult(
result[1],
key='domainName',
)
return web.render(
'ldap/domain/profile.html',
cur_domain=self.domain,
allDomains=allDomains,
allAccountSettings=allAccountSettings,
profile=result[1],
profile_type=self.profile_type,
msg=i.get('msg', None),
)
else:
return web.seeother('/domains?msg=' + result[1])
def GET(self, cur_page=1):
i = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page == 1
adminLib = admin.Admin()
result = adminLib.listAccounts()
connutils = connUtils.Utils()
sl = connutils.getSizelimitFromAccountLists(
result[1],
curPage=cur_page,
sizelimit=session['pageSizeLimit'],
)
if cur_page > sl.get('totalPages', 0):
cur_page = sl.get('totalPages', 0)
return web.render(
'ldap/admin/list.html',
cur_page=cur_page,
total=sl.get('totalAccounts'),
admins=sl.get('accountList'),
msg=i.get('msg', None),
)
def GET(self, profile_type, domain):
i = web.input()
self.domain = web.safestr(domain.split('/', 1)[0])
self.profile_type = web.safestr(profile_type)
if not iredutils.isDomain(self.domain):
return web.seeother('/domains?msg=EMPTY_DOMAIN')
domainLib = domainlib.Domain()
result = domainLib.profile(domain=self.domain)
if result[0] is True:
r = domainLib.listAccounts(attrs=['domainName'])
if r[0] is True:
allDomains = r[1]
else:
return r
allAccountSettings = ldaputils.getAccountSettingFromLdapQueryResult(result[1], key='domainName',)
return web.render(
'ldap/domain/profile.html',
cur_domain=self.domain,
allDomains=allDomains,
allAccountSettings=allAccountSettings,
profile=result[1],
profile_type=self.profile_type,
msg=i.get('msg', None),
)
else:
return web.seeother('/domains?msg=' + result[1])
def GET(self, cur_page=1):
i = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page == 1
domainLib = domainlib.Domain()
result = domainLib.listAccounts()
if result[0] is True:
allDomains = result[1]
# Get value of accountSetting.
allAccountSettings = ldaputils.getAccountSettingFromLdapQueryResult(allDomains, key='domainName',)
else:
return result
connutils = connUtils.Utils()
sl = connutils.getSizelimitFromAccountLists(allDomains, curPage=cur_page, sizelimit=session.get('pageSizeLimit', 50),)
if cur_page > sl.get('totalPages'):
cur_page = sl.get('totalPages')
return web.render(
'ldap/domain/list.html',
cur_page=cur_page,
total=sl.get('totalAccounts'),
allDomains=sl.get('accountList'),
allAccountSettings=allAccountSettings,
msg=i.get('msg', None),
)
def GET(self, cur_page=1):
form = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page = 1
_wrap = SQLWrap()
conn = _wrap.conn
result = sql_lib_admin.get_paged_admins(conn=conn, cur_page=cur_page)
if result[0] is True:
(total, records) = (result[1]['total'], result[1]['records'])
# Get list of global admins.
all_global_admins = []
qr = sql_lib_admin.get_all_global_admins(conn=conn)
if qr[0]:
all_global_admins = qr[1]
return web.render(
'sql/admin/list.html',
cur_page=cur_page,
total=total,
admins=records,
allGlobalAdmins=all_global_admins,
msg=form.get('msg', None),
)
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))
def GET(self, profile_type, mail):
i = web.input()
self.mail = str(mail).lower()
self.cur_domain = self.mail.split('@', 1)[-1]
self.profile_type = str(profile_type)
if self.mail.startswith('@') and iredutils.is_domain(self.cur_domain):
# Catchall account.
raise web.seeother('/profile/domain/catchall/%s' % self.cur_domain)
if not iredutils.is_email(self.mail):
raise web.seeother('/domains?msg=INVALID_USER')
if not iredutils.is_domain(self.cur_domain):
raise web.seeother('/domains?msg=INVALID_DOMAIN_NAME')
userLib = userlib.User()
qr = userLib.profile(domain=self.cur_domain, mail=self.mail)
if qr[0] is True:
self.profile = qr[1]
else:
raise web.seeother('/users/%s?msg=%s' % (self.cur_domain, web.urlquote(qr[1])))
return web.render(
'pgsql/user/profile.html',
cur_domain=self.cur_domain,
mail=self.mail,
profile_type=self.profile_type,
profile=self.profile,
languagemaps=get_language_maps(),
msg=i.get('msg'),
)
def GET(self, domain, cur_page=1):
self.domain = web.safestr(domain).split('/', 1)[0]
cur_page = int(cur_page)
if not iredutils.is_domain(self.domain):
raise web.seeother('/domains?msg=INVALID_DOMAIN_NAME')
if cur_page == 0:
cur_page = 1
userLib = userlib.User()
result = userLib.listAccounts(domain=self.domain, cur_page=cur_page,)
if result[0] is True:
(total, records) = (result[1], result[2])
return web.render(
'pgsql/user/list.html',
cur_domain=self.domain,
cur_page=cur_page,
total=total,
users=records,
msg=web.input().get('msg', None),
)
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))
def GET(self, cur_page=1):
i = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page == 1
adminLib = adminlib.Admin()
result = adminLib.listAccounts(cur_page=cur_page)
if result[0] is True:
(total, records) = (result[1]['total'], result[1]['records'])
# Get list of global admins.
allGlobalAdmins = []
qr = adminLib.get_all_global_admins(mail_only=True)
if qr[0]:
allGlobalAdmins = qr[1]
return web.render(
'pgsql/admin/list.html',
cur_page=cur_page,
total=total,
admins=records,
allGlobalAdmins=allGlobalAdmins,
msg=i.get('msg', None),
)
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))
def GET(self, cur_page=1):
i = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page == 1
adminLib = adminlib.Admin()
result = adminLib.listAccounts(cur_page=cur_page)
if result[0] is True:
(total, records) = (result[1], result[2])
# Get list of global admins.
allGlobalAdmins = []
connutils = connUtils.Utils()
qr = connutils.getAllGlobalAdmins()
if qr[0] is True:
allGlobalAdmins = qr[1]
return web.render(
'dbmail_mysql/admin/list.html',
cur_page=cur_page,
total=total,
admins=records,
allGlobalAdmins=allGlobalAdmins,
msg=i.get('msg', None),
)
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))
def login():
if request.method == 'POST':
# ct = request.environ.get('CONTENT_LENGTH')
# print(ct)
# print(request.environ['wsgi.input'].read(int(ct)))
# print('wsgi.input', request.environ['wsgi.input'].read(100))
print('content-length', request.content_length)
# bo = request.environ['wsgi.input']
# print(bo.read(129))
# print(type(bo))
# bo.seek(0)
# print('twice', request.environ['wsgi.input'].read(10))
# print('twice', request.environ['wsgi.input'].read(10))
# print(request.POST.to_dict())
# print(request.POST)
# print('request.form:', request.form)
print('request.content_type:', request.content_type)
# # print(request.params.to_dict())
# return request.params.hobbits
# return request.environ['wsgi.input'].read()
# while True:
# cont = request.environ['wsgi.input'].read(300)
# if not cont:
# break
# yield cont
print('form', request.form)
# print('file', request.files.avatar)
# request.files.avatar.save('/Users/cymoo/Desktop/minim_file')
#
return 'haha'
return render('login.html')
def GET(
self,
domain=None,
):
if domain is None:
self.cur_domain = None
else:
self.cur_domain = str(domain)
if not iredutils.isDomain(self.cur_domain):
raise web.seeother('/domains?msg=INVALID_DOMAIN_NAME')
i = web.input()
# Get all managed domains.
connutils = connUtils.Utils()
qr = connutils.getManagedDomains(
admin=session.get('username'),
domainNameOnly=True,
)
if qr[0] is True:
allDomains = qr[1]
else:
raise web.seeother('/domains?msg=' + web.urlquote(qr[1]))
# Set first domain as current domain.
if self.cur_domain is None:
if len(allDomains) > 0:
raise web.seeother('/create/alias/%s' % str(allDomains[0]))
else:
raise web.seeother('/domains?msg=NO_DOMAIN_AVAILABLE')
# Get domain profile.
domainLib = domainlib.Domain()
resultOfProfile = domainLib.profile(domain=self.cur_domain)
if resultOfProfile[0] is True:
self.profile = resultOfProfile[1]
else:
raise web.seeother('/domains?msg=%s' %
web.urlquote(resultOfProfile[1]))
# Cet total number and allocated quota size of existing users under domain.
self.numberOfExistAccounts = 0
resultOfCount = domainLib.getCountsOfExistAccountsUnderDomain(
domain=self.cur_domain,
accountType='alias',
)
if resultOfCount[0] is True:
self.numberOfExistAccounts = resultOfCount[1]
return web.render(
'dbmail_mysql/alias/create.html',
cur_domain=self.cur_domain,
allDomains=allDomains,
profile=self.profile,
numberOfExistAccounts=self.numberOfExistAccounts,
numberOfAccounts=2,
msg=i.get('msg'),
)
def GET(self):
i = web.input(_unicode=False,)
# Get queries.
self.event = web.safestr(i.get('event', 'all'))
self.domain = web.safestr(i.get('domain', 'all'))
self.admin = web.safestr(i.get('admin', 'all'))
self.cur_page = web.safestr(i.get('page', '1'))
if not self.cur_page.isdigit() or self.cur_page == '0':
self.cur_page = 1
else:
self.cur_page = int(self.cur_page)
logLib = loglib.Log()
total, entries = logLib.listLogs(
event=self.event,
domain=self.domain,
admin=self.admin,
cur_page=self.cur_page,
)
return web.render(
'panel/log.html',
event=self.event,
domain=self.domain,
admin=self.admin,
log_events=LOG_EVENTS,
cur_page=self.cur_page,
total=total,
entries=entries,
msg=i.get('msg'),
)
def login():
if request.method == 'POST':
# ct = request.environ.get('CONTENT_LENGTH')
# print(ct)
# print(request.environ['wsgi.input'].read(int(ct)))
# print('wsgi.input', request.environ['wsgi.input'].read(100))
print('content-length', request.content_length)
# bo = request.environ['wsgi.input']
# print(bo.read(129))
# print(type(bo))
# bo.seek(0)
# print('twice', request.environ['wsgi.input'].read(10))
# print('twice', request.environ['wsgi.input'].read(10))
# print(request.POST.to_dict())
# print(request.POST)
# print('request.form:', request.form)
print('request.content_type:', request.content_type)
# # print(request.params.to_dict())
# return request.params.hobbits
# return request.environ['wsgi.input'].read()
# while True:
# cont = request.environ['wsgi.input'].read(300)
# if not cont:
# break
# yield cont
print('form', request.form)
# print('file', request.files.avatar)
# request.files.avatar.save('/Users/cymoo/Desktop/minim_file')
#
return 'haha'
return render('login.html')
class Dashboard:
@decorators.require_login
def GET(self, checknew=False):
if checknew:
checknew = True
# Get network interface related infomation.
netif_data = {}
try:
import netifaces
ifaces = netifaces.interfaces()
for iface in ifaces:
addr = netifaces.ifaddresses(iface)
if netifaces.AF_INET in addr.keys():
data = addr[netifaces.AF_INET][0]
try:
netif_data[iface] = {'addr': data['addr'], 'netmask': data['netmask'], }
except Exception:
pass
except Exception:
pass
# Check new version.
newVersionInfo = (None, )
if session.get('domainGlobalAdmin') is True and checknew is True:
try:
curdate = time.strftime('%Y-%m-%d')
vars = dict(date=curdate)
r = web.admindb.select('updatelog', vars=vars, where='date >= $date',)
if len(r) == 0:
urlInfo = {
'v': __version_ose__,
'lang': settings.default_language,
'host': getfqdn(),
'backend': settings.backend,
}
url = __url_latest_ose__ + '?' + urlencode(urlInfo)
newVersionInfo = iredutils.getNewVersion(url)
# Always remove all old records, just keep the last one.
web.admindb.delete('updatelog', vars=vars, where='date < $date',)
# Insert updating date.
web.admindb.insert('updatelog', date=curdate,)
except Exception, e:
newVersionInfo = (False, str(e))
return web.render(
'dashboard.html',
version=__version_ose__,
iredmail_version=iredutils.get_iredmail_version(),
hostname=getfqdn(),
uptime=iredutils.get_server_uptime(),
loadavg=iredutils.get_system_load_average(),
netif_data=netif_data,
newVersionInfo=newVersionInfo,
)
def GET(self):
if not session.get('logged'):
form = web.input(_unicode=False)
if not iredutils.is_allowed_admin_login_ip(client_ip=web.ctx.ip):
return web.render('error_without_login.html',
error='NOT_ALLOWED_IP')
# Show login page.
return web.render('login.html',
languagemaps=iredutils.get_language_maps(),
msg=form.get('msg'))
else:
if settings.REDIRECT_TO_DOMAIN_LIST_AFTER_LOGIN:
raise web.seeother('/domains')
else:
raise web.seeother('/dashboard')
def GET(self):
i = web.input()
return web.render('ldap/admin/create.html',
languagemaps=languages.get_language_maps(),
default_language=settings.default_language,
min_passwd_length=settings.min_passwd_length,
max_passwd_length=settings.max_passwd_length,
msg=i.get('msg'))
def GET(self):
form = web.input()
return web.render('sql/domain/create.html',
preferred_language=settings.default_language,
languagemaps=iredutils.get_language_maps(),
timezones=TIMEZONES,
msg=form.get('msg'))
def GET(self):
form = web.input()
return web.render('sql/admin/create.html',
languagemaps=iredutils.get_language_maps(),
default_language=settings.default_language,
min_passwd_length=settings.min_passwd_length,
max_passwd_length=settings.max_passwd_length,
password_policies=iredutils.get_password_policies(),
msg=form.get('msg'))
def GET(self, domain):
domain = str(domain).lower()
form = web.input()
# Get all managed domains.
_wrap = SQLWrap()
conn = _wrap.conn
if session.get('is_global_admin'):
qr = sql_lib_domain.get_all_domains(conn=conn, name_only=True)
else:
qr = sql_lib_admin.get_managed_domains(
conn=conn,
admin=session.get('username'),
domain_name_only=True)
if qr[0] is True:
all_domains = qr[1]
else:
raise web.seeother('/api?msg=' + web.urlquote(qr[1]))
# Get domain profile.
qr_profile = sql_lib_domain.simple_profile(domain=domain, conn=conn)
if qr_profile[0] is True:
domain_profile = qr_profile[1]
domain_settings = sqlutils.account_settings_string_to_dict(
domain_profile['settings'])
else:
raise web.seeother('/api?msg=%s' % web.urlquote(qr_profile[1]))
# Cet total number and allocated quota size of existing users under domain.
num_users_under_domain = sql_lib_general.num_users_under_domain(
domain=domain, conn=conn)
min_passwd_length = domain_settings.get('min_passwd_length',
settings.min_passwd_length)
max_passwd_length = domain_settings.get('max_passwd_length',
settings.max_passwd_length)
return web.render(
'api/msg/msg.html',
content_type="application/json",
msg={
#"cur_domain":domain,
#"allDomains":all_domains,
#"profile":domain_profile,
#"domain_settings":domain_settings,
#"min_passwd_length":min_passwd_length,
#"max_passwd_length":max_passwd_length,
#"store_password_in_plain_text":settings.STORE_PASSWORD_IN_PLAIN_TEXT,
#"num_existing_users":num_users_under_domain,
#"languagemaps":iredutils.get_language_maps(),
#"password_policies":iredutils.get_password_policies(),
#"msg":form.get('msg')
"msg": "Create User API's GET method!"
})
def GET(self):
i = web.input()
return web.render('ldap/admin/create.html',
languagemaps=languages.getLanguageMaps(),
default_language=cfg.general.get('lang', 'en_US'),
min_passwd_length=cfg.general.get('min_passwd_length'),
max_passwd_length=cfg.general.get('max_passwd_length'),
msg=i.get('msg'),
)
def GET(self, profile_type, mail):
i = web.input()
self.mail = web.safestr(mail)
self.profile_type = web.safestr(profile_type)
if not iredutils.isEmail(self.mail):
raise web.seeother('/admins?msg=INVALID_MAIL')
if session.get('domainGlobalAdmin'
) is not True and session.get('username') != self.mail:
# Don't allow to view/update other admins' profile.
raise web.seeother(
'/profile/admin/general/%s?msg=PERMISSION_DENIED' %
session.get('username'))
adminLib = adminlib.Admin()
result = adminLib.profile(mail=self.mail)
if result[0] is True:
domainGlobalAdmin, profile = result[1], result[2]
# Get all domains.
self.allDomains = []
domainLib = domainlib.Domain()
resultOfAllDomains = domainLib.getAllDomains()
if resultOfAllDomains[0] is True:
self.allDomains = resultOfAllDomains[1]
# Get managed domains.
self.managedDomains = []
connutils = connUtils.Utils()
qr = connutils.getManagedDomains(
admin=self.mail,
domainNameOnly=True,
listedOnly=True,
)
if qr[0] is True:
self.managedDomains += qr[1]
return web.render(
'dbmail_mysql/admin/profile.html',
mail=self.mail,
profile_type=self.profile_type,
domainGlobalAdmin=domainGlobalAdmin,
profile=profile,
languagemaps=languages.getLanguageMaps(),
allDomains=self.allDomains,
managedDomains=self.managedDomains,
min_passwd_length=cfg.general.get('min_passwd_length', '0'),
max_passwd_length=cfg.general.get('max_passwd_length', '0'),
msg=i.get('msg'),
)
else:
raise web.seeother('/admins?msg=' + web.urlquote(result[1]))
def GET(self):
form = web.input()
domain = form_utils.get_domain_name(form=form)
return web.render('ldap/domain/create.html',
preferred_language=settings.default_language,
languagemaps=iredutils.get_language_maps(),
timezones=TIMEZONES,
domainName=domain,
msg=form.get('msg'))
