def delete_group(self, menu_item = None):
"""Delete the group selected in the group_treeview"""
if not self.__check_connection():
return None
group, t_iter = self.__get_selected_group()
# If nothing is selected we can return and do nothing.
# We should only notify the user that what he would like
# to do can not be done now.
if t_iter is None:
show_info_dialog(_("Select a group before asking for its deletion."))
return
# Users tend to delete many things they do not want to delete
if len(self.__connection.get_members(group)) == 0:
question = _("Really delete group <b>%s</b>?") % group
else:
question = _("Really delete the non empty group <b>%s</b>?" +
" This will lead to integrity problems.") % group
if not ask_question(question):
return
# Finally we delete the group
try:
self.__connection.delete_group(group)
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to delete group"))
return None
# and delete the group from the treeview
self.__group_store.remove(t_iter)
# Finally show the successful operation in the statusbar
self.statusbar_update(_("Group %s successfully deleted.") % group)
def group_properties(self, menu_item = None):
"""View selected group properties, such as members and
gidNumber"""
if not self.__check_connection():
return None
group, t_iter = self.__get_selected_group()
if t_iter is None:
show_info_dialog(_("Select a group to view its properties"))
# Get group_members, that are the only interesting property
# we can get from ldap
group_members = self.__connection.get_members(group)
# Get gid
gid = self.__group_store.get_gid(t_iter)
# Show info dialog
dialog_text = _("<b>Name:</b> %s\n") % group
dialog_text += "<b>Gid</b>: %s\n" % gid
if len(group_members) > 0:
dialog_text += _("<b>Members</b>: ")
dialog_text += ", ".join(group_members)
else:
dialog_text += _("This group is empty.")
# Show info dialog.
show_info_dialog(dialog_text)
def create_new_user_dialog(self, menu_item):
"""Create new user"""
if not self.__check_connection():
return None
new_user_dialog = lumNewUserDialog(self.__datapath, self.__connection)
try:
new_user_dialog.run()
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to accomplish operation"))
return None
if new_user_dialog.usermodel is not None:
if self.__check_connection():
new_user_dialog.usermodel.set_dn("uid=%s,%s" % (new_user_dialog.usermodel.get_username(),
self.__users_ou))
try:
self.__connection.add_user(new_user_dialog.usermodel)
except LumAlreadyExistsError:
show_error_dialog(_("User <b>%s</b> already exists in the ldap tree, " +
"cannot create one more") % new_user_dialog.usermodel.get_username())
return None
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to create the user"))
return None
self.statusbar_update(_("User %s created correctly.") % new_user_dialog.usermodel.get_username())
# Reload user list because the dialog may have created a new group
# and then pushing the user will not update the group list too
self.reload_user_list()
def menu():
"""First menu shown when add-on menu is requested"""
if checkSettings() == False:
return
options = (_(201), watchlist_menu), (_(202), recommendation_menu), (_(203), trending_menu), (_(204), sync_clean_menu)
_generate_menu(_(200), options)
def edit_user(self, menu_item = None):
"""Edit selected user"""
usermodel, t_iter = self.__get_selected_user()
if t_iter is None:
show_info_dialog(_("Select a user to modify"))
return
# Create the dialog making a copy of the old usermodel
# so we can check the difference after modification
old_user = UserModel(usermodel)
dialog = lumEditUserDialog(self.__datapath, usermodel, self.__group_store)
new_usermodel = dialog.run()
if (new_usermodel is not None):
try:
self.__connection.modify_user(old_user, new_usermodel)
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to edit user"))
return None
self.statusbar_update(_("User %s successfully modified") % new_usermodel.get_username())
# TODO: Reload only selected user
self.reload_user_list()
def main():
if ADDON.getSetting('EraseCache') == 'true':
try:
urlcache.URLCache(ADDON_DATA_PATH).erase()
finally:
ADDON.setSetting('EraseCache', 'false')#@UndefinedVariable
if not API_KEY:
raise Exception(_("No API Key."), _("Enter your Met Office API Key under settings."))
properties.observation()
properties.daily()
properties.threehourly()
WINDOW.setProperty('WeatherProvider', ADDON.getAddonInfo('name'))#@UndefinedVariable
WINDOW.setProperty('WeatherProviderLogo', ADDON_BANNER_PATH)#@UndefinedVariable
WINDOW.setProperty('ObservationLocation', ADDON.getSetting('ObservationLocation'))#@UndefinedVariable
WINDOW.setProperty('Current.Location', ADDON.getSetting('ForecastLocation'))#@UndefinedVariable
WINDOW.setProperty('ForecastLocation', ADDON.getSetting('ForecastLocation'))#@UndefinedVariable
WINDOW.setProperty('RegionalLocation', ADDON.getSetting('RegionalLocation'))#@UndefinedVariable
WINDOW.setProperty('Location1', ADDON.getSetting('ForecastLocation'))#@UndefinedVariable
WINDOW.setProperty('Locations', '1')#@UndefinedVariable
#Explicitly set unused flags to false, so there are no unusual side
#effects/residual data when moving from another weather provider.
WINDOW.setProperty('36Hour.IsFetched', '')#@UndefinedVariable
WINDOW.setProperty('Weekend.IsFetched', '')#@UndefinedVariable
WINDOW.setProperty('Map.IsFetched', '')#@UndefinedVariable
WINDOW.setProperty('Today.Sunrise', '')#@UndefinedVariable
WINDOW.setProperty('Today.Sunset', '')#@UndefinedVariable
WINDOW.setProperty('Weather.CurrentView', '')#@UndefinedVariable
def connect(self, menu_item = None):
"""Connect to server"""
# Determine which server to connect to
connect_dialog = lumConnectDialog(self.__datapath, self.__configuration)
uri, bind_dn, base_dn, users_ou, groups_ou = connect_dialog.run()
# Update internal information
self.__uri = uri
self.__bind_dn = bind_dn
self.__base_dn = base_dn
self.__users_ou = users_ou
self.__groups_ou = groups_ou
if uri is None:
return
# Add base_dn if necessary
if not self.__bind_dn.endswith(self.__base_dn): self.__bind_dn += ",%s" % self.__base_dn
if not self.__users_ou.endswith(self.__base_dn): self.__users_ou += ",%s" % self.__base_dn
if not self.__groups_ou.endswith(self.__base_dn): self.__groups_ou += ",%s" % self.__base_dn
# Get password from keyring
password = self.ask_password()
# Notify user of connection
self.statusbar_update(_("Connecting to %s.") % uri)
self.__connection = Connection(uri = self.__uri, bind_dn = self.__bind_dn,
password = password,
base_dn = self.__base_dn, users_ou = self.__users_ou,
groups_ou = self.__groups_ou)
self.__connection.connect("missing-ou", self.missing_ou_cb)
self.__connection.connect("connection-completed", self.connection_completed_cb)
# Try to connect to the specified server
try:
self.__connection.start()
except LumError:
# If we can't, maybe password is wrong, so ask it again
self.forget_password()
password = self.ask_password()
# and retry the connection. But if we fail even this time, then
# abort
try:
self.__connection.set_password(password)
self.__connection.start()
except:
# You had two opportunities, and both are gone.
show_error_dialog(
_("Error while connecting to the server, check your credentials and your connectivity"))
self.__connection = None
self.statusbar_update(_("Connection failed."))
def clean_movies(daemon=False):
"""Cleans trakt.tv movie database.
Checks if trakt contains any movies that the xbmc database doesn't and if any
are found unlibraries them on trakt.
"""
if not daemon:
progress = xbmcgui.DialogProgress()
progress.create(_(200), _(171))
trakt_movies = utilities.traktMovieListByImdbID(utilities.getMoviesFromTrakt())
xbmc_movies = utilities.xbmcMovieListByImdbID(utilities.getMoviesFromXBMC())
clean_list = []
index = 0
length = len(trakt_movies)
for imdbid in trakt_movies:
if not daemon:
index += 1
progress.update(int(float(index)/length*100), _(171))
if imdbid not in xbmc_movies:
clean_list.append({'imdb_id': imdbid, 'title': trakt_movies[imdbid]['title'], 'year': trakt_movies[imdbid]['year']})
if len(clean_list) > 0:
utilities.traktJsonRequest('POST', '/movie/unlibrary/%%API_KEY%%', {'movies': clean_list})
if not daemon:
progress.close()
def main():
if ADDON.getSetting('EraseCache') == 'true':
try:
urlcache.URLCache(ADDON_DATA_PATH).erase()
finally:
ADDON.setSetting('EraseCache', 'false')#@UndefinedVariable
if not API_KEY:
raise Exception(_("No API Key."), _("Enter your Met Office API Key under settings."))
if len(sys.argv) > 1 and sys.argv[1].isdigit():
properties.observation()
if not CURRENT_VIEW:
properties.daily()
elif CURRENT_VIEW == '3hourly':
properties.threehourly()
elif CURRENT_VIEW == 'forecastmap':
properties.forecastlayer()
elif CURRENT_VIEW == 'observationmap':
properties.observationlayer()
elif CURRENT_VIEW == 'text':
properties.text()
WINDOW.setProperty('WeatherProvider', ADDON.getAddonInfo('name'))#@UndefinedVariable
WINDOW.setProperty('ObservationLocation', ADDON.getSetting('ObservationLocation'))#@UndefinedVariable
WINDOW.setProperty('ForecastLocation', ADDON.getSetting('ForecastLocation'))#@UndefinedVariable
WINDOW.setProperty('RegionalLocation', ADDON.getSetting('RegionalLocation'))#@UndefinedVariable
WINDOW.setProperty('Location1', ADDON.getSetting('ObservationLocation'))#@UndefinedVariable
WINDOW.setProperty('Locations', '1')#@UndefinedVariable
def main(location):
if not API_KEY:
raise Exception(_("No API Key."),
_("Enter your Met Office API Key under settings."))
KEYBOARD.doModal() #@UndefinedVariable
text = KEYBOARD.isConfirmed() and KEYBOARD.getText() #@UndefinedVariable
sitelist = getsitelist(location, text)
if sitelist == []:
DIALOG.ok(_("No Matches"),
_("No locations found containing") +
" {0}".format(text)) #@UndefinedVariable
utilities.log("No locations found containing '%s'" % text)
else:
display_list = [site['display'] for site in sitelist]
selected = DIALOG.select(_("Matching Sites"),
display_list) #@UndefinedVariable
if selected != -1:
ADDON.setSetting(location,
sitelist[selected]['name']) #@UndefinedVariable
ADDON.setSetting("%sID" % location,
sitelist[selected]['id']) #@UndefinedVariable
ADDON.setSetting(
"%sLatitude" % location,
str(sitelist[selected].get('latitude'))) #@UndefinedVariable
ADDON.setSetting(
"%sLongitude" % location,
str(sitelist[selected].get('longitude'))) #@UndefinedVariable
utilities.log(
"Setting '{location}' to '{name} ({distance})'".format(
location=location,
name=sitelist[selected]['name'].encode('utf-8'),
distance=sitelist[selected]['id']))
def __init__(self, datapath, configuration):
self.__configuration = configuration
self.__builder = create_builder("LumConnectDialog.ui")
self.__dialog = self.__builder.get_object("connect_dialog")
for renderer in ('uri_cellrenderer', 'bind_dn_cellrenderer', 'base_dn_cellrenderer',
'users_ou_cellrenderer', 'groups_ou_cellrenderer'):
self.__builder.get_object(renderer).set_property("editable", True)
signals = {
'on_connect_button_activate': self.on_connect_button_cb,
'on_add_button_activate': self.on_add_button_cb,
'on_uri_cellrenderer_edited': self.on_uri_edited,
'on_bind_dn_edited': self.on_bind_dn_edited,
'on_base_dn_edited': self.on_base_dn_edited,
'on_users_ou_edited': self.on_users_ou_edited,
'on_groups_ou_edited': self.on_groups_ou_edited,
'on_uri_cellrenderer_editing_started': self.on_uri_start_editing,
'on_remove_button_clicked': self.on_remove_button_cb,
# Activate
'on_treeview_row_activated': self.on_connect_button_cb,
}
self.__builder.connect_signals(signals)
image = gtk.Image()
image.set_from_file(os.path.join(datapath, "ui/server.png"))
self.__pixbuf = image.get_pixbuf()
self.__credentials = (None, None, None, None, None)
self.__old_uri = None
for uri in self.__configuration.sections():
if not self.__configuration.has_option(uri, "bind_dn"):
bind_dn = _("Insert bind dn")
else:
bind_dn = self.__configuration.get(uri, "bind_dn")
if self.__configuration.has_option(uri, "base_dn"):
base_dn = self.__configuration.get(uri, "base_dn")
else:
base_dn = _("Insert base dn")
if self.__configuration.has_option(uri, "users_ou"):
users_ou = self.__configuration.get(uri, "users_ou")
else:
users_ou = _("Insert users organizational unit")
if self.__configuration.has_option(uri, "groups_ou"):
groups_ou = self.__configuration.get(uri, "groups_ou")
else:
groups_ou = _("Insert groups organizational unit")
self.__builder.get_object("server_store").append((self.__pixbuf, uri, bind_dn,
base_dn, users_ou, groups_ou))
self.__dialog.set_title(_("Connection to LDAP server"))
def __init__(self, model, parent):
"""
Create the new UserTreeView starting from
a UserStore
"""
gtk.TreeView.__init__(self)
self.set_model(model)
self.__model = model
self.__parent = parent
# Create popup menu
self.__popup_menu = lumUserTreeViewMenu(self.__parent)
self.connect("button-press-event", self.on_button_press_event)
# Load pixbuf
pixbuf_path = os.path.join(package_dir, "ui", "user.png")
pixbuf_image = gtk.Image()
pixbuf_image.set_from_file(pixbuf_path)
pixbuf = pixbuf_image.get_pixbuf()
# User image column
renderer = gtk.CellRendererPixbuf()
renderer.set_property("pixbuf", pixbuf)
column = gtk.TreeViewColumn()
column.pack_start(renderer, True)
column.set_expand(False)
self.append_column(column)
# username column
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn()
column.pack_start(renderer)
column.set_title(_("User"))
column.add_attribute(renderer, "text", 0)
column.set_expand(True)
self.append_column(column)
# Name column
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn()
column.set_title(_("Name"))
column.pack_start(renderer)
column.add_attribute(renderer, "text", 1)
column.set_expand(True)
self.append_column(column)
# group column
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn()
column.pack_start(renderer)
column.set_title(_("Group"))
column.add_attribute(renderer, "text", 2)
column.set_expand(True)
self.append_column(column)
def missing_ou_cb(self, widget, missing_ou):
"""Callback to ask user if he/she wants to add
missing ous before continue"""
text = "\n".join(map(lambda x : "- <b>" + x + "</b>", missing_ou))
if ask_question(_("The following organizational units are missing in the database, add them?\n%s" % text)):
for ou in missing_ou:
self.__connection.add_ou(ou, True)
else:
show_info_dialog(_("You will not be able to perform any operation without these OUs"))
self.disconnect()
def run(self):
"""Run dialog"""
# Check if the user says "save"...
if self.__window.run() == 1:
# And then retrieve data
username = self.__builder.get_object("username_entry").get_text()
givenName = self.__builder.get_object("givenName_entry").get_text()
sn = self.__builder.get_object("sn_entry").get_text()
home = self.__builder.get_object("home_entry").get_text()
shell = self.__builder.get_object("shell_entry").get_text()
email = self.__builder.get_object("email_entry").get_text()
# Set uid to 0 so ldap_protocol will autodetermine the first free uid
# when creating the user
uid = 0
group = self.__builder.get_object("group_entry").get_text()
gid = self.__connection.gid_from_group(group)
# Check if this is an existent user
if self.__connection.is_present("uid=%s" % username):
show_error_dialog(_("User %s is present, not overwriting it!") % username)
self.__window.destroy()
return None
# Ask the user if he intended to create the group and destroy window
# before the call to the ldap module, that could raise an exception
# catched by our parent (i.e. lumApp)
if gid is None:
if ask_question(_("The group %s doesn't exists, create it now?") % group):
self.__window.destroy()
self.__connection.add_group(group)
gid = self.__connection.gid_from_group(group)
else:
self.__window.destroy()
return None
else:
self.__window.destroy()
# Fill UserModel
self.usermodel = UserModel()
self.usermodel.set_username(username)
self.usermodel.set_gid(gid)
self.usermodel.set_surname(sn)
self.usermodel.set_given_name(givenName)
self.usermodel.set_home(home)
self.usermodel.set_shell(shell)
self.usermodel.set_email(email)
else:
self.__window.destroy()
def __check_connection(self):
if self.__connection is None:
if ask_question(_("Not connected to any LDAP server, connect now?")):
self.connect ()
else:
return False
if self.__connection is not None:
return True
else:
show_error_dialog(_("Error while connecting to LDAP server, aborting operation."))
return False
def watchlist_movies():
"""Create movie watchlist window"""
movies = utilities.getWatchlistMoviesFromTrakt()
if movies == None: # movies = None => there was an error
return # error already displayed in utilities.py
if len(movies) == 0:
xbmcgui.Dialog().ok(_(200), _(134))
return
_create_window('watchlist', movies, _WINDOW_TYPE_MOVIES)
def watchlist_tv():
"""Create TV show watchlist window"""
tvshows = utilities.getWatchlistTVShowsFromTrakt()
if tvshows == None: # tvshows = None => there was an error
return # error already displayed in utilities.py
if len(tvshows) == 0:
xbmcgui.Dialog().ok(_(200), _(135))
return
_create_window('watchlist', tvshows, _WINDOW_TYPE_TV)
def sync_movies(daemon=False):
"""Sync playcounts and collection status between trakt and xbmc.
Scans XBMC and trakt and updates the play count of each movie in both the xbmc
and trakt libraries based on which is higher. If the movie exists in xbmc
but is not collected in trakt it is set as collected too.
"""
if not daemon:
progress = xbmcgui.DialogProgress()
progress.create(_(200), _(172))
# Generate list of movies keyed with their imdb id
trakt_movies = utilities.traktMovieListByImdbID(utilities.getMoviesFromTrakt())
xbmc_movies = utilities.xbmcMovieListByImdbID(utilities.getMoviesFromXBMC())
xbmc_playcount_update = []
trakt_playcount_update = []
trakt_collection_update = []
for imdbid in xbmc_movies:
if imdbid not in trakt_movies:
trakt_collection_update.append({'imdb_id': imdbid, 'title': xbmc_movies[imdbid]['title'], 'year': xbmc_movies[imdbid]['year']})
if xbmc_movies[imdbid]['playcount'] > 0:
trakt_playcount_update.append({'imdb_id': imdbid, 'title': xbmc_movies[imdbid]['title'], 'year': xbmc_movies[imdbid]['year'], 'plays': xbmc_movies[imdbid]['playcount'], 'last_played': xbmc_movies[imdbid]['lastplayed']})
continue
if xbmc_movies[imdbid]['playcount'] > trakt_movies[imdbid]['plays']:
trakt_playcount_update.append({'imdb_id': imdbid, 'title': xbmc_movies[imdbid]['title'], 'year': xbmc_movies[imdbid]['year'], 'plays': xbmc_movies[imdbid]['playcount'], 'last_played': xbmc_movies[imdbid]['lastplayed']})
elif xbmc_movies[imdbid]['playcount'] < trakt_movies[imdbid]['plays']:
xbmc_playcount_update.append((xbmc_movies[imdbid]['movieid'], trakt_movies[imdbid]['plays'], imdbid))
if not daemon:
progress.update(0, _(173))
if len(trakt_collection_update) > 0:
utilities.traktJsonRequest('POST', '/movie/library/%%API_KEY%%', {'movies': trakt_collection_update})
if len(trakt_playcount_update) > 0:
utilities.setMoviesSeenOnTrakt(trakt_playcount_update)
if len(xbmc_playcount_update) > 0:
if not daemon:
_update_xbmc_movie_playcounts(xbmc_playcount_update, progress, daemon)
else:
_update_xbmc_movie_playcounts(xbmc_playcount_update, None, True)
if not daemon:
progress.close()
def recommended_tv():
"""Create recommended shows window"""
tvshows = utilities.getRecommendedTVShowsFromTrakt()
if tvshows == None: # tvshows = None => there was an error
return # error already displayed in utilities.py
if len(tvshows) == 0:
xbmcgui.Dialog().ok(_(200), _(121))
return
for tvshow in tvshows:
tvshow['watchlist'] = tvshow['in_watchlist']
_create_window('recommended', tvshows, _WINDOW_TYPE_TV)
def disconnect(self, menu_item = None):
self.clear_user_list()
self.clear_group_list()
self.__connection = None
if self.__uri is not None:
self.statusbar_update(_("Disconnected from %s") % self.__uri)
self.__uri = None
def _update_xbmc_movie_playcounts(playcount_list, progress, daemon):
"""Updates playcounts from the list passed to it and updates the progress bar"""
count = len(playcount_list)
index = 0
if not daemon:
progress.update(0, _(170))
for movieid, playcount, imdbid in playcount_list:
utilities.setXBMCMoviePlaycount(movieid, playcount, imdbid)
index += 1
if not daemon:
if progress.iscanceled():
return
progress.update(int(float(index)/count*100), _(170))
def sync_tv(daemon=False):
"""Sync playcounts and collection status between trakt and xbmc.
Scans XBMC and trakt and updates the playcount of each episode in both the
xbmc and trakt libraries. If the episode exists in xbmc but is not collected
on trakt it is also set as collected on trakt.
"""
collect_episodes = []
watch_episodes = []
if not daemon:
progress = xbmcgui.DialogProgress()
progress.create(_(200), _(174))
xbmc_shows = _parse_xbmc_structure()
trakt_shows = _parse_trakt_structure()
index = 0
length = len(xbmc_shows)
for tvdbid in xbmc_shows:
if not daemon:
if progress.iscanceled():
return
progress.update(int(float(index)/length*100), _(175))
index += 1
if tvdbid not in trakt_shows:
collect_trakt_episodes, watch_trakt_episodes = _generate_show_not_on_trakt(xbmc_shows, tvdbid)
else:
collect_trakt_episodes, watch_trakt_episodes, watched_xbmc_episodes = _generate_show_on_trakt(xbmc_shows, trakt_shows, tvdbid)
_update_xbmc_episode_playcounts(watched_xbmc_episodes)
if collect_trakt_episodes:
collect_episodes.append(collect_trakt_episodes)
if watch_trakt_episodes:
watch_episodes.append(watch_trakt_episodes)
if not daemon:
progress.update(0, _(176))
_send_episodes_to_trakt(collect_episodes, watch_episodes)
if not daemon:
progress.close()
def __init__(self, parent):
gtk.Menu.__init__(self)
# Save internal data
self.__parent = parent
self.__delete_button = gtk.MenuItem(_("Delete"))
self.__properties_button = gtk.MenuItem(_("Properties"))
self.__edit_button = gtk.MenuItem(_("Edit members"))
for it in (self.__delete_button, self.__properties_button,
self.__edit_button):
self.append(it)
it.show()
self.__delete_button.connect("activate", self.delete_cb)
self.__properties_button.connect("activate", self.properties_cb)
self.__edit_button.connect("activate", self.edit_button_cb)
async def extensions(self, ctx):
# create output embeds
embed_loaded = discord.Embed(colour=discord.Colour.green(),
title=_("loaded extensions"))
embed_unloaded = discord.Embed(colour=discord.Colour.red(),
title=_("unloaded extensions"))
# get loaded extension
loaded_extensions = Extension.loaded()
if loaded_extensions:
for extension in loaded_extensions:
embed_loaded.add_field(name=extension.name,
value=extension.description,
inline=False)
else:
embed_loaded.add_field(name=_("no extensions"),
value=_("no extensions loaded"),
inline=False)
# get unloaded extension
unloaded_extensions = Extension.unloaded()
if unloaded_extensions:
for extension in unloaded_extensions:
embed_unloaded.add_field(name=extension.name,
value=_(extension.description),
inline=False)
else:
embed_unloaded.add_field(name=_("no extensions"),
value=_("no extensions unloaded"),
inline=False)
# send embeds
await ctx.send(embed=embed_loaded)
await ctx.send(embed=embed_unloaded)
def verify(user_id: UUID):
user = User.get(user_id=str(user_id))
if user is None:
return {'error': 'invalid user ID'}, 404
user.verified_at = datetime.now()
db_session.commit()
self.loop.run_until_complete(self.add_role(user.discord_id))
return """
<html lang="{language}">
<head>
<title>Fachschaft 5 | Verified!</title>
</head>
<body>
<p style='margin: auto;'>{content}</p>
</body>
</html>
""".format(language=_('language'),
content=_('you can close this window now'))
async def verify(self, ctx: Context, username: str = None):
if ctx.channel.type != ChannelType.private:
return await ctx.send(embed=Embed(
color=Color.gold(),
title=_('unsupported'),
description=_('only supported in dm'),
))
if username is None or username == '':
return await ctx.send(embed=Embed(
color=Color.red(),
title=_('Errors'),
description=_('provide username'),
))
discord_id = ctx.author.id
if User.exists(discord_id=discord_id):
user = User.get(discord_id=discord_id)
return await ctx.send(embed=Embed(
color=Color.gold(),
description=_('user already verified {mail} {username}').format(
mail=user.mail_address,
username=username,
),
)) if user.verified_at is not None else await ctx.send(embed=Embed(
color=Color.gold(),
description=_('already sent verification {mail} {username}').format(
mail=user.mail_address,
username=username,
),
))
await ctx.send(embed=Embed(
color=Color.green(),
description=_('sent verification mail {username}').format(username=username),
))
mail_address = f'{username}@alumni.fh-aachen.de'
user_id = str(uuid4())
db_session.add(User(
id=user_id,
discord_id=discord_id,
mail_address=mail_address,
))
db_session.commit()
message = f"""From: No-Reply <{self.config['verification']['mail_user']}>
To: {ctx.author.name} <{mail_address}>
Subject: Fachschaft 5 Discord Verification
Hello {ctx.author.name},
Visit this link to verify your Discord account:
{self.config['verification']['host']}:{self.config['verification']['port']}{self.config['verification']['endpoint']}/{user_id}
Best regards
"""
try:
client = smtplib.SMTP_SSL(self.config['verification']['mail_server'], 465)
client.login(self.config['verification']['mail_user'], self.config['verification']['mail_pass'])
client.sendmail(self.config['verification']['mail_user'], [mail_address], message)
except smtplib.SMTPException as err:
logging.error(str(err))
def trending_tv():
"""Create trending shows window"""
tvshows = utilities.getTrendingTVShowsFromTrakt()
watchlist = utilities.traktShowListByTvdbID(utilities.getWatchlistTVShowsFromTrakt())
if tvshows == None: # tvshows = None => there was an error
return # error already displayed in utilities.py
if len(tvshows) == 0:
xbmcgui.Dialog().ok(_(200), _(161))
return
for tvshow in tvshows:
if tvshow['imdb_id'] in watchlist:
tvshow['watchlist'] = True
else:
tvshow['watchlist'] = False
_create_window('trending', tvshows, _WINDOW_TYPE_TV)
def main():
if ADDON.getSetting('EraseCache') == 'true':
try:
urlcache.URLCache(ADDON_DATA_PATH).erase()
finally:
ADDON.setSetting('EraseCache', 'false') #@UndefinedVariable
if not API_KEY:
raise Exception(_("No API Key."),
_("Enter your Met Office API Key under settings."))
properties.observation()
properties.daily()
properties.threehourly()
WINDOW.setProperty('WeatherProvider',
ADDON.getAddonInfo('name')) #@UndefinedVariable
WINDOW.setProperty('WeatherProviderLogo',
ADDON_BANNER_PATH) #@UndefinedVariable
WINDOW.setProperty(
'ObservationLocation',
ADDON.getSetting('ObservationLocation')) #@UndefinedVariable
WINDOW.setProperty(
'Current.Location',
ADDON.getSetting('ForecastLocation')) #@UndefinedVariable
WINDOW.setProperty(
'ForecastLocation',
ADDON.getSetting('ForecastLocation')) #@UndefinedVariable
WINDOW.setProperty(
'RegionalLocation',
ADDON.getSetting('RegionalLocation')) #@UndefinedVariable
WINDOW.setProperty(
'Location1', ADDON.getSetting('ForecastLocation')) #@UndefinedVariable
WINDOW.setProperty('Locations', '1') #@UndefinedVariable
#Explicitly set unused flags to false, so there are no unusual side
#effects/residual data when moving from another weather provider.
WINDOW.setProperty('36Hour.IsFetched', '') #@UndefinedVariable
WINDOW.setProperty('Weekend.IsFetched', '') #@UndefinedVariable
WINDOW.setProperty('Map.IsFetched', '') #@UndefinedVariable
WINDOW.setProperty('Today.Sunrise', '') #@UndefinedVariable
WINDOW.setProperty('Today.Sunset', '') #@UndefinedVariable
WINDOW.setProperty('Weather.CurrentView', '') #@UndefinedVariable
def trending_movies():
"""Create tending movies window"""
movies = utilities.getTrendingMoviesFromTrakt()
watchlist = utilities.traktMovieListByImdbID(utilities.getWatchlistMoviesFromTrakt())
if movies == None: # movies = None => there was an error
return # error already displayed in utilities.py
if len(movies) == 0:
xbmcgui.Dialog().ok(_(200), _(160))
return
for movie in movies:
if movie['imdb_id'] in watchlist:
movie['watchlist'] = True
else:
movie['watchlist'] = False
_create_window('trending', movies, _WINDOW_TYPE_MOVIES)
def __init__(self, parent):
gtk.Menu.__init__(self)
self.__parent = parent
self.__edit_button = gtk.MenuItem(_("Edit"))
self.__del_button = gtk.MenuItem(_("Delete"))
self.__pwd_button = gtk.MenuItem(_("Change password"))
self.append (self.__edit_button)
self.append (self.__del_button)
self.append (self.__pwd_button)
self.__edit_button.show()
self.__del_button.show()
self.__pwd_button.show()
self.__edit_button.connect("activate", self.edit)
self.__del_button.connect("activate", self.delete)
self.__pwd_button.connect("activate", self.change_password)
self.username = None
def on_download_clicked(self):
""" Read GUI widgets """
# Client instance attributes
client_opts = {key: self.read_widget(getattr(self, key))
for key in OFXClient.defaults.keys()}
client = OFXClient(**client_opts)
# Statement options
stmt_options = {}
for option in OFXClient.stmt_defaults.keys():
widget = getattr(self, option, None)
stmt_options[option] = self.read_widget(widget)
# Account numbers
accts = {key: self.read_widget(getattr(self, key))
for key in OFXClient.acct_defaults.keys()}
acct_tuple = client.parse_account_strings(**accts)
client.request_all(*acct_tuple, **stmt_options)
user = self.read_widget(self.user)
if self.dry_run.isChecked():
request = client.write_request(user, 'TOPSECRET')
msg = QtGui.QMessageBox(self, windowTitle='OFX Request',
text='OFX request prepared for %s' % self.fi_name)
msg.setDetailedText(request)
msg.exec_()
return
password = self.get_password(user)
if self.profile.isChecked():
client.request_profile(user=user, password=password)
archive_file = 'profile.ofx'
else:
client.write_request(user=user, password=password)
# FIXME - ought to use DTCLIENT from the SONRQ here
import datetime
archive_file = '%s.ofx' % datetime.datetime.now().strftime('%Y%m%d%H%M%S')
response = client.download(user, password)
clicked = self.popup_response(response.read())
if clicked == QtGui.QMessageBox.Save:
archive_dir = _(os.path.join(self.config.get('global', 'dir'), self.fi_name))
if archive_dir == '':
return
if not os.path.exists(archive_dir):
os.makedirs(archive_dir)
archive_path = os.path.join(archive_dir, archive_file)
archive_path = QtGui.QFileDialog.getSaveFileName(self,
directory=archive_path,
filter='OFX files (*.ofx);;All files (*)')
with open(archive_path, 'w') as archive:
archive.write(response.read())
def main(location):
if not API_KEY:
raise Exception(_("No API Key."), _("Enter your Met Office API Key under settings."))
KEYBOARD.doModal()#@UndefinedVariable
text= KEYBOARD.isConfirmed() and KEYBOARD.getText()#@UndefinedVariable
sitelist = getsitelist(location, text)
if sitelist == []:
DIALOG.ok(_("No Matches"), _("No locations found containing")+" {0}".format(text))#@UndefinedVariable
utilities.log("No locations found containing '%s'" % text)
else:
display_list = [site['display'] for site in sitelist]
selected = DIALOG.select(_("Matching Sites"), display_list)#@UndefinedVariable
if selected != -1:
ADDON.setSetting(location, sitelist[selected]['name'])#@UndefinedVariable
ADDON.setSetting("%sID" % location, sitelist[selected]['id'])#@UndefinedVariable
ADDON.setSetting("%sLatitude" % location, str(sitelist[selected].get('latitude')))#@UndefinedVariable
ADDON.setSetting("%sLongitude" % location, str(sitelist[selected].get('longitude')))#@UndefinedVariable
utilities.log("Setting '{location}' to '{name} ({distance})'".format(location=location,
name=sitelist[selected]['name'].encode('utf-8'),
distance=sitelist[selected]['id']))
def new_user(self, button):
"""Create a new empty row"""
store = self.__builder.get_object("members_store")
it = store.append((_("Insert uid here"),))
# Get path
path = store.get_path(it)
# Start editing the new entry
treeview = self.__builder.get_object("members_treeview")
column = self.__builder.get_object("members_column")
treeview.set_cursor(path, column, True)
def new_group(self, menu_item = None):
"""Create a new group catching the callback from menu"""
if not self.__check_connection():
return None
new_group_dialog = lumNewGroupDialog(self.__datapath,
self.__connection)
group_name, gid = new_group_dialog.run()
if group_name is not None:
try:
self.__connection.add_group(group_name, gid)
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to create group"))
return None
except LumAlreadyExistsError:
show_error_dialog(_("Group <b>%s</b> already exists in the database," +
" cannot add one more.") % group_name)
return None
self.__group_store.append(gid, group_name)
self.statusbar_update(_("Group %s successfully created.") % group_name)
def main():
if ADDON.getSetting('EraseCache') == 'true':
try:
urlcache.URLCache(ADDON_DATA_PATH).erase()
finally:
ADDON.setSetting('EraseCache', 'false') #@UndefinedVariable
if not API_KEY:
raise Exception(_("No API Key."),
_("Enter your Met Office API Key under settings."))
if len(sys.argv) > 1 and sys.argv[1].isdigit():
properties.observation()
if not CURRENT_VIEW:
properties.daily()
elif CURRENT_VIEW == '3hourly':
properties.threehourly()
elif CURRENT_VIEW == 'forecastmap':
properties.forecastlayer()
elif CURRENT_VIEW == 'observationmap':
properties.observationlayer()
elif CURRENT_VIEW == 'text':
properties.text()
WINDOW.setProperty('WeatherProvider',
ADDON.getAddonInfo('name')) #@UndefinedVariable
WINDOW.setProperty(
'ObservationLocation',
ADDON.getSetting('ObservationLocation')) #@UndefinedVariable
WINDOW.setProperty(
'ForecastLocation',
ADDON.getSetting('ForecastLocation')) #@UndefinedVariable
WINDOW.setProperty(
'RegionalLocation',
ADDON.getSetting('RegionalLocation')) #@UndefinedVariable
WINDOW.setProperty(
'Location1',
ADDON.getSetting('ObservationLocation')) #@UndefinedVariable
WINDOW.setProperty('Locations', '1') #@UndefinedVariable
def change_password(self, menu_item = None):
"""Change password of selected user"""
usermodel, t_iter = self.__get_selected_user()
if t_iter is None:
show_info_dialog(_("You need to select a user to change its password"))
return
password_dialog = lumChangeUserPasswordDialog(self.__datapath, usermodel.get_username())
new_password = password_dialog.run()
if new_password is None:
return False
else:
try:
self.__connection.change_password(usermodel.get_username(), new_password)
except LumInsufficientPermissionsError:
show_error_dialog(_("Insufficient permissions to change user password"))
return False
else:
self.statusbar_update(_("Password of user %s changed succesfully") % usermodel.get_username())
return True
async def load(self, ctx, extension: str):
# prepare extension string
extension = extension.lower()
# check if extension is not on blacklist
if extension not in self.extension_blacklist:
# try to load extension
try:
# load extension
self.bot.load_extension(self.extensions_dir + extension)
# check extension in database and update/set
db_extension = Extension.get(extension)
if db_extension:
db_extension.isLoaded = True
else:
extension_object = Extension(extension, True)
db_session.add(extension_object)
# commit update
db_session.commit()
except Exception as e:
# create output embed
embed = discord.Embed(
colour=discord.Colour.red(),
title=_("extension not loaded, {extension}").format(
extension=extension))
embed.add_field(name=_("Errors"),
value="{}: {}".format(type(e).__name__, e),
inline=False)
# send embed
await ctx.send(embed=embed)
else:
# create output embed
embed = discord.Embed(
colour=discord.Colour.green(),
title=_("extension successfully loaded, {extension}"
).format(extension=extension))
# send embed
await ctx.send(embed=embed)
else:
# create output embed
embed = discord.Embed(
colour=discord.Colour.red(),
title=_("extension not loaded, {extension}").format(
extension=extension))
embed.add_field(name=_("Errors"),
value=_("extension blacklist"),
inline=False)
# send embed
await ctx.send(embed=embed)
async def reload(self, ctx, extension: str):
# prepare extension string
extension = extension.lower()
# check if extension is not on blacklist
if extension not in self.extension_blacklist:
# try to reload extension
try:
self.bot.unload_extension(self.extensions_dir + extension)
self.bot.load_extension(self.extensions_dir + extension)
except Exception as e:
# create output embed
embed = discord.Embed(
colour=discord.Colour.red(),
title=_("extension not reloaded, {extension}").format(
extension=extension))
embed.add_field(name=_("Errors"),
value="{}: {}".format(type(e).__name__, e),
inline=False)
# send embed
await ctx.send(embed=embed)
else:
# create output embed
embed = discord.Embed(
colour=discord.Colour.green(),
title=_("extension successfully reloaded, {extension}"
).format(extension=extension))
# send embed
await ctx.send(embed=embed)
else:
# create output embed
embed = discord.Embed(
colour=discord.Colour.red(),
title=_("extension not reloaded, {extension}").format(
extension=extension))
embed.add_field(name=_("Errors"),
value=_("extension blacklist"),
inline=False)
# send embed
await ctx.send(embed=embed)
async def dice(self, ctx):
await ctx.send(
_("dice role, {mention}, {dice}").format(
mention=ctx.author.mention, dice=random.randint(1, 6)))
