def openLoginDialog(self):
self.login_dialog = LoginDialog(self.main_window)
self.login_dialog.exec_()
if self.login_dialog.result():
username = str(self.login_dialog.username_line.text())
password = str(self.login_dialog.password_line.text())
if username and password:
remember = self.login_dialog.remember_checkbox.isChecked()
self.handleLoginData(username, password, remember)
def do_selected(self):
if not self.activated:
self.activated = True
self.shell = self.props.shell
self.plugin = self.props.plugin
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.entry_type = self.props.entry_type
if self.doubanfm == None:
if self.login_dialog == None:
self.login_dialog = LoginDialog(self.shell)
self.login_dialog.connect('login-completed',
self.on_login_completed)
self.login_dialog.login()
self.plugin.show_sidebar(True)
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
if not sys.path.__contains__(self.plugin_dir): sys.path.append(self.plugin_dir)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'SLTRPlugin_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = LoginDialog()
self.dlg2 = SolaPluginDialog()
self.dlg3 = CreateFormDialog()
# Declare instance attributes
self.actions = []
self.fid_array = []
self.user = ''
self.fid = 0
self.parcel_id = ''
self.transactionId = ''
configParser = ConfigParser.RawConfigParser()
configfilepath = self.plugin_dir+os.path.sep+'config.ini'
configParser.read(configfilepath)
self.db_hostName = configParser.get('settings', 'Hostname') # '192.168.0.1'
self.db_databaseName = configParser.get('settings', 'DatabaseName') # 'sltrportal'
self.db_UserName = configParser.get('settings', 'Username') # 'postgres'
self.db_password = configParser.get('settings', 'Password') # 'sola450'
self.db_Port = int(configParser.get('settings', 'Port')) # 5432
self.url = configParser.get('settings',
'Url') # 'url=http://192.168.0.1:8080/geoserver/SLTR/wms?service=WMS&version=1.1.0&request=GetMap&layers=kano&styles=&crs=EPSG:26332&format=image/jpeg'
print self.db_hostName
print self.db_databaseName
print self.db_UserName
print self.db_password
print self.url
self.menu = self.tr(u'&SLTRPlugin')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'SLTRPlugin')
self.toolbar.setObjectName(u'SLTRPlugin')
def openLoginDialog(self):
self.login_dialog = LoginDialog(self.main_window)
self.login_dialog.exec_()
if self.login_dialog.result():
username = str(self.login_dialog.username_line.text())
password = str(self.login_dialog.password_line.text())
if username and password:
remember = self.login_dialog.remember_checkbox.isChecked()
self.handleLoginData(username, password, remember)
def main():
app = QApplication(sys.argv)
if len(sys.argv) > 1:
config.app_dir = sys.argv[1]
if os.path.exists(config.config_path):
# User is already registered
config.load()
dialog = LoginDialog()
if dialog.exec() != 1:
print("Error: failed to login user\n"
"Will exit the program!",
file=sys.stderr)
sys.exit(1)
# Get registered client
client = dialog.client
else:
# User needs to register first
# Present the user with the register dialog
dialog = RegisterDialog()
if dialog.exec() != 1:
print("Error: failed to register user\n"
"Will exit the program!",
file=sys.stderr)
sys.exit(1)
# Get registered client
client = dialog.client
window = MainWindow(client)
window.refresh()
window.adjustSize()
window.show()
sys.exit(app.exec_())
def init_menu(parent):
parent.login = LoginDialog(parent)
parent.add_player.triggered.connect(parent.login.exec_)
parent.start_game.triggered.connect(parent.init_game)
parent.start_game.setDisabled(True)
parent.new_game.triggered.connect(lambda: new_game_func(parent))
parent.new_game.setDisabled(True)
parent.exit_game.triggered.connect(QApplication.exit)
parent.roll_dice.setDisabled(True)
def do_selected(self):
if not self.activated:
self.activated = True
self.shell = self.props.shell
self.plugin = self.props.plugin
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.entry_type = self.props.entry_type
if self.doubanfm == None:
if self.login_dialog == None:
self.login_dialog = LoginDialog(self.shell)
self.login_dialog.connect('login-completed', self.on_login_completed)
self.login_dialog.login()
self.plugin.show_sidebar(True)
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'LizardDownloader_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.login_dialog = LoginDialog()
self.import_dialog = LizardDownloaderDialog()
self.upload_points_dialog = UploadPointsDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&GGMN lizard integration')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'LizardDownloader')
self.toolbar.setObjectName(u'LizardDownloader')
# Stored username/password, will be set by the login dialog.
self.username = None
self.password = None
self.organisations = [] # Will be filled after logging in.
self.selected_organisation = None
self.start_date = datetime.date(1930, 1, 1)
self.end_date = datetime.date.today()
self.filename = None
self.custom_filename = None
self.custom_layer = None
self.already_uploaded = []
def main():
#you can change databasename at models.__init__
#status = False
#if SqlHandler.usesLite():
status = True #os.path.exists(getDBName())
app = QtGui.QApplication(sys.argv)
#try:
if not SqlHandler.initialize():
print(g_error_msg_dict['database_init'])
return
if LoginDialog().exec_() == QtGui.QDialog.Accepted:
vet_app = MainWindow()
Tabmanager.openTab(tabCreator=MainMenuTab)
vet_app.showMaximized()
sys.exit(app.exec_())
def login(self):
login, password, ok = LoginDialog.getCredentials(self)
if not ok:
return
if not login or not password:
QMessageBox.warning(self, 'Error', 'Empty username or password',
QMessageBox.Ok)
return
self.user = db.signin(login, password)
if self.user is None:
QMessageBox.critical(self, 'Error', 'Incorrect pasword',
QMessageBox.Ok)
return
tasks = db.readData(self.user)
model.update(tasks)
model.layoutChanged.emit()
self.refresh()
self.addButton.setEnabled(True)
self.saveButton.setEnabled(True)
class DoubanFMSource(RB.BrowserSource):
__gtype_name__ = 'DoubanFMSource'
object = GObject.property(type=GObject.Object)
def __init__(self):
RB.BrowserSource.__init__(self, name=SOURCE_NAME)
self.activated = False
self.db = None
self.doubanfm = None
self.songs_map = {}
self.songs = []
self.history = []
self.login_dialog = None
def do_selected(self):
if not self.activated:
self.activated = True
self.shell = self.props.shell
self.plugin = self.props.plugin
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.entry_type = self.props.entry_type
if self.doubanfm == None:
if self.login_dialog == None:
self.login_dialog = LoginDialog(self.shell)
self.login_dialog.connect('login-completed',
self.on_login_completed)
self.login_dialog.login()
self.plugin.show_sidebar(True)
def do_deselected(self):
self.plugin.show_sidebar(False)
def on_login_completed(self, dialog, doubanfm):
self.doubanfm = doubanfm
self.plugin.change_menu_item_state(True)
def set_channel(self, channel):
self.doubanfm.channel = channel
self.new_playlist()
def get_song_by_title(self, song_title):
return self.songs_map.get(song_title.decode('utf-8'), None)
def add_song(self, song):
entry = RB.RhythmDBEntry.new(self.db, self.entry_type, song.url)
self.db.entry_set(entry, RB.RhythmDBPropType.TITLE,
song.title.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ALBUM,
song.albumtitle.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ARTIST,
song.artist.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.DURATION, song.length)
if song.rating_avg:
self.db.entry_set(entry, RB.RhythmDBPropType.RATING,
song.rating_avg)
if song.kbps:
self.db.entry_set(entry, RB.RhythmDBPropType.BITRATE,
int(song.kbps.encode('utf-8')))
if song.company:
self.db.entry_set(entry, RB.RhythmDBPropType.GENRE,
song.company.encode('utf-8'))
if song.public_time:
date = datetime.date(int(song.public_time.encode('utf-8')), 1,
1).toordinal()
self.db.entry_set(entry, RB.RhythmDBPropType.DATE, date)
def reset_songs(self, songs):
for row in self.props.query_model:
self.db.entry_delete(row[0])
self.songs = songs
self.songs_map = {}
for song in self.songs:
self.songs_map[song.title] = song
self.add_song(song)
self.db.commit()
GLib.idle_add(self.start_playing)
def start_playing(self):
if self.player.get_playing_entry() == None:
self.player.set_playing_source(self)
self.player.do_next()
def new_playlist(self):
thread.start_new_thread(self.doubanfm.new_playlist,
(self.history, self.reset_songs))
def del_song(self, song):
sids = [each.sid for each in self.songs]
next = sids.index(song.sid) + 1
thread.start_new_thread(
self.doubanfm.del_song,
(song.sid, song.aid, sids[next:], self.reset_songs))
def fav_song(self, song):
thread.start_new_thread(self.doubanfm.fav_song, (song.sid, song.aid))
song.like = True
def unfav_song(self, song):
thread.start_new_thread(self.doubanfm.unfav_song, (song.sid, song.aid))
song.like = False
def skip_song(self, song):
thread.start_new_thread(
self.doubanfm.skip_song,
(song.sid, song.aid, self.history, self.reset_songs))
if (song.sid, 's') not in self.history:
self.history.insert(0, (song.sid, 's'))
if len(self.history) > 20:
self.history.pop()
def played_song(self, song):
thread.start_new_thread(self.doubanfm.played_song,
(song.sid, song.aid))
if (song.sid, 'p') not in self.history:
self.history.insert(0, (song.sid, 'p'))
if len(self.history) > 20:
self.history.pop()
def played_list(self, song):
thread.start_new_thread(self.doubanfm.played_list,
(song.sid, self.history, self.reset_songs))
# -*- coding: utf-8 -*-
# python的gui编程
# 主程序，先出现登录界面，登录成功则跳转到主界面
if __name__ == '__main__':
import sys
from login_dialog import LoginDialog
try:
from PyQt5.QtWidgets import QApplication
except ModuleNotFoundError as e:
# 执行时引入 pyqt5库失败时，则使用 pip指令安装
import os
print('本机未安装pyqt，正在安装 PyQt5 ...')
os.system(
'pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple --trusted-host pypi.tuna.tsinghua.edu.cn pyqt5'
)
app = QApplication(sys.argv)
login_dia = LoginDialog() # 实例化登录窗口
login_dia.show()
app.exec_()
from PyQt5.QtWidgets import QApplication
from login_dialog import LoginDialog
from main_window import MainWindow
import sip
import sys
sip.setapi("QString", 1)
if __name__ == "__main__":
a = QApplication(sys.argv)
a.setStyle("fusion")
loginDialog = LoginDialog()
isAuth = False
result = -1
# while not isAuth:
loginDialog.exec_()
# if result == loginDialog.Success or result == loginDialog.Rejected:
# isAuth = True
# else:
# isAuth = False
isAuth = loginDialog.Success
if isAuth == True:
w = MainWindow()
w.show()
a.exec_()
# exit(0)
class LizardDownloader:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'LizardDownloader_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.login_dialog = LoginDialog()
self.import_dialog = LizardDownloaderDialog()
self.upload_points_dialog = UploadPointsDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&GGMN lizard integration')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'LizardDownloader')
self.toolbar.setObjectName(u'LizardDownloader')
# Stored username/password, will be set by the login dialog.
self.username = None
self.password = None
self.organisations = [] # Will be filled after logging in.
self.selected_organisation = None
self.start_date = datetime.date(1930, 1, 1)
self.end_date = datetime.date.today()
self.filename = None
self.custom_filename = None
self.custom_layer = None
self.already_uploaded = []
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('LizardDownloader', message)
def add_action(self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/LizardDownloader/icon.png'
self.add_action(
icon_path,
text=self.tr(u'Log into Lizard'),
callback=self.run_login,
add_to_toolbar=False,
parent=self.iface.mainWindow())
self.add_action(
icon_path,
text=self.tr(u'Download from Lizard'),
callback=self.run_import,
add_to_toolbar=False,
parent=self.iface.mainWindow())
self.download_custom_points_action = self.add_action(
icon_path,
text=self.tr(u'Download custom points from Lizard'),
callback=self.run_custom_import,
enabled_flag=False,
add_to_toolbar=False,
parent=self.iface.mainWindow())
self.upload_custom_points_action = self.add_action(
icon_path,
text=self.tr(u'Upload custom points to Lizard'),
callback=self.run_upload,
add_to_toolbar=False,
enabled_flag=False,
parent=self.iface.mainWindow())
self.upload_raster_action = self.add_action(
icon_path,
text=self.tr(u'Upload interpolation raster to Lizard'),
callback=self.run_raster_upload,
enabled_flag=False,
add_to_toolbar=False,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&GGMN lizard integration'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def determine_organisations(self):
if not (self.username and self.password):
raise RuntimeError("Not logged in")
single_user_api = SingleUserInfo()
single_user_api.username = self.username
single_user_api.password = self.password
organisations_url = single_user_api.organisations_url()
organisations_url = organisations_url.rstrip('/')
organisations_api = Organisations()
organisations_api.username = self.username
organisations_api.password = self.password
organisations_api.base_url = organisations_url
return organisations_api.for_dialog()
def run_login(self):
"""Show login dialog if the user isn't logged in yet."""
# show the dialog
self.login_dialog.show()
ok_pressed = self.login_dialog.exec_()
if ok_pressed:
self.username = self.login_dialog.username.text()
self.password = self.login_dialog.password.text()
self.organisations = self.determine_organisations()
return ok_pressed
def run_import(self):
"""Run method that performs all the real work"""
if not (self.username and self.password):
ok_pressed = self.run_login()
if not ok_pressed:
# Then we don't want to do anything either!
return
# Set up the dialog. (Should perhaps be moved to the dialog class.)
self.import_dialog.organisationComboBox.clear()
for organisation in self.organisations:
self.import_dialog.organisationComboBox.addItem(
organisation['name'],
organisation['unique_id'])
if self.selected_organisation:
self.import_dialog.organisationComboBox.setCurrentIndex(
self.import_dialog.organisationComboBox.findData(
self.selected_organisation))
self.import_dialog.startDate.setDate(
QDate(self.start_date.year,
self.start_date.month,
self.start_date.day))
self.import_dialog.endDate.setDate(
QDate(self.end_date.year,
self.end_date.month,
self.end_date.day))
# show the dialog
self.import_dialog.show()
# Run the dialog event loop
result = self.import_dialog.exec_()
# See if OK was pressed
if result:
index = self.import_dialog.organisationComboBox.currentIndex()
self.selected_organisation = self.organisations[index]['unique_id']
# print("Selected org: %s" % self.selected_organisation)
self.start_date = self.import_dialog.startDate.date().toPyDate()
self.end_date = self.import_dialog.endDate.date().toPyDate()
start = self.start_date.strftime('%Y-%m-%dT00:00:00Z')
end = self.end_date.strftime('%Y-%m-%dT00:00:00Z')
gw_info = QGisLizardImporter(username=self.username,
password=self.password,
organisation_id=self.selected_organisation)
self.iface.messageBar().pushMessage(
"Lizard",
"Downloading data (can take up to a minute)...")
gw_info.download(
start=start,
end=end,
groundwater_type=GROUNDWATER_TYPE)
if gw_info.data:
if not self.filename:
# Take homedir as starting point
self.filename = os.path.expanduser('~')
self.filename = QFileDialog.getSaveFileName(
self.iface.mainWindow(),
self.tr("New shapefile to save downloaded data in"),
self.filename,
self.tr("Shape files (*.shp)"))
gw_info.data_to_shape(filename=self.filename,
overwrite=True)
gw_info.load_shape(self.filename)
self.download_custom_points_action.setDisabled(False)
self.upload_raster_action.setDisabled(False)
else:
def _split_url(url):
return '\n&'.join(url.split('&'))
msg = """
No data found for period and extent.
Technical debug info follows:
Username: {username}
Organisation ID: {organisation_id}
Start date: {start}
End date: {end}
Locations url: {locations_url}
len(locations): {locations_len}
Timeseries url: {timeseries_url}
len(timeseries): {timeseries_len}
""".format(username=self.username,
organisation_id=self.selected_organisation,
start=start,
end=end,
locations_url=_split_url(gw_info.groundwater.locs.url),
timeseries_url=_split_url(gw_info.groundwater.ts.url),
locations_len=len(gw_info.groundwater.locs.results),
timeseries_len=len(gw_info.groundwater.ts.results))
pop_up_info(msg=msg, title='No data found')
return
def run_custom_import(self):
start = self.start_date.strftime('%Y-%m-%dT00:00:00Z')
end = self.end_date.strftime('%Y-%m-%dT00:00:00Z')
gw_info = QGisLizardCustomImporter(username=self.username,
password=self.password,
organisation_id=self.selected_organisation)
gw_info.download(
start=start,
end=end,
groundwater_type=CUSTOM_GROUNDWATER_TYPE)
# It is fine to have no data. We'll just create an empty shapefile,
# then.
if not self.custom_filename:
# Take homedir as starting point
self.filename = os.path.expanduser('~')
self.custom_filename = QFileDialog.getSaveFileName(
self.iface.mainWindow(),
self.tr("New shapefile to save downloaded CUSTOM data in"),
self.filename,
self.tr("Shape files (*.shp)"))
gw_info.data_to_custom_shape(filename=self.custom_filename,
overwrite=True)
self.custom_layer = gw_info.load_custom_shape(self.custom_filename)
self.custom_layer.featureDeleted.connect(self._record_deleted_point)
self.custom_layer.featureAdded.connect(self._record_added_point)
self.custom_layer.attributeValueChanged.connect(self._record_changed_point)
self.upload_custom_points_action.setDisabled(False)
def _record_deleted_point(self, id):
# print("Point %s has been deleted" % id)
pass
def _record_added_point(self, id):
# print("Point %s has been added" % id)
pass
def _record_changed_point(self, id, index, dont_care):
# QgsFeatureId fid, int idx, const QVariant &
# print("Point %s has been changed" % id)
pass
def run_upload(self):
to_upload = []
for feature in self.custom_layer.getFeatures():
attrs = feature.attributes()
value = attrs[0]
downloaded = bool(attrs[1] == DOWNLOADED_MARKER)
if downloaded:
# We only upload new stuff
continue
wkt = feature.geometry().asPoint().wellKnownText()
# ^^^ Hope that this is in the right coordinate system.
if wkt in self.already_uploaded:
# We already uploaded it earlier.
continue
to_upload.append({'feature': feature,
'wkt': wkt,
'value': value})
self.upload_points_dialog.number.setText(str(len(to_upload)))
self.upload_points_dialog.show()
# Run the dialog event loop
result = self.upload_points_dialog.exec_()
# See if OK was pressed
if result:
num_succeeded = 0
num_failed = 0
loc_api = Locations()
loc_api.username = self.username
loc_api.password = self.password
loc_api.organisation_id = self.selected_organisation
for point in to_upload:
values = {
'name': GGMN_CUSTOM,
'organisation': self.selected_organisation,
'organisation_code': datetime.datetime.now().isoformat(),
'ddsc_show_on_map': 'false',
'access_modifier': 0,
'geometry': point['wkt']}
try:
location_uuid = loc_api.add_new_one(values)
except Exception as e:
# print(e)
num_failed += 1
continue
# print("Created location with uuid %s" % location_uuid)
ts_api = TimeSeries()
ts_api.username = self.username
ts_api.password = self.password
ts_api.organisation_id = self.selected_organisation
values = {'name': GGMN_CUSTOM,
'location': location_uuid,
'supplier_code': datetime.datetime.now().isoformat(),
'organisation_code': datetime.datetime.now().isoformat(),
'access_modifier': 0,
'value_type': 1, # 1 = float
'parameter_referenced_unit': CUSTOM_GROUNDWATER_TYPE,
}
try:
ts_id = ts_api.add_new_one(values)
except Exception as e:
# print(e)
num_failed += 1
continue
# print("Created timeserie id=%s" % ts_id)
try:
ts_api.add_value(ts_id, value=point['value'])
except Exception as e:
# print(e)
num_failed += 1
continue
self.already_uploaded.append(point['wkt'])
num_succeeded += 1
pop_up_info("%s succesfully uploaded, %s failed" % (num_succeeded,
num_failed))
def run_raster_upload(self):
# The selected layer should be a raster layer.
layer = self.iface.activeLayer()
if not isinstance(layer, QgsRasterLayer):
pop_up_info("Error: you must select the raster layer")
return
fd, tiff_filename = tempfile.mkstemp(suffix='.tiff')
os.close(fd)
# ^^^ We just want the filename, not the opened file descriptor.
provider = layer.dataProvider()
pipe = QgsRasterPipe()
pipe.set(provider.clone())
file_writer = QgsRasterFileWriter(tiff_filename)
file_writer.writeRaster(pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
provider.crs())
# http://build-failed.blogspot.nl/2014/12/splitting-vector-and-raster-files-in.html
# print(tiff_filename)
# Optionally TODO: grab title from dialog.
title = "Uploaded by the qgis plugin on %s" % (
datetime.datetime.now().isoformat())
form = urllib2_upload.MultiPartForm()
form.add_field('title', title)
form.add_field('organisation_id', str(self.selected_organisation))
filename = os.path.basename(tiff_filename)
form.add_file('raster_file', filename, fileHandle=open(tiff_filename, 'rb'))
request = urllib2.Request('https://ggmn.un-igrac.org/upload_raster/')
request.add_header('User-agent', 'qgis ggmn uploader')
request.add_header('username', self.username)
request.add_header('password', self.password)
body = str(form)
request.add_header('Content-type', form.get_content_type())
request.add_header('Content-length', len(body))
# print("content-length: %s" % len(body))
request.add_data(body)
fd2, logfile = tempfile.mkstemp(prefix="uploadlog", suffix=".txt")
open(logfile, 'w').write(request.get_data())
# print("Printed what we'll send to %s" % logfile)
answer = urllib2.urlopen(request).read()
# print(answer)
# print("Uploaded geotiff to the server")
pop_up_info("Uploaded geotiff to the server")
api = VkApi()
if api.isLogedIn():
self.track_list = VkAudio.parse(api.audio_get(api.current_user_id, api.audio_get_count(api.current_user_id)))
for track in self.track_list:
btn = QPushButton()
btn.setText(track.artist + track.title)
btn.clicked.connect(partial(self.on_track_click, track.url))
self.ui.track_list.add_widget_item(btn)
self.show()
def on_track_click(self, item_id):
if self.track_list:
for track in self.track_list:
if track.url == item_id:
self.ui.player_widget.prepare_playback(track)
if __name__ == '__main__':
app = QApplication(sys.argv)
app.setStyle("Fusion")
login = LoginDialog()
if not login.exec_():
sys.exit(-1)
ex = ZebraApplication()
sys.exit(app.exec_())
class DoubanFMSource(RB.BrowserSource):
__gtype_name__ = 'DoubanFMSource'
object = GObject.property(type=GObject.Object)
def __init__(self):
RB.BrowserSource.__init__(self, name=SOURCE_NAME)
self.activated = False
self.db = None
self.doubanfm = None
self.songs_map = {}
self.songs = []
self.history = []
self.login_dialog = None
def do_selected(self):
if not self.activated:
self.activated = True
self.shell = self.props.shell
self.plugin = self.props.plugin
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.entry_type = self.props.entry_type
if self.doubanfm == None:
if self.login_dialog == None:
self.login_dialog = LoginDialog(self.shell)
self.login_dialog.connect('login-completed', self.on_login_completed)
self.login_dialog.login()
self.plugin.show_sidebar(True)
def do_deselected(self):
self.plugin.show_sidebar(False)
def on_login_completed(self, dialog, doubanfm):
self.doubanfm = doubanfm
self.plugin.change_menu_item_state(True)
def set_channel(self, channel):
self.doubanfm.channel = channel
self.new_playlist()
def get_song_by_title(self, song_title):
return self.songs_map.get(song_title.decode('utf-8'), None)
def add_song(self, song):
entry = RB.RhythmDBEntry.new(self.db, self.entry_type, song.url)
self.db.entry_set(entry, RB.RhythmDBPropType.TITLE, song.title.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ALBUM, song.albumtitle.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ARTIST, song.artist.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.DURATION, song.length)
if song.rating_avg:
self.db.entry_set(entry, RB.RhythmDBPropType.RATING, song.rating_avg)
if song.kbps:
self.db.entry_set(entry, RB.RhythmDBPropType.BITRATE, int(song.kbps.encode('utf-8')))
if song.company:
self.db.entry_set(entry, RB.RhythmDBPropType.GENRE, song.company.encode('utf-8'))
if song.public_time:
date = datetime.date(int(song.public_time.encode('utf-8')), 1, 1).toordinal()
self.db.entry_set(entry, RB.RhythmDBPropType.DATE, date)
def reset_songs(self, songs):
for row in self.props.query_model:
self.db.entry_delete(row[0])
self.songs = songs
self.songs_map = {}
for song in self.songs:
self.songs_map[song.title] = song
self.add_song(song)
self.db.commit()
GLib.idle_add(self.start_playing)
def start_playing(self):
if self.player.get_playing_entry() == None:
self.player.set_playing_source(self)
self.player.do_next()
def new_playlist(self):
_thread.start_new_thread(self.doubanfm.new_playlist, (self.history,
self.reset_songs))
def del_song(self, song):
sids = [each.sid for each in self.songs]
next = sids.index(song.sid) + 1
_thread.start_new_thread(self.doubanfm.del_song, (song.sid, song.aid,
sids[next:], self.reset_songs))
def fav_song(self, song):
_thread.start_new_thread(self.doubanfm.fav_song, (song.sid, song.aid))
song.like = True
def unfav_song(self, song):
_thread.start_new_thread(self.doubanfm.unfav_song, (song.sid, song.aid))
song.like = False
def skip_song(self, song):
_thread.start_new_thread(self.doubanfm.skip_song, (song.sid, song.aid,
self.history, self.reset_songs))
if (song.sid, 's') not in self.history:
self.history.insert(0, (song.sid, 's'))
if len(self.history) > 20:
self.history.pop()
def played_song(self, song):
_thread.start_new_thread(self.doubanfm.played_song, (song.sid, song.aid))
if (song.sid, 'p') not in self.history:
self.history.insert(0, (song.sid, 'p'))
if len(self.history) > 20:
self.history.pop()
def played_list(self, song):
_thread.start_new_thread(self.doubanfm.played_list, (song.sid, self.history,
self.reset_songs))
class PSSOptimisation(object):
def __init__(self):
QtCore.QCoreApplication.setApplicationName("PSSOptimisation")
QtCore.QCoreApplication.setApplicationVersion(str(VERSION))
QtCore.QCoreApplication.setOrganizationName("Hubert Grzeskowiak")
self.settings = QtCore.QSettings()
self.main_window = MainWindow(True)
self.grades_model = GradesModel(self.main_window)
self.proxy_model = GradesModelProxy()
self.proxy_model.setSourceModel(self.grades_model)
self.initUI()
# tray = QtGui.QSystemTrayIcon(self.main_window)
# tray.setIcon(QtGui.QIcon("icons/Accessories-calculator.svg"))
# tray.connect(tray,
# SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),
# self.trayClicked)
# tray.show()
# self.tray = tray
# def trayClicked(self, reason):
# print reason
# if reason == QtGui.QSystemTrayIcon.DoubleClick:
# self.main_window.setVisible(not self.main_window.isVisible())
def initUI(self):
self.connectUI()
self.main_window.show()
def __columnsChanged(self):
"""This should be called whenever the columns filter is changed.
It's a workaround for a bug in the headerview not updating the columns
properly on filter change.
"""
header = self.main_window.grades_table.horizontalHeader()
header.resizeSections(QtGui.QHeaderView.ResizeToContents)
header.resizeSection(0, header.sectionSize(0) - 1)
header.resizeSection(0, header.sectionSize(0) + 1)
def connectUI(self):
self.main_window.grades_table.setModel(self.proxy_model)
delegate = CheckBoxDelegate()
self.main_window.grades_table.setItemDelegate(delegate)
self.main_window.connect(self.main_window.action_download,
SIGNAL("triggered()"), self.openLoginDialog)
self.main_window.connect(self.main_window.action_donate,
SIGNAL("triggered()"),
self.openDonationDialog)
self.main_window.connect(self.main_window.action_open,
SIGNAL("triggered()"), self.openFileDialog)
self.main_window.connect(self.grades_model, SIGNAL("dataChanged()"),
self.updateStats)
self.main_window.connect(
self.grades_model, SIGNAL("dataChanged()"),
self.main_window.grades_table.resizeColumnsToContents)
self.main_window.connect(self.grades_model, SIGNAL("modelReset()"),
self.updateStats)
self.main_window.connect(
self.grades_model, SIGNAL("modelReset()"),
self.main_window.grades_table.resizeColumnsToContents)
# workaround for buggy headerview
self.main_window.connect(self.proxy_model,
SIGNAL("columnsVisibilityChanged()"),
self.__columnsChanged)
# create actions for toggling table columns
header = self.main_window.grades_table.horizontalHeader()
self.header_actions = QtGui.QActionGroup(header)
self.header_actions.setExclusive(False)
for nr, (name, visible) in enumerate(
zip(self.grades_model.header_data,
self.proxy_model.col_visibility)):
action = self.header_actions.addAction(name)
action.setCheckable(True)
action.setChecked(visible)
action.connect(action,
SIGNAL("triggered()"),
lambda nr=nr: self.proxy_model.toggleColumn(nr))
# add that menu as context menu for the header
header.addActions(self.header_actions.actions())
header.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
# and put it into the main window's menus
self.main_window.menu_table_columns.clear()
for action in self.header_actions.actions():
self.main_window.menu_table_columns.addAction(action)
# automatically download new grades (depends on settings)
if self.settings.value("updateOnStart", False).toBool():
QtCore.QTimer.singleShot(200, self.tryAutoDownloadFromPSSO)
def openLoginDialog(self):
self.login_dialog = LoginDialog(self.main_window)
self.login_dialog.exec_()
if self.login_dialog.result():
username = str(self.login_dialog.username_line.text())
password = str(self.login_dialog.password_line.text())
if username and password:
remember = self.login_dialog.remember_checkbox.isChecked()
self.handleLoginData(username, password, remember)
def handleLoginData(self, username, password, remember=False):
"""Try to load the grades by using the provided login credentials.
On failure, an error popup is displayed. On success a loading progress
bar and after that a table is shown.
If "remember" is True, then the login data is saved.
"""
self.main_window.setDisabled(True)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
progress = 0
try:
iterator = self.grades_model.getFromPSSOIterator(
username, password)
for step in iterator:
self.main_window.showProgress(progress, step)
# getFromPSSOIterator defines 8 steps, but 1st is at 0
progress += 100.0 / 7
QtGui.QApplication.processEvents()
except (ConnectionError, ServiceUnavailableError, ParsingError) as e:
QtGui.QMessageBox.critical(self.main_window, e.title, e.message)
return
except LoginError as e:
self.clearLoginData(username)
QtGui.QMessageBox.critical(self.main_window, e.title, e.message)
return
finally:
self.main_window.setEnabled(True)
self.main_window.showProgress(-1)
self.main_window.showTable()
self.main_window.setEnabled(True)
if remember:
self.saveLoginData(username, password)
def saveLoginData(self, username, password):
assert username and password
self.settings.setValue("username", username)
keyring.set_password("PSSO", username, password)
def getLoginData(self):
"""Try to retrieve previously saved username and password. Returns
a tuple of two empty strings on failure.
"""
username = str(self.settings.value("username").toString() or "")
try:
password = keyring.get_password("PSSO", username) or ""
except IOError:
return "", ""
return username, password
def clearLoginData(self, username=None):
"""Remove username and password settings. If a username is given,
its password will be removed. If there is a saved username,
it will also get removed alongside with the corresponding password.
"""
username2 = str(self.settings.value("username").toString() or "")
try:
keyring.delete_password("PSSO", username)
except:
pass
try:
keyring.delete_password("PSSO", username2)
except:
pass
self.settings.remove("username")
def tryAutoDownloadFromPSSO(self):
u, p = self.getLoginData()
if u and p:
self.handleLoginData(u, p)
def openFileDialog(self):
ofd = OpenFileDialog(self.main_window)
accepted = ofd.exec_()
if accepted and ofd.html_file:
try:
html = codecs.open(ofd.html_file, encoding='utf-8')
except IOError:
QtGui.QMessageBox.warning(
self.main_window, "File not found",
"Sorry, but there seems to be no file called {}.".format(
ofd.html_file))
return
self.grades_model.getFromHTML(html)
self.main_window.showTable()
def openDonationDialog(self):
dp = DonationDialog(self.main_window)
dp.exec_()
def updateStats(self):
self.main_window.num_of_grades.setText(
str(self.grades_model.getNumOfGrades()))
self.main_window.num_of_credits.setText(
str(self.grades_model.getNumOfCredits()))
self.main_window.average_grade.setText(
str(self.grades_model.getAverageGrade()))
class SLTRPlugin:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
if not sys.path.__contains__(self.plugin_dir): sys.path.append(self.plugin_dir)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'SLTRPlugin_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = LoginDialog()
self.dlg2 = SolaPluginDialog()
self.dlg3 = CreateFormDialog()
# Declare instance attributes
self.actions = []
self.fid_array = []
self.user = ''
self.fid = 0
self.parcel_id = ''
self.transactionId = ''
configParser = ConfigParser.RawConfigParser()
configfilepath = self.plugin_dir+os.path.sep+'config.ini'
configParser.read(configfilepath)
self.db_hostName = configParser.get('settings', 'Hostname') # '192.168.0.1'
self.db_databaseName = configParser.get('settings', 'DatabaseName') # 'sltrportal'
self.db_UserName = configParser.get('settings', 'Username') # 'postgres'
self.db_password = configParser.get('settings', 'Password') # 'sola450'
self.db_Port = int(configParser.get('settings', 'Port')) # 5432
self.url = configParser.get('settings',
'Url') # 'url=http://192.168.0.1:8080/geoserver/SLTR/wms?service=WMS&version=1.1.0&request=GetMap&layers=kano&styles=&crs=EPSG:26332&format=image/jpeg'
print self.db_hostName
print self.db_databaseName
print self.db_UserName
print self.db_password
print self.url
self.menu = self.tr(u'&SLTRPlugin')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'SLTRPlugin')
self.toolbar.setObjectName(u'SLTRPlugin')
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('SLTRPlugin', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/SLTRPlugin/icon.png'
self.add_action(
icon_path,
text=self.tr(u'SLTR'),
callback=self.run,
parent=self.iface.mainWindow())
# self.toolbar = self.iface.addToolBar("SLTRToolBar")
# Create actions
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&SLTRPlugin'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
# Capture Login Details
print self.dlg.userNameBox.text()
print self.dlg.pswdBox.text()
# Check User namer and password
username = self.dlg.userNameBox.text()
password = self.dlg.pswdBox.text()
if self.authUser(username, password) == True:
self.user = username
self.iface.messageBar().pushMessage("Success",
"Login Successful! Welcome " + self.dlg.userNameBox.text(),
level=QgsMessageBar.INFO, duration=3)
self.transactionId = self.getTransactionId()
self.createRasterLayer()
self.createLGALayer()
self.createWardLayer()
self.createSectionLayer()
self.createBlockLayer()
self.createParcelLayer()
layer = self.iface.activeLayer()
canvas = self.iface.mapCanvas()
extent = layer.extent()
canvas.setExtent(extent)
self.dlg.close()
else:
self.iface.messageBar().pushMessage("Error", "Your Login attempt was unsuccessful. Please try again",
level=QgsMessageBar.CRITICAL, duration=5)
self.run()
# tryout
# END TRY'''
def captureFeatures(self, fid):
print 'Feature Added'
print fid
if fid in self.fid_array:
print "in Capture Features: I saw it there!!"
pass
else:
self.fid = fid
self.fid_array.append(fid)
self.initDialog('')
def startEdit(self):
print 'Edit started'
def finishEdit(self):
print 'Finished Editing!'
# self.initDialog()
layer = self.iface.activeLayer()
self.initDialog('')
def initDialog(self, error):
if error != '':
self.dlg2.error_label.setText(error)
self.dlg2.show()
result = self.dlg2.exec_()
layer = self.iface.activeLayer()
if result:
if self.checkParcelNumberExists(self.dlg2.parcel_id.text()):
self.parcel_id = self.dlg2.parcel_id.text()
if self.dlg2.absentee.isChecked() == True:
self.statuscode = 'absentee'
print 'Absentee Claimant'
else:
self.statuscode = 'pending'
print 'Present Claimant so pending'
if self.dlg2.existing_title.isChecked() == True:
self.existing_title = 'existing_title'
print 'Existing Title'
else:
self.existing_title = self.parcel_id
print 'No Existin Title for ' + self.parcel_id
print ' just captured parcel' + self.parcel_id
if self.checkParcelExistsAlready(self.parcel_id) == False:
# self.dlg2.parcel_id.setText('')
layer.featureAdded.disconnect(self.captureFeatures)
print 'About to saveEdit' + self.parcel_id
self.saveEdit(self.parcel_id, self.statuscode, self.existing_title)
layer.featureAdded.connect(self.captureFeatures)
else:
# layer.deleteFeature(fid)
# self.resetFid()
# layer.commitChanges()
# layer.startEditing()
self.initDialog('Parcel Number already exists! Please check and try again')
else:
# self.resetFid()
# layer.commitChanges()
# layer.startEditing()
self.initDialog('The Parcel Number doesn''t exist for the generated forms. Please try again')
else:
layer.deleteFeature(self.fid)
layer.commitChanges()
layer.startEditing()
self.dlg2.parcel_id.setText('')
def createParcelLayer(self):
uri = QgsDataSourceURI()
uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
uri.setDataSource("cadastre", "cadastre_object", "geom_polygon")
uri.uri()
print uri.uri()
rlayer = self.iface.addVectorLayer(uri.uri(), "Parcels", "postgres")
self.iface.setActiveLayer(rlayer)
rlayer.loadNamedStyle(self.plugin_dir + '/parcel.qml')
#rlayer.layerModified.connect(self.captureFeatures)
rlayer.featureAdded.connect(self.captureFeatures)
rlayer.setEditForm(self.plugin_dir + os.sep + 'createForm.ui')
#rlayer.setEditFormInit('.CreateFormDialog.formOpen')
rlayer.startEditing()
def createWardLayer(self):
uri = QgsDataSourceURI()
uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
uri.setDataSource("cadastre", "spatial_unit_group", "geom", "hierarchy_level=3")
uri.uri()
print uri.uri()
rlayer = self.iface.addVectorLayer(uri.uri(), "Ward", "postgres")
rlayer.loadNamedStyle(self.plugin_dir + '/ward.qml')
def createLGALayer(self):
uri = QgsDataSourceURI()
uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
uri.setDataSource("cadastre", "spatial_unit_group", "geom", "hierarchy_level=2")
uri.uri()
print uri.uri()
rlayer = self.iface.addVectorLayer(uri.uri(), "LGA", "postgres")
rlayer.loadNamedStyle(self.plugin_dir + '/lga.qml')
def createRasterLayer(self):
# http://192.168.0.1:8080/geoserver/SLTR/wms
urlWithParams = self.url
rlayer = QgsRasterLayer(urlWithParams, 'Orthophoto', 'wms')
QgsMapLayerRegistry.instance().addMapLayer(rlayer)
# urlWithParams = 'url=http://localhost:8085/geoserver/calabar/wms?service=WMS&version=1.1.0&request=GetMap&layers=Calabar_20Dec2013_50cm_Colr2&styles=&srs=EPSG:4326&format=image/jpeg'
# rlayer = QgsRasterLayer(urlWithParams, 'Orthophoto', 'wms')
# QgsMapLayerRegistry.instance().addMapLayer(rlayer)
# urlWithParams = 'url=http://localhost:8085/geoserver/lokoja/wms?service=WMS&version=1.1.0&request=GetMap&layers=Lokoja_Mos_Nov2011_50cm_Color&styles=&crs=EPSG:32632&format=image/png'
# rlayer = QgsRasterLayer(urlWithParams, 'Orthophoto', 'wms')
# QgsMapLayerRegistry.instance().addMapLayer(rlayer)
def createSectionLayer(self):
uri = QgsDataSourceURI()
uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
uri.setDataSource("cadastre", "spatial_unit_group", "geom", "hierarchy_level=4")
uri.uri()
print uri.uri()
rlayer = self.iface.addVectorLayer(uri.uri(), "Section", "postgres")
rlayer.loadNamedStyle(self.plugin_dir + '/lga.qml')
def createBlockLayer(self):
uri = QgsDataSourceURI()
uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
uri.setDataSource("cadastre", "spatial_unit_group", "geom", "hierarchy_level=5")
uri.uri()
print uri.uri()
rlayer = self.iface.addVectorLayer(uri.uri(), "Blocks", "postgres")
rlayer.loadNamedStyle(self.plugin_dir + '/lga.qml')
def authUser(self, username, password):
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
# assume you have a table called 'appuser'
query = db.exec_("select * from public.user where username='******' AND qpass = '******'")
# No password implementations yet
# iterate over the rows
if query.size() == 1:
return True
else:
return False
pass
def saveEdit(self, parcel_id, statuscode, existing_title):
layer = self.iface.activeLayer()
fid = self.fid
print 'current featureID' + parcel_id
print 'in saving of edits A as: ' + parcel_id
# print feature.id()
# print feature.geometry()
# dataProvider=layer.dataProvider()
# absentee or pending for status
caps = layer.dataProvider().capabilities()
# if caps & QgsVectorDataProvider.AddAttributes:
feature = layer.getFeatures(QgsFeatureRequest(fid)).next()
# transaction_id=self.getTransactionId()
# check that the specified parcel number exists
print 'current Transaction ID ' + self.transactionId
print 'in saving of edits B' + parcel_id
if self.checkParcelExistsAlready(parcel_id) == False:
name_lastpart=self.getNameLastPart(feature.geometry().exportToWkt())
layer.changeAttributeValue(fid, feature.fieldNameIndex('id'), self.getUUID())
layer.changeAttributeValue(fid, feature.fieldNameIndex('type_code'), 'parcel')
layer.changeAttributeValue(fid, feature.fieldNameIndex('source_reference'), existing_title)
layer.changeAttributeValue(fid, feature.fieldNameIndex('name_firstpart'), parcel_id)
layer.changeAttributeValue(fid, feature.fieldNameIndex('name_lastpart'), name_lastpart)
layer.changeAttributeValue(fid, feature.fieldNameIndex('status_code'), statuscode)
layer.changeAttributeValue(fid, feature.fieldNameIndex('change_action'), 'i')
layer.changeAttributeValue(fid, feature.fieldNameIndex('change_user'), self.user)
layer.changeAttributeValue(fid, feature.fieldNameIndex('transaction_id'), self.transactionId)
layer.changeAttributeValue(fid, feature.fieldNameIndex('land_use_code'), 'residential')
layer.changeAttributeValue(fid, feature.fieldNameIndex('view_id'), 1)
#self.fid_array.append(fid)
# feat.setGeometry()
(res, outFeat) = layer.dataProvider().addFeatures([feature])
layer.commitChanges()
layer.startEditing()
print 'finished saveEdit'
else:
self.initDialog('An error has occurred. Duplicate Parcel Number. Please check and try again')
pass
def checkParcelNumberExists(self, parcelNumber):
# Check the forms table to verify the existence of the parcel number in the form table
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
# assume you have a table called 'appuser'
query = db.exec_("select nr from public.form where nr='" + parcelNumber + "'")
print 'in checkParcelNumberExists'
# iterate over the rows to see if there is only one record and it exists
if query.size() == 1:
return True
else:
return False
pass
# Implementation to standardize db calls
def checkParcelExistsAlready(self, parcelNumber):
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
query = db.exec_(
"select name_firstpart from cadastre.cadastre_object where name_firstpart='" + parcelNumber + "'")
print 'in checkParcelExistsAlready'
# iterate over the rows to see if there is only one record and it exists
if query.size() == 1:
print query.size()
return True
else:
return False
pass
def getTransactionId(self):
# return '010656ad-1725-41e6-b172-064e9b89b323'
# Essentially create a transaction ID in code, insert the transaction entry and store in the session variable
did = str(self.getUUID())
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
# assume you have a table called 'appuser'
query = db.exec_("insert into transaction.transaction(id,change_action,change_user) VALUES('" + did + "','i','" + self.user + "')")
# iterate over the rows
if query.size() == 1:
#self.transactionId = did
print "in getTransactionId success" + did
print did
return did
# else:
# self.iface.messageBar().pushMessage("Error",
# "An error has occurred. Please notify the administrator",
# level=QgsMessageBar.CRITICAL, duration=5)
def getUUID(self):
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
# assume you have a table called 'appuser'
query = db.exec_("select uuid_generate_v1()")
print "in getUUID"
# iterate over the rows
if query.size() == 1:
query.next()
return str(query.value(0))
else:
return False
pass
def getNameLastPart(self, geom):
db = QSqlDatabase('QPSQL')
if db.isValid():
db.setHostName(self.db_hostName)
# string
db.setDatabaseName(self.db_databaseName)
# string
db.setUserName(self.db_UserName)
# string
db.setPassword(self.db_password)
# integer e.g. 5432
db.setPort(self.db_Port)
if db.open():
print str(geom)
query=db.exec_("select cadastre.get_new_cadastre_object_identifier_last_part((SELECT ST_PolygonFromText(('"+str(geom)+"'),32632)),'value')")
print "in getNameLastPart"
if query.size()==1:
query.next()
print str(query.value(0))
return str(query.value(0))
else:
return ''
pass
pass
def checkOverlaps(self):
pass
def resetFid(self):
self.fid = 0
class DoubanFMSource(RB.BrowserSource):
__gtype_name__ = 'DoubanFMSource'
object = GObject.property(type=GObject.Object)
def __init__(self):
RB.BrowserSource.__init__(self, name=SOURCE_NAME)
self.activated = False
self.db = None
self.doubanfm = None
self.songs_map = {}
self.songs = []
self.history = []
self.login_dialog = None
def do_selected(self):
"""
do some work when this source is selected.
"""
if not self.activated:
self.activated = True
self.shell = self.props.shell
self.plugin = self.props.plugin
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.entry_type = self.props.entry_type
if self.doubanfm == None:
if self.login_dialog == None:
self.login_dialog = LoginDialog(self.shell)
self.login_dialog.connect('login-completed', self.on_login_completed)
self.login_dialog.login()
self.plugin.show_sidebar(True)
def do_deselected(self):
"""
do some work when this source is deselected.
"""
self.plugin.show_sidebar(False)
def on_login_completed(self, dialog, doubanfm):
"""
refresh playlist when logged in successfully.
"""
self.doubanfm = doubanfm
self.new_playlist()
self.plugin.change_menu_item_state(True)
def set_channel(self, channel):
"""
set current channel.
"""
self.doubanfm.channel = channel
self.new_playlist()
def get_song_by_title(self, song_title):
"""
get a song by its title.
"""
return self.songs_map.get(song_title.decode('utf-8'), None)
def add_song(self, song):
"""
add a new entry for a song.
"""
entry = self.db.entry_lookup_by_location(song.url)
if entry == None:
entry = RB.RhythmDBEntry.new(self.db, self.entry_type, song.url)
self.db.entry_set(entry, RB.RhythmDBPropType.TITLE, song.title.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ALBUM, song.albumtitle.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.ARTIST, song.artist.encode('utf-8'))
self.db.entry_set(entry, RB.RhythmDBPropType.DURATION, song.length)
if song.rating_avg:
self.db.entry_set(entry, RB.RhythmDBPropType.RATING, song.rating_avg)
if song.kbps:
self.db.entry_set(entry, RB.RhythmDBPropType.BITRATE, int(song.kbps.encode('utf-8')))
if song.company:
self.db.entry_set(entry, RB.RhythmDBPropType.GENRE, song.company.encode('utf-8'))
if song.public_time:
date = datetime.date(int(song.public_time.encode('utf-8')), 1, 1).toordinal()
self.db.entry_set(entry, RB.RhythmDBPropType.DATE, date)
def reset_songs(self, songs):
"""
clear and reset all entries.
"""
for row in self.props.query_model:
entry = row[0]
self.db.entry_delete(entry)
self.songs = songs
self.songs_map = {}
for song in self.songs:
self.songs_map[song.title] = song
self.add_song(song)
self.db.commit()
GLib.idle_add(self.start_playing)
def start_playing(self):
"""
start playing from the beginning.
"""
if self.player.get_playing_entry() == None:
self.player.set_playing_source(self)
self.player.do_next()
def new_playlist(self):
"""
get a new playlist.
"""
songs = self.doubanfm.new_playlist(self.history)
self.reset_songs(songs)
def del_song(self, song):
"""
delete a song (mark as 'never play') by its title.
"""
sids = [each.sid for each in self.songs]
next = sids.index(song.sid) + 1
songs = self.doubanfm.del_song(song.sid, song.aid, sids[next:])
self.reset_songs(songs)
def fav_song(self, song):
"""
favor a song (mark as 'like') by its title.
"""
self.doubanfm.fav_song(song.sid, song.aid)
song.like = True
def unfav_song(self, song):
"""
unfavor a song (remove 'like' mark) by its title.
"""
self.doubanfm.unfav_song(song.sid, song.aid)
song.like = False
def skip_song(self, song):
"""
skip a song by its title.
"""
songs = self.doubanfm.skip_song(song.sid, song.aid, self.history)
self.reset_songs(songs)
self.history.append((song.sid, 's'))
def played_song(self, song):
"""
mark a song as 'played'.
"""
self.doubanfm.played_song(song.sid, song.aid)
self.history.append((song.sid, 'p'))
def played_list(self, song):
"""
playlist ended. request more songs.
"""
songs = self.doubanfm.played_list(song.sid, self.history)
self.reset_songs(songs)
class PSSOptimisation(object):
def __init__(self):
QtCore.QCoreApplication.setApplicationName("PSSOptimisation")
QtCore.QCoreApplication.setApplicationVersion(str(VERSION))
QtCore.QCoreApplication.setOrganizationName("Hubert Grzeskowiak")
self.settings = QtCore.QSettings()
self.main_window = MainWindow(True)
self.grades_model = GradesModel(self.main_window)
self.proxy_model = GradesModelProxy()
self.proxy_model.setSourceModel(self.grades_model)
self.initUI()
# tray = QtGui.QSystemTrayIcon(self.main_window)
# tray.setIcon(QtGui.QIcon("icons/Accessories-calculator.svg"))
# tray.connect(tray,
# SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),
# self.trayClicked)
# tray.show()
# self.tray = tray
# def trayClicked(self, reason):
# print reason
# if reason == QtGui.QSystemTrayIcon.DoubleClick:
# self.main_window.setVisible(not self.main_window.isVisible())
def initUI(self):
self.connectUI()
self.main_window.show()
def __columnsChanged(self):
"""This should be called whenever the columns filter is changed.
It's a workaround for a bug in the headerview not updating the columns
properly on filter change.
"""
header = self.main_window.grades_table.horizontalHeader()
header.resizeSections(QtGui.QHeaderView.ResizeToContents)
header.resizeSection(0, header.sectionSize(0)-1)
header.resizeSection(0, header.sectionSize(0)+1)
def connectUI(self):
self.main_window.grades_table.setModel(self.proxy_model)
delegate = CheckBoxDelegate()
self.main_window.grades_table.setItemDelegate(delegate)
self.main_window.connect(self.main_window.action_download,
SIGNAL("triggered()"), self.openLoginDialog)
self.main_window.connect(self.main_window.action_donate,
SIGNAL("triggered()"), self.openDonationDialog)
self.main_window.connect(self.main_window.action_open,
SIGNAL("triggered()"), self.openFileDialog)
self.main_window.connect(self.grades_model,
SIGNAL("dataChanged()"), self.updateStats)
self.main_window.connect(self.grades_model,
SIGNAL("dataChanged()"),
self.main_window.grades_table.resizeColumnsToContents)
self.main_window.connect(self.grades_model,
SIGNAL("modelReset()"), self.updateStats)
self.main_window.connect(self.grades_model,
SIGNAL("modelReset()"),
self.main_window.grades_table.resizeColumnsToContents)
# workaround for buggy headerview
self.main_window.connect(self.proxy_model,
SIGNAL("columnsVisibilityChanged()"),
self.__columnsChanged)
# create actions for toggling table columns
header = self.main_window.grades_table.horizontalHeader()
self.header_actions = QtGui.QActionGroup(header)
self.header_actions.setExclusive(False)
for nr, (name, visible) in enumerate(zip(
self.grades_model.header_data,
self.proxy_model.col_visibility)):
action = self.header_actions.addAction(name)
action.setCheckable(True)
action.setChecked(visible)
action.connect(action, SIGNAL("triggered()"),
lambda nr=nr: self.proxy_model.toggleColumn(nr))
# add that menu as context menu for the header
header.addActions(self.header_actions.actions())
header.setContextMenuPolicy(
QtCore.Qt.ActionsContextMenu)
# and put it into the main window's menus
self.main_window.menu_table_columns.clear()
for action in self.header_actions.actions():
self.main_window.menu_table_columns.addAction(action)
# automatically download new grades (depends on settings)
if self.settings.value("updateOnStart", False).toBool():
QtCore.QTimer.singleShot(200, self.tryAutoDownloadFromPSSO)
def openLoginDialog(self):
self.login_dialog = LoginDialog(self.main_window)
self.login_dialog.exec_()
if self.login_dialog.result():
username = str(self.login_dialog.username_line.text())
password = str(self.login_dialog.password_line.text())
if username and password:
remember = self.login_dialog.remember_checkbox.isChecked()
self.handleLoginData(username, password, remember)
def handleLoginData(self, username, password, remember=False):
"""Try to load the grades by using the provided login credentials.
On failure, an error popup is displayed. On success a loading progress
bar and after that a table is shown.
If "remember" is True, then the login data is saved.
"""
self.main_window.setDisabled(True)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
progress = 0
try:
iterator = self.grades_model.getFromPSSOIterator(username, password)
for step in iterator:
self.main_window.showProgress(progress, step)
# getFromPSSOIterator defines 8 steps, but 1st is at 0
progress += 100.0/7
QtGui.QApplication.processEvents()
except (ConnectionError, ServiceUnavailableError, ParsingError) as e:
QtGui.QMessageBox.critical(self.main_window,
e.title, e.message)
return
except LoginError as e:
self.clearLoginData(username)
QtGui.QMessageBox.critical(self.main_window,
e.title, e.message)
return
finally:
self.main_window.setEnabled(True)
self.main_window.showProgress(-1)
self.main_window.showTable()
self.main_window.setEnabled(True)
if remember:
self.saveLoginData(username, password)
def saveLoginData(self, username, password):
assert username and password
self.settings.setValue("username", username)
keyring.set_password("PSSO", username, password)
def getLoginData(self):
"""Try to retrieve previously saved username and password. Returns
a tuple of two empty strings on failure.
"""
username = str(self.settings.value("username").toString() or "")
try:
password = keyring.get_password("PSSO", username) or ""
except IOError:
return "", ""
return username, password
def clearLoginData(self, username=None):
"""Remove username and password settings. If a username is given,
its password will be removed. If there is a saved username,
it will also get removed alongside with the corresponding password.
"""
username2 = str(self.settings.value("username").toString() or "")
try:
keyring.delete_password("PSSO", username)
except:
pass
try:
keyring.delete_password("PSSO", username2)
except:
pass
self.settings.remove("username")
def tryAutoDownloadFromPSSO(self):
u, p = self.getLoginData()
if u and p:
self.handleLoginData(u, p)
def openFileDialog(self):
ofd = OpenFileDialog(self.main_window)
accepted = ofd.exec_()
if accepted and ofd.html_file:
try:
html = codecs.open(ofd.html_file, encoding='utf-8')
except IOError:
QtGui.QMessageBox.warning(self.main_window, "File not found",
"Sorry, but there seems to be no file called {}.".format(
ofd.html_file))
return
self.grades_model.getFromHTML(html)
self.main_window.showTable()
def openDonationDialog(self):
dp = DonationDialog(self.main_window)
dp.exec_()
def updateStats(self):
self.main_window.num_of_grades.setText(str(
self.grades_model.getNumOfGrades()))
self.main_window.num_of_credits.setText(str(
self.grades_model.getNumOfCredits()))
self.main_window.average_grade.setText(str(
self.grades_model.getAverageGrade()))
import sys
from PyQt5.QtWidgets import QApplication
from login_dialog import LoginDialog
if __name__ == "__main__":
app = QApplication([])
login_dialog = LoginDialog()
login_dialog.show()
sys.exit(app.exec_())
