def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
# init event
# self.btn_Query.clicked.connect(self.on_btn_Query_clicked)
# 获得系统默认编码格式
self.sysCharType = sys.getfilesystemencoding()
self.data_list_youka = None
now_time = str(datetime.date.today()) + ' 00:00:00'
from_time_default = get_default_time(-1)
self.date_from.setDateTime(QDateTime.fromString(from_time_default, 'yyyy-MM-dd hh:mm:ss'))
self.date_end.setDateTime(QDateTime.fromString(now_time, 'yyyy-MM-dd hh:mm:ss'))
# init table_results
self.table_results.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table_results.setColumnCount(3)
self.table_results.setRowCount(0)
self.table_results.setHorizontalHeaderLabels([u'学校代码', u'学校名称', u'增长数量'])
def setvalue(self, value):
strvalue = value
if value in [None, "", NULL]:
value = DateWidget.DEFAULTDATE
self._is_valid = value.isValid()
elif isinstance(value, basestring):
value = QDateTime.fromString(strvalue, Qt.ISODate)
if not value or (value and value.date().year() < 0):
value = QDateTime.fromString(strvalue, Qt.SystemLocaleShortDate)
self._is_valid = value.isValid()
if not self._is_valid:
raise ValueError("Unable to parse date string {}".format(strvalue))
if isinstance(value, QDate):
value = QDateTime(value)
self._is_valid = value.isValid()
if hasattr(self.datewidget, 'setDate'):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, 'setTime'):
self.datewidget.setTime(value.time())
self.set_date(value)
def load_sensor(self):
"""
Load selected sensor from DB
"""
self.clear_ui()
sensor_name = self.sensorList.currentText()
self.oat = self.get_sensor_from_db(sensor_name)
self.result = {'type': None}
if self.oat.data_availability != [None, None]:
begin_text = QDateTime.fromString(
self.oat.data_availability[0].replace('T', ' ')[:-5],
"yyyy-MM-dd hh:mm:ss")
end_text = QDateTime.fromString(
self.oat.data_availability[1].replace('T', ' ')[:-5],
"yyyy-MM-dd hh:mm:ss")
self.set_date(self.statisticsBegin, self.statisticsEnd, begin_text,
end_text)
self.set_date(self.intBegin, self.intEnd, begin_text, end_text)
self.set_date(self.dvalueBegin, self.dvalueEnd, begin_text,
end_text)
self.set_date(self.qualityBegin, self.qualityEnd, begin_text,
end_text)
self.set_date(self.hIndexBegin, self.hIndexEnd, begin_text,
end_text)
self.set_date(self.hEvtBegin, self.hEvtEnd, begin_text, end_text)
self.filterFrame.setEnabled(True)
self.stackedWidget.setEnabled(True)
self.draw_preview_chart()
def init_date(self):
date_from_last = str(tool.get_lastweek_someday(calendar.MONDAY) + datetime.timedelta(days=-9)) + ' 00:00:00'
self.date_from_last.setDateTime(QDateTime.fromString(date_from_last, 'yyyy-MM-dd hh:mm:ss'))
date_end_last = str(tool.get_lastweek_someday(calendar.MONDAY) + datetime.timedelta(days=-2)) + ' 00:00:00'
self.date_end_last.setDateTime(QDateTime.fromString(date_end_last, 'yyyy-MM-dd hh:mm:ss'))
date_from = str(tool.get_lastweek_someday(calendar.MONDAY) + datetime.timedelta(days=-2)) + ' 00:00:00'
self.date_from.setDateTime(QDateTime.fromString(date_from, 'yyyy-MM-dd hh:mm:ss'))
date_end = str(tool.get_current_week_someday(5)) + ' 00:00:00'
self.date_end.setDateTime(QDateTime.fromString(date_end, 'yyyy-MM-dd hh:mm:ss'))
def _load_settings(self):
s = QSettings()
self.ui.nldasEdit.setText(s.value("pihm_helper/nldas/cache", "./cache").toString())
o = s.value("pihm_helper/nldas/output", ".").toString()
self.ui.coverageBox.setEditText(s.value("pihm_helper/nldas/input", ".").toString())
self.ui.beginEdit.setDateTime(QDateTime.fromString(s.value("pihm_helper/nldas/begin", "1999-12-31T19:00:00").toString(), Qt.ISODate))
self.ui.endEdit.setDateTime(QDateTime.fromString(s.value("pihm_helper/nldas/end", "2000-01-01T02:00:00").toString(), Qt.ISODate))
if _iface:
p = QgsProject.instance()
o = p.readPath(p.readEntry("pihm_helper", "nldas/output", o)[0])
self.ui.outputEdit.setText(o)
def LoadData(self, reader, version):
# reader = open("")
for case in switch(version):
if case(QAFileVersion.V8) or case(QAFileVersion.V8_1):
self.stamp = QDateTime.fromString(reader.readline())
self.title = reader.readline()
break
elif case(QAFileVersion.V10):
self.stamp = QDateTime.fromString(reader.readline())
self.title = reader.readline()
break
else:
raise SystemError
def last_save_date(self):
"""
Return the last save date for the _data folder.
:return:
"""
return QDateTime.fromString(self.read()["data_save_date"],
Qt.ISODate).toString()
def update_display(self, test_case):
self.test_caseidentify_edit.setText(unicode(test_case.case_mark))
self.test_item_edit.setText(unicode(test_case.case_name))
self.test_cat_combox.setCurrentIndex(test_case.case_cat)
self.require_trace_edit.setText(unicode(test_case.case_req_track))
self.test_content_edit.setText(unicode(test_case.case_content))
self.sys_prepare_edit.setText(unicode(test_case.case_sys_prepare))
self.precondation_edit.setText(unicode(test_case.case_constraint))
self.test_input_edit.setText(unicode(test_case.case_input))
for index, item in enumerate(test_case.case_exec_procedure):
self.test_procedure_tabel.insertRow(index)
self.test_procedure_tabel.setItem(index, 0, QTableWidgetItem(item[0]))
self.test_procedure_tabel.setItem(index, 1, QTableWidgetItem(unicode(item[1])))
self.test_procedure_tabel.setItem(index, 2, QTableWidgetItem(unicode(item[2])))
self.test_procedure_tabel.setItem(index, 3, QTableWidgetItem(unicode(item[3])))
self.test_procedure_tabel.setItem(index, 4, QTableWidgetItem(unicode(item[4])))
self.test_procedure_tabel.setItem(index, 5, QTableWidgetItem(unicode(item[5])))
self.test_procedure_tabel.setItem(index, 6, QTableWidgetItem(unicode(item[6])))
self.estimate_rule_eidt.setText(unicode(test_case.case_qualified_rule))
self.test_env_combox.setCurrentIndex(test_case.case_env)
self.qualified_method_combox.setCurrentIndex(test_case.case_qualified_method)
self.safe_secret_edit.setText(unicode(test_case.case_safe_secret))
self.test_person_combox.setCurrentIndex(test_case.test_person)
self.test_person_join_edit.setText(unicode(test_case.test_join_person))
self.test_date_timepickedit.setDateTime(QDateTime.fromString(test_case.test_date, 'yyyy-MM-dd'))
self.test_data_edit.setText(unicode(test_case.case_data))
self.problem_sheet_edit.setText(unicode(test_case.case_problem_sheet))
self.correct_sheet_edit.setText(unicode(test_case.case_correct_sheet))
self.test_diff_edit.setText(unicode(test_case.case_diff))
def parse (self, xml):
def _float (value):
try: return float(value)
except: return None
components = {}
for member, _ in self.search(xml, "member"):
for node, tag in self.search (member, "Measurement/*"):
if tag == "samplingTime":
samplingTime = self.timeParser.parse(node)
elif tag == "observedProperty":
_, prop = self.searchFirst(node, "@href")
if not prop in components: components[prop] = None
elif tag == "featureOfInterest":
hasSamplingPoint = False
for point, foi_id in chain(self.search (node, "FeatureCollection/featureMember/SamplingPoint@id"),self.search (node, "SamplingPoint@id"),self.search (node, "SamplingPointAtDepth@id")):
hasSamplingPoint = True
_, name = self.searchFirst (point, "name")
pointGeo, _ = self.searchFirst(point, "position")
pointGeo = GMLParser.geometryFromGML(pointGeo)
if self.yx:
pointGeo = pointGeo.asPoint()
pointGeo = QgsGeometry.fromPoint(QgsPoint (pointGeo.y(),pointGeo.x()))
self.provider.features [foi_id] = (name, pointGeo)
if point.localName () == "SamplingPointAtDepth":
_, depth = self.searchFirst (point, "depth")
foi_id = (foi_id, depth)
if not hasSamplingPoint:
for _, foi_id in self.search (node, "FeatureCollection/featureMember@href"):
self.provider.features [foi_id] = (foi_id, None)
elif node.localName () == "result":
self.provider.setObservation (unicode(foi_id), QDateTime.fromString(str(samplingTime), Qt.ISODate), unicode(prop), str(tag))
if prop in components and components[prop] == None:
components[prop] = QgsField (prop, QVariant.Double if _float(tag) else QVariant.String, node.attribute("uom"))
return components
def getTimelineOptions(self, appdef):
layers = appdef["Layers"]
times = set()
for layer in layers:
if layer.timeInfo is not None:
if isinstance(layer.timeInfo[0], basestring):
features = layer.layer.getFeatures()
for feature in features:
for field in layer.timeInfo:
try:
value = feature[field]
if isinstance(value, QDate):
t = QDateTime()
t.setDate(value)
else:
t = QDateTime.fromString(unicode(value), Qt.ISODate)
if t.isValid():
times.add(t.toMSecsSinceEpoch())
except:
pass
else:
times.add(layer.timeInfo[0])
times.add(layer.timeInfo[1])
if times:
return [min(times), max(times)]
else:
return [0,1]
def add_new_row(self):
"""
Add a new row to the table
"""
row_count = self.gui.rawTable.rowCount()
frequency = self.gui.comboFreqRaw.itemData(
self.gui.comboFreqRaw.currentIndex())
if frequency == '':
self.gui.rawTable.insertRow(row_count)
self.gui.rawTable.setItem(row_count, 0, QTableWidgetItem(''))
return
if row_count != 0:
# read last date from table
last_pos = self.gui.rawTable.item(row_count - 1, 0)
last_date = QDateTime.fromString(last_pos.text(),
"yyyy-MM-dd hh:mm:ss")
seconds = isodate.parse_duration(frequency).total_seconds()
begin_pos = last_date.addSecs(seconds)
else:
last_date = self.gui.rawBeginPos.dateTime()
begin_pos = last_date
if begin_pos > self.gui.rawEndPos.dateTime():
return
self.gui.rawTable.insertRow(row_count)
begin_str = begin_pos.toString("yyyy-MM-dd hh:mm:ss")
self.gui.rawTable.setItem(row_count, 0, QTableWidgetItem(begin_str))
self.gui.rawTable.setItem(row_count, 1, QTableWidgetItem('0'))
self.gui.rawTable.setItem(row_count, 2, QTableWidgetItem('100'))
def getTimelineOptions(self, appdef):
layers = appdef["Layers"]
times = set()
for layer in layers:
if layer.timeInfo is not None:
if isinstance(layer.timeInfo[0], basestring):
features = layer.layer.getFeatures()
for feature in features:
for field in layer.timeInfo:
try:
value = feature[field]
if isinstance(value, QDate):
t = QDateTime()
t.setDate(value)
else:
t = QDateTime.fromString(
unicode(value), Qt.ISODate)
if t.isValid():
times.add(t.toMSecsSinceEpoch())
except:
pass
else:
times.add(layer.timeInfo[0])
times.add(layer.timeInfo[1])
if times:
return [min(times), max(times)]
else:
return [0, 1]
def parseDateTime(s):
#QDateTime.fromString('2000-01-03 02:5','yyyy-M-d h:m')
#allowed order: yyy-M-d or M-d-y
#allowed date separator: / - .
#allowed main separator: T or space
if not s:
return None
if type(s) is QDateTime:
return s
s = s.strip()
if '-' in s: dsep = '-'
elif '/' in s: dsep = '/'
elif '.' in s: dsep = '.'
else: return None
tsep = ':'
if 'T' in s: sep = 'T'
elif ' ' in s: sep = ' '
else: return None
try:
if int(s[0:4]) in range(1800,2100):
#year first
dformat = 'yyyy%sM%sd%sh%sm' % (dsep, dsep, sep, tsep)
else:
#strange data...
return None
except:
# the year isn't first - let's assume it's the month then
dformat = 'M%sd%syyyy%sh%sm' % (dsep, dsep, sep, tsep)
d = QDateTime.fromString(s, dformat)
if d<1000:
return None
return d
def parseDateTime(s):
#QDateTime.fromString('2000-01-03 02:5','yyyy-M-d h:m')
#allowed order: yyy-M-d or M-d-y
#allowed date separator: / - .
#allowed main separator: T or space
if not s:
return None
if type(s) is QDateTime:
return s
s = s.strip()
if '-' in s: dsep = '-'
elif '/' in s: dsep = '/'
elif '.' in s: dsep = '.'
else: return None
tsep = ':'
if 'T' in s: sep = 'T'
elif ' ' in s: sep = ' '
else: return None
try:
if int(s[0:4]) in range(1800, 2100):
#year first
dformat = 'yyyy%sM%sd%sh%sm' % (dsep, dsep, sep, tsep)
else:
#strange data...
return None
except:
# the year isn't first - let's assume it's the month then
dformat = 'M%sd%syyyy%sh%sm' % (dsep, dsep, sep, tsep)
d = QDateTime.fromString(s, dformat)
if d < 1000:
return None
return d
def isDateTimeFormatZZZ(instr):
form = QString("yyyy/MM/dd hh:mm:ss.zzz")
inqstr = QString(instr)
dts = QDateTime.fromString(inqstr, form)
if dts.isValid():
return True
else:
return False
def fmtToQDateTime(datetime,fmt_id=DATETIME_STANDARD):
"""
fmt_id as one of the enum date standards within this class
datetime should be a string using that format.
convert "01/01/2000 12:00" to a Qt-date-time object representing that time
"""
return QDateTime.fromString(datetime,DateTime.qt_datetime_format[fmt_id])
def _photoDate(self, path):
with open(path, 'rb') as imgFile:
tags = exifread.process_file(imgFile, details=False)
if 'EXIF GPS GPSDate' in tags:
return QDateTime.fromString(tags['EXIF GPS GPSDate'].values,
'yyyy:MM:dd')
else:
return QDateTime.currentDateTime()
def setvalue(self, value):
if not isinstance(value, QDateTime):
value = QDateTime.fromString(value, Qt.ISODate)
if hasattr(self.datewidget, 'setDate'):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, 'setTime'):
self.datewidget.setTime(value.time())
def value(self, value):
if value is None:
self.setAsNow()
return
if isinstance(value, basestring):
value = QDateTime.fromString(value, Qt.ISODate)
self.setDate(value.date())
self.setTime(value.time())
def value(self, value):
if value is None:
self.setAsNow()
return
if isinstance(value, basestring):
value = QDateTime.fromString(value, Qt.ISODate)
self.setDate(value.date())
self.setTime(value.time())
def setvalue(self, value):
strvalue = value
if value is None:
value = DateWidget.DEFAULTDATE
elif isinstance(value, basestring):
value = QDateTime.fromString(strvalue, Qt.ISODate)
if not value or (value and value.date().year() < 0):
value = QDateTime.fromString(strvalue, Qt.SystemLocaleShortDate)
if isinstance(value, QDate):
value = QDateTime(value)
if hasattr(self.datewidget, 'setDate'):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, 'setTime'):
self.datewidget.setTime(value.time())
self.set_date(value)
def setvalue(self, value):
strvalue = value
if value is None:
value = DateWidget.DEFAULTDATE
elif isinstance(value, basestring):
value = QDateTime.fromString(strvalue, Qt.ISODate)
if not value or (value and value.date().year() < 0):
value = QDateTime.fromString(strvalue,
Qt.SystemLocaleShortDate)
if isinstance(value, QDate):
value = QDateTime(value)
if hasattr(self.datewidget, 'setDate'):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, 'setTime'):
self.datewidget.setTime(value.time())
self.set_date(value)
def datetime_from_string(s):
s = s.strip()
if not s:
return None
from PyQt4.QtCore import QDateTime
f = local_datetime_format()
dt = QDateTime.fromString(s, f)
if not dt.isValid():
raise ParsingError()
return datetime(dt.date().year(), dt.date().month(), dt.date().day(),
dt.time().hour(), dt.time().minute(), dt.time().second())
def require_op(self):
"""
Require observed properties for selected procedure
"""
myproc = None
name = self.gui.sosProcedure.currentText()
for proc in self.procedure_list:
if proc['name'] == name:
myproc = proc
break
if not myproc:
print "Procedure not found...."
return
self.gui.sosSensorOp.clear()
self.gui.sosSensorOp.addItem('')
for obs in myproc['observedproperties']:
self.gui.sosSensorOp.addItem(obs['name'].split('-')[-1])
# set begin and end position
samplig_time = myproc['samplingTime']
begin_text = QDateTime.fromString(
samplig_time['beginposition'].replace("T", " ")[:-5],
"yyyy-MM-dd hh:mm:ss")
end_text = QDateTime.fromString(
samplig_time['endposition'].replace("T", " ")[:-5],
"yyyy-MM-dd hh:mm:ss")
# set time limit
self.gui.sosTimeEnd.setMaximumDateTime(end_text)
self.gui.sosTimeBegin.setMinimumDateTime(begin_text)
self.gui.sosTimeBegin.setDateTime(begin_text)
self.gui.sosTimeEnd.setDateTime(end_text)
def manageGui(self):
"""
Gui init
"""
self.buttonBox.button(QDialogButtonBox.Ok).clicked.connect(self.clone)
self.sensorShort.stateChanged.connect(self.enable_frame)
beg = self.oat.data_availability[0].replace("T", " ")
end = self.oat.data_availability[1].replace("T", " ")
if beg[-3] == ':':
beg = beg[:-6]
end = end[:-6]
else:
beg = beg[:-5]
end = end[:-5]
begin_pos = QDateTime.fromString(beg, "yyyy-MM-dd hh:mm:ss")
end_pos = QDateTime.fromString(end, "yyyy-MM-dd hh:mm:ss")
self.sensorBegin.setDateTime(begin_pos)
self.sensorEnd.setDateTime(end_pos)
def setvalue(self, value):
if value is None:
value = DateWidget.DEFAULTDATE
elif isinstance(value, basestring):
value = QDateTime.fromString(value, Qt.ISODate)
if isinstance(value, QDate):
value = QDateTime(value)
if hasattr(self.datewidget, "setDate"):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, "setTime"):
self.datewidget.setTime(value.time())
def parse(self, xml):
def _float(value):
try:
return float(value)
except:
return None
components = {}
for member, _ in self.search(xml, "member"):
for node, tag in self.search(member, "Measurement/*"):
if tag == "samplingTime":
samplingTime = self.timeParser.parse(node)
elif tag == "observedProperty":
_, prop = self.searchFirst(node, "@href")
if not prop in components: components[prop] = None
elif tag == "featureOfInterest":
hasSamplingPoint = False
for point, foi_id in chain(
self.search(
node,
"FeatureCollection/featureMember/SamplingPoint@id"
), self.search(node, "SamplingPoint@id"),
self.search(node, "SamplingPointAtDepth@id")):
hasSamplingPoint = True
_, name = self.searchFirst(point, "name")
pointGeo, _ = self.searchFirst(point, "position")
pointGeo = GMLParser.geometryFromGML(pointGeo)
if self.yx:
pointGeo = pointGeo.asPoint()
pointGeo = QgsGeometry.fromPoint(
QgsPoint(pointGeo.y(), pointGeo.x()))
self.provider.features[foi_id] = (name, pointGeo)
if point.localName() == "SamplingPointAtDepth":
_, depth = self.searchFirst(point, "depth")
foi_id = (foi_id, depth)
if not hasSamplingPoint:
for _, foi_id in self.search(
node, "FeatureCollection/featureMember@href"):
self.provider.features[foi_id] = (foi_id, None)
elif node.localName() == "result":
self.provider.setObservation(
unicode(foi_id),
QDateTime.fromString(str(samplingTime), Qt.ISODate),
unicode(prop), str(tag))
if prop in components and components[prop] == None:
components[prop] = QgsField(
prop, QVariant.Double
if _float(tag) else QVariant.String,
node.attribute("uom"))
return components
def setvalue(self, value):
if value is None:
value = DateWidget.DEFAULTDATE
elif isinstance(value, basestring):
value = QDateTime.fromString(value, Qt.ISODate)
if isinstance(value, QDate):
value = QDateTime(value)
if hasattr(self.datewidget, 'setDate'):
self.datewidget.setDate(value.date())
if hasattr(self.datewidget, 'setTime'):
self.datewidget.setTime(value.time())
def datetime_from_string(s):
s = s.strip()
if not s:
return None
from PyQt4.QtCore import QDateTime
f = local_datetime_format()
dt = QDateTime.fromString(s, f)
if not dt.isValid():
raise ParsingError()
return datetime(dt.date().year(),
dt.date().month(),
dt.date().day(),
dt.time().hour(),
dt.time().minute(),
dt.time().second())
def set_widgets(self):
"""Set widgets on the Source tab."""
# Just set values based on existing keywords
source = self.parent.get_existing_keyword('source')
if source or source == 0:
self.leSource.setText(get_unicode(source))
else:
self.leSource.clear()
source_scale = self.parent.get_existing_keyword('scale')
if source_scale or source_scale == 0:
self.leSource_scale.setText(get_unicode(source_scale))
else:
self.leSource_scale.clear()
source_date = self.parent.get_existing_keyword('date')
if source_date:
self.ckbSource_date.setChecked(True)
self.dtSource_date.setDateTime(
QDateTime.fromString(get_unicode(source_date),
'yyyy-MM-dd HH:mm:ss'))
else:
self.ckbSource_date.setChecked(False)
self.dtSource_date.clear()
source_url = self.parent.get_existing_keyword('url')
try:
source_url = source_url.toString()
except AttributeError:
pass
if source_url or source_url == 0:
self.leSource_url.setText(get_unicode(source_url))
else:
self.leSource_url.clear()
source_license = self.parent.get_existing_keyword('license')
if source_license or source_license == 0:
self.leSource_license.setText(get_unicode(source_license))
else:
self.leSource_license.clear()
def set_widgets(self):
"""Set widgets on the Source tab."""
# Just set values based on existing keywords
source = self.parent.get_existing_keyword('source')
if source or source == 0:
self.leSource.setText(get_unicode(source))
else:
self.leSource.clear()
source_scale = self.parent.get_existing_keyword('scale')
if source_scale or source_scale == 0:
self.leSource_scale.setText(get_unicode(source_scale))
else:
self.leSource_scale.clear()
source_date = self.parent.get_existing_keyword('date')
if source_date:
self.ckbSource_date.setChecked(True)
self.dtSource_date.setDateTime(
QDateTime.fromString(get_unicode(source_date),
'yyyy-MM-dd HH:mm:ss'))
else:
self.ckbSource_date.setChecked(False)
self.dtSource_date.clear()
source_url = self.parent.get_existing_keyword('url')
try:
source_url = source_url.toString()
except AttributeError:
pass
if source_url or source_url == 0:
self.leSource_url.setText(get_unicode(source_url))
else:
self.leSource_url.clear()
source_license = self.parent.get_existing_keyword('license')
if source_license or source_license == 0:
self.leSource_license.setText(get_unicode(source_license))
else:
self.leSource_license.clear()
def har_cookie2qt(cls, cookie):
qcookie = QNetworkCookie()
qcookie.setName(cookie["name"])
qcookie.setValue(cookie["value"])
if 'domain' in cookie:
qcookie.setDomain(cookie["domain"])
if 'httpOnly' in cookie:
qcookie.setHttpOnly(cookie["httpOnly"])
if 'secure' in cookie:
qcookie.setSecure(cookie["secure"])
if 'path' in cookie:
qcookie.setPath(cookie["path"])
if cookie.get('expires'):
expires = QDateTime.fromString(cookie["expires"], Qt.ISODate)
qcookie.setExpirationDate(expires)
return qcookie
def har_cookie2qt(cls, cookie):
qcookie = QNetworkCookie()
qcookie.setName(cookie["name"])
qcookie.setValue(cookie["value"])
if 'domain' in cookie:
qcookie.setDomain(cookie["domain"])
if 'httpOnly' in cookie:
qcookie.setHttpOnly(cookie["httpOnly"])
if 'secure' in cookie:
qcookie.setSecure(cookie["secure"])
if 'path' in cookie:
qcookie.setPath(cookie["path"])
if cookie.get('expires'):
expires = QDateTime.fromString(cookie["expires"], Qt.ISODate)
qcookie.setExpirationDate(expires)
return qcookie
def _prepForModify(self):
model = self.listData.model()
selected = self.listData.selectedIndexes()[0]
row = selected.row()
fetchByColId = lambda col: model.data(model.createIndex(row, col)).toString()
fetchColId = lambda name: model.getColIndexByName(name)
fetchValue = lambda name: fetchByColId(fetchColId(name))
self.ui.editID.setText(fetchValue('ID'))
self.ui.editName.setText(fetchValue('Name'))
self.ui.editType.setText(fetchValue('Type'))
self.ui.editPrice.setText(fetchValue('Price'))
dt = QDateTime.fromString(fetchValue('Time'), "yyyy-MM-dd HH:mm:ss")
if not dt.isValid():
dt = QDateTime.currentDateTime()
self.ui.editTime.setDateTime(dt)
self.ui.editComments.setText(fetchValue('Comments'))
self.ui.editPic.setText(fetchValue('Pic'))
catMatches = [k for k in categories if fetchValue('Category') == k]
if len(catMatches) == 0:
self.ui.comboCategory.setCurrentIndex(0)
else:
self.ui.comboCategory.setCurrentIndex(categories.index(catMatches[0]))
def test_existing_complex_keywords(self):
"""Test for existing complex keywords in wizard in locale mode."""
from safe.gui.tools.wizard_dialog import WizardDialog
from safe.test.utilities import (
clone_shp_layer, remove_vector_temp_file)
layer = clone_shp_layer(
name='tsunami_polygon', include_keywords=True, source_directory='')
from safe.test.utilities import get_qgis_app
# Get QGis app handle
# noinspection PyPep8Naming
_, _, IFACE, PARENT = get_qgis_app()
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# select hazard
self.select_from_list_widget('ancaman', dialog.lstCategories)
dialog.pbnNext.click()
# select volcano
self.select_from_list_widget('gunung berapi', dialog.lstSubcategories)
dialog.pbnNext.click()
# select volcano categorical unit
self.select_from_list_widget('Kategori gunung berapi', dialog.lstUnits)
dialog.pbnNext.click()
# select GRIDCODE
self.select_from_list_widget('GRIDCODE', dialog.lstFields)
dialog.pbnNext.click()
unit = dialog.selected_unit()
default_classes = unit['classes']
unassigned_values = [] # no need to check actually, not save in file
assigned_values = {
'low': ['5.0'],
'medium': ['3.0', '4.0'],
'high': ['2.0']
}
dialog.populate_classified_values(
unassigned_values, assigned_values, default_classes)
dialog.pbnNext.click()
source = 'Source'
source_scale = 'Source Scale'
source_url = 'Source Url'
source_date = QDateTime.fromString(
'06-12-2015 12:30',
'dd-MM-yyyy HH:mm')
dialog.leSource.setText(source)
dialog.leSource_scale.setText(source_scale)
dialog.leSource_url.setText(source_url)
dialog.leSource_date.seDateTime(source_date)
dialog.pbnNext.click() # next
dialog.pbnNext.click() # finish
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# step 1 of 7 - select category
self.check_current_text('ancaman', dialog.lstCategories)
# Click Next
dialog.pbnNext.click()
# step 2 of 7 - select subcategory
# noinspection PyTypeChecker
self.check_current_text('gunung berapi', dialog.lstSubcategories)
# Click Next
dialog.pbnNext.click()
# step 3 of 7 - select volcano units
self.check_current_text('Kategori gunung berapi', dialog.lstUnits)
# Click Next
dialog.pbnNext.click()
# step 4 of 7 - select field
self.check_current_text('GRIDCODE', dialog.lstFields)
# Click Next
dialog.pbnNext.click()
for index in range(dialog.lstUniqueValues.count()):
message = ('%s Should be in unassigned values' %
dialog.lstUniqueValues.item(index).text())
self.assertIn(
dialog.lstUniqueValues.item(index).text(),
unassigned_values,
message)
real_assigned_values = dialog.selected_mapping()
self.assertDictEqual(real_assigned_values, assigned_values)
# Click Next
dialog.pbnNext.click()
# step 6 of 7 - enter source
message = ('Invalid Next button state in step 6! Disabled while '
'source is optional')
self.assertTrue(dialog.pbnNext.isEnabled(), message)
message = 'Source should be %s' % source
self.assertEqual(dialog.leSource.text(), source, message)
message = 'Source Url should be %s' % source_url
self.assertEqual(dialog.leSource_url.text(), source_url, message)
message = 'Source Date should be %s' % source_date.toString(
'dd-MM-yyyy HH:mm')
self.assertEqual(dialog.leSource_date.dateTime(), source_date, message)
message = 'Source Scale should be %s' % source_scale
self.assertEqual(dialog.leSource_scale.text(), source_scale, message)
dialog.pbnNext.click()
dialog.pbnCancel.click()
remove_vector_temp_file(layer.source())
def fill_field(self):
"""
Fill field with sensor info
"""
self.clear_layout(self.editFrame.layout())
self.nameBox.setText(self.oat.name)
self.descBox.clear()
self.descBox.appendPlainText(self.oat.desc)
self.latBox.setValue(self.oat.lat)
self.lonBox.setValue(self.oat.lon)
self.freqBox.setText(self.oat.freq)
if not self.oat.alt:
self.altBox.setValue(0)
else:
self.altBox.setValue(self.oat.alt)
if not self.oat.tz:
self.tzBox.setValue(0)
else:
if ":" in self.oat.tz:
self.tzBox.setValue(int(self.oat.tz.split(':')[0]))
else:
self.tzBox.setValue(int(self.oat.tz))
self.opBox.setText(self.oat.prop)
self.uomBox.setText(self.oat.unit)
if self.oat.bottomscreen:
self.bottomScreenBox.setValue(self.oat.bottomscreen)
else:
self.bottomScreenBox.setValue(0.0)
if self.oat.topscreen:
self.topScreenBox.setValue(self.oat.topscreen)
else:
self.topScreenBox.setValue(0.0)
if self.oat.use > 0:
self.useBox.setCheckState(Qt.Checked)
self.statBox.setText(self.oat.statflag)
if not self.oat.ts.empty:
chart = MatplotWidget(toolbar=True)
chart.set_data(self.oat, qi=True)
self.clear_layout(self.dataPreview)
self.dataPreview.addWidget(chart)
if self.oat.data_availability[0]:
beg = self.oat.data_availability[0].replace("T", " ")
end = self.oat.data_availability[1].replace("T", " ")
if beg[-3] == ':':
beg = beg[:-6]
end = end[:-6]
else:
beg = beg[:-5]
end = end[:-5]
begin_pos = QDateTime.fromString(beg, "yyyy-MM-dd hh:mm:ss")
end_pos = QDateTime.fromString(end, "yyyy-MM-dd hh:mm:ss")
self.beginPositionBox.setDateTime(begin_pos)
self.endPositionBox.setDateTime(end_pos)
def setEditorValue(self, editor, value):
editor.setDateTime(QDateTime.fromString(value, "yyyy-MM-dd HH:mm:ss"))
def parse(self, xml):
def _float(value):
try:
return float(value)
except:
return None
components = {}
for member, _ in self.search(xml, "member"):
for node, tag in self.search(member, "Observation/*"):
if tag == "samplingTime":
samplingTime = self.timeParser.parse(node)
elif tag == "observedProperty":
_, prop = self.searchFirst(node, "@href")
if prop:
if not prop in components: components[prop] = None
else:
for _, prop in self.search(
node, "CompositePhenomenon/component@href"):
if not prop in components: components[prop] = None
elif tag == "featureOfInterest":
hasSamplingPoint = False
for point, foi_id in chain(
self.search(
node,
"FeatureCollection/featureMember/SamplingPoint@id"
), self.search(node, "SamplingPoint@id"),
self.search(node, "SamplingPointAtDepth@id")):
hasSamplingPoint = True
_, name = self.searchFirst(point, "name")
pointGeo, _ = self.searchFirst(point, "position")
pointGeo = GMLParser.geometryFromGML(pointGeo)
if self.yx:
pointGeo = pointGeo.asPoint()
pointGeo = QgsGeometry.fromPoint(
QgsPoint(pointGeo.y(), pointGeo.x()))
self.provider.features[foi_id] = (name, pointGeo)
if point.localName() == "SamplingPointAtDepth":
_, depth = self.searchFirst(point, "depth")
foi_id = (foi_id, depth)
if not hasSamplingPoint:
for _, foi_id in self.search(
node, "FeatureCollection/featureMember@href"):
self.provider.features[foi_id] = (foi_id, None)
elif tag == "result":
node, tag = self.searchFirst(node, "*")
if tag == "DataArray":
simpleDataRecord = []
for fieldNode, field in chain(
self.search(
node,
"elementType/SimpleDataRecord/field@name"),
self.search(
node,
"elementType/DataRecord/field@name")):
simpleDataRecord.append(field)
fieldNode, definition = self.searchFirst(
fieldNode, "*/@definition")
if definition in components and components[
definition] == None:
if fieldNode.localName() == "Quantity":
fieldType = QVariant.Double
_, definition = self.searchFirst(
fieldNode, "uom@code")
elif fieldNode.localName() == "Time":
fieldType = QVariant.String
else:
fieldType = QVariant.String
components[definition] = QgsField(
field, fieldType, definition)
encoding, _ = self.searchFirst(node, "encoding")
_, blockSeparator = self.searchFirst(
encoding, "TextBlock@blockSeparator")
_, tokenSeparator = self.searchFirst(
encoding, "TextBlock@tokenSeparator")
_, values = self.searchFirst(node, "values")
try:
indexes = map(simpleDataRecord.index,
["feature", "Time"])
except:
indexes = None
if not indexes:
try:
indexes = map(
simpleDataRecord.index,
["FeatureOfInterest", "SamplingTime"])
except:
indexes = None
if not indexes:
raise ValueError('SimpleDataRecord = ' +
str(simpleDataRecord))
map(simpleDataRecord.pop, indexes)
for block in filter(lambda x: len(x),
values.split(blockSeparator)):
observation = block.split(tokenSeparator)
observationKeys = map(observation.pop, indexes)
map(
lambda prop, value: self.provider.
setObservation(
unicode(observationKeys[0]),
QDateTime.fromString(
observationKeys[1], Qt.ISODate),
unicode(prop), str(value)),
simpleDataRecord, observation)
return components
def prettyTimeString(self, dateTimeString):
dateTimeString = QString(dateTimeString).remove(QRegExp('\.\d+$'))
return QDateTime.fromString(dateTimeString, 'yyyy-MM-dd HH:mm:ss').toString('h:mm ap')
def __init__(self, filepath):
tree = ET.parse(filepath)
root = tree.getroot()
self.data = {}
for child in root:
# project
if child.tag == 'P_T':
self.data[child.find('P_ID').text] = dict(
RootPath=os.path.dirname(filepath),
Name=self.getValue(child, 'P_Name'),
Date=QDateTime.fromString(self.getValue(child, 'P_Date'), 'dd.MM.yyyy hh:mm:ss'),
Channel='',
Sections={})
#print child.find('P_Name').text
# section
if child.tag == 'S_T':
self.data[child.find('S_Project_ID').text]['Sections'][child.find('S_ID').text] = dict(
QgepChannelId1=None,
QgepChannelId2=None,
QgepChannelId3=None,
UsePreviousSection=False,
Counter=self.getValue(child, 'S_Counter'),
StartNode=self.getValue(child, 'S_StartNode'),
EndNode=self.getValue(child, 'S_EndNode'),
Sectionlength=float(self.getValue(child, 'S_Sectionlength')),
SectionUse=self.getValue(child, 'S_SectionUse'),
PipeMaterial=self.getValue(child, 'S_PipeMaterial'),
Profile=self.getValue(child, 'S_Profile'),
PipeDia=float(self.getValue(child, 'S_PipeDia')),
PipeWidth=float(self.getValue(child, 'S_PipeWidth')),
#Medianumber=self.getValue(child, 'S_Medianumber'), # do not exist in XML
Inspections={},
Import=True)
# inspection
if child.tag == 'SI_T':
found = False
for p_id, project in self.data.items():
for s_id in project['Sections']:
if s_id == child.find('SI_Section_ID').text:
self.data[p_id]['Sections'][s_id]['Inspections'][child.find('SI_ID').text] = dict(
InspMethod=self.getValue(child, 'SI_InspMethod'),
InspectionDir=self.getValue(child, 'SI_InspectionDir'),
CodeInspectionDir=self.getValue(child, 'CodeSI_InspectionDir'),
InspectedLength=float(self.getValue(child, 'SI_InspectedLength') or 0),
Operator=self.getValue(child, 'SI_Operator'),
Weather=self.getValue(child, 'SI_Weather'),
InclinationFileName=self.getValue(child, 'SI_InclinationFileName'),
Cleaned=self.getValue(child, 'SI_Cleaned'),
InspDate=QDate.fromString(self.getValue(child, 'SI_InspDate'), 'dd.MM.yyyy'),
VideoName=self.getValue(child, 'SI_Virtual_x007E_ClipFilename'),
Observations={},
Import=True)
found = True
break
if found: break
if not found:
raise ValueError('insepction has no section')
# observation
if child.tag == 'SO_T':
found = False
for p_id, project in self.data.items():
for s_id, section in project['Sections'].items():
for i_id in section['Inspections']:
if i_id == child.find('SO_Inspecs_ID').text:
code = self.getValue(child, 'SO_OpCode')
PhotoFilenames = []
i = 1
while True:
pf = self.getValue(child, 'SO_PhotoFilename{}'.format(i))
i += 1
if pf is None:
break
PhotoFilenames.append(pf)
self.data[p_id]['Sections'][s_id]['Inspections'][i_id]['Observations'][child.find('SO_ID').text] = dict(
Counter=self.getValue(child, 'SO_Counter'),
Position=float(self.getValue(child, 'SO_Position')),
ToGoMeter=self.getValue(child, 'SO_ToGoMeter'),
Text=self.getValue(child, 'SO_Text'),
MPEGPosition=self.getValue(child, 'SO_MPEGPosition'),
PhotoFilename=PhotoFilenames,
Rate=int(round(float(self.getValue(child, 'SO_Rate') or 4))),
OpCode=code,
ClipFileName1=self.getValue(child, 'SO_ClipFileName1'),
Quant1=self.getValue(child, 'SO_Quant1'),
Quant2=self.getValue(child, 'SO_Quant2'),
Quant1Unit=self.getValue(child, 'SO_Quant1Unit'),
Quant2Unit=self.getValue(child, 'SO_Quant2Unit'),
ObservCode=self.getValue(child, 'SO_ObservCode'),
BendAngleDeg=self.getValue(child, 'SO_BendAngleDeg'),
BendClockH=self.getValue(child, 'SO_BendClockH'),
Import=True if code is not None and code not in SkipCode else False,
ForceImport=False) # force import if observation is out of channel (channel too short)
found = True
break
if found: break
if not found:
raise ValueError('observation has no insepction')
# order elements by counter
for p_id in self.data.keys():
self.data[p_id]['Sections'] = OrderedDict(sorted(self.data[p_id]['Sections'].items(), key=lambda t: int(t[1]['Counter'])))
for s_id in self.data[p_id]['Sections'].keys():
for i_id in self.data[p_id]['Sections'][s_id]['Inspections'].keys():
self.data[p_id]['Sections'][s_id]['Inspections'][i_id]['Observations'] = OrderedDict( sorted(self.data[p_id]['Sections'][s_id]['Inspections'][i_id]['Observations'].items(), key=lambda t: t[1]['Position']) )
def main():
import argparse
import sys
parser = argparse.ArgumentParser(
description='Export referrals for hospitalization in Krasnodar area.')
parser.add_argument('-u', dest='user', default='dbuser')
parser.add_argument('-P', dest='password')
parser.add_argument('-t', dest='datetime', default=None)
parser.add_argument('-a', dest='host', default='127.0.0.1')
parser.add_argument('-p', dest='port', type=int, default='3306')
parser.add_argument('-d', dest='database', default='s11')
parser.add_argument('-D', dest='dir', default=os.getcwd())
parser.add_argument('-T', dest='exportType')
parser.add_argument('-c', dest='orgCode', default='07526')
args = vars(parser.parse_args(sys.argv[1:]))
exportType = forceInt(args['exportType'])
if not args['user']:
print 'Error: you should specify user name'
sys.exit(-1)
if not args['password']:
print 'Error: you should specify password'
sys.exit(-2)
if not args['exportType'] or exportType not in (1, 2, 3, 5, 6):
print 'Error: you should specify correct export type'
sys.exit(-3)
if not args['orgCode']:
print 'Error: you should specify organisation ID'
sys.exit(-5)
app = QtCore.QCoreApplication(sys.argv)
dateTime = QDateTime.currentDateTime()
begDateTime = args['datetime']
begDateTime = QDateTime.fromString(
begDateTime,
'yyyy-MM-ddTHH:mm:ss') if begDateTime else QDateTime.currentDateTime(
) # QDateTime.currentDateTime().addSecs(-60)
if not (begDateTime is None or begDateTime.isValid()):
print 'Error: incorrect base datetime.'
sys.exit(-4)
connectionInfo = {
'driverName': 'MYSQL',
'host': args['host'],
'port': args['port'],
'database': args['database'],
'user': args['user'],
'password': args['password'],
'connectionName': 'HospRefs',
'compressData': True,
'afterConnectFunc': None
}
db = connectDataBaseByInfo(connectionInfo)
QtGui.qApp.db = db
if exportType == 1:
refName = u'SendPlanOrdersClinic_%s'
elif exportType == 2:
refName = u'SendFactOrdersHospital_%s'
elif exportType == 3:
refName = u'SendOrdersHospitalUrgently_%s'
elif exportType == 5:
refName = u'SendOrdersLeave_%s'
elif exportType == 6:
refName = u'SendKDInformation_%s'
name = u'ReferralForHospitalization_%s.xml' % refName
fileName = name % (dateTime.toString('yyMMddThhmmss.zzz'))
fullFileName = os.path.join(forceStringEx(args['dir']), fileName)
outFile = QtCore.QFile(fullFileName)
outFile.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text)
exporter = CReferralForHospitalization(None, args['orgCode'], begDateTime)
exporter.setCodec(QtCore.QTextCodec.codecForName('cp1251'))
exporter.writeFileHeader(outFile)
exporter.writeSend(exportType, dateTime)
exporter.writeFileFooter()
outFile.close()
if exporter.emptyExport:
os.remove(fullFileName)
def parse (self, xml):
def _float (value):
try: return float(value)
except: return None
components = {}
for member, _ in self.search(xml, "member"):
for node, tag in self.search (member, "Observation/*"):
if tag == "samplingTime":
samplingTime = self.timeParser.parse(node)
elif tag == "observedProperty":
_, prop = self.searchFirst(node, "@href")
if prop:
if not prop in components: components[prop] = None
else:
for _, prop in self.search (node, "CompositePhenomenon/component@href"):
if not prop in components: components[prop] = None
elif tag == "featureOfInterest":
hasSamplingPoint = False
for point, foi_id in chain(self.search (node, "FeatureCollection/featureMember/SamplingPoint@id"),self.search (node, "SamplingPoint@id"),self.search (node, "SamplingPointAtDepth@id")):
hasSamplingPoint = True
_, name = self.searchFirst (point, "name")
pointGeo, _ = self.searchFirst(point, "position")
pointGeo = GMLParser.geometryFromGML(pointGeo)
if self.yx:
pointGeo = pointGeo.asPoint()
pointGeo = QgsGeometry.fromPoint(QgsPoint (pointGeo.y(),pointGeo.x()))
self.provider.features [foi_id] = (name, pointGeo)
if point.localName () == "SamplingPointAtDepth":
_, depth = self.searchFirst (point, "depth")
foi_id = (foi_id, depth)
if not hasSamplingPoint:
for _, foi_id in self.search (node, "FeatureCollection/featureMember@href"):
self.provider.features [foi_id] = (foi_id, None)
elif tag == "result":
node, tag = self.searchFirst(node, "*")
if tag == "DataArray":
simpleDataRecord = []
for fieldNode, field in chain(self.search(node, "elementType/SimpleDataRecord/field@name"),self.search(node, "elementType/DataRecord/field@name")):
simpleDataRecord.append(field)
fieldNode, definition = self.searchFirst(fieldNode, "*/@definition")
if definition in components and components[definition] == None:
if fieldNode.localName () == "Quantity":
fieldType = QVariant.Double
_, definition = self.searchFirst (fieldNode, "uom@code")
elif fieldNode.localName () == "Time":
fieldType = QVariant.String
else:
fieldType = QVariant.String
components[definition] = QgsField (field, fieldType, definition)
encoding, _ = self.searchFirst (node, "encoding")
_, blockSeparator = self.searchFirst (encoding, "TextBlock@blockSeparator")
_, tokenSeparator = self.searchFirst (encoding, "TextBlock@tokenSeparator")
_, values = self.searchFirst (node, "values")
try:
indexes = map(simpleDataRecord.index, ["feature", "Time"])
except:
indexes = None
if not indexes:
try:
indexes = map(simpleDataRecord.index, ["FeatureOfInterest","SamplingTime"])
except:
indexes = None
if not indexes:
raise ValueError('SimpleDataRecord = ' + str(simpleDataRecord))
map(simpleDataRecord.pop, indexes)
for block in filter (lambda x: len(x), values.split (blockSeparator)):
observation = block.split(tokenSeparator)
observationKeys = map(observation.pop, indexes)
map (lambda prop, value: self.provider.setObservation (unicode(observationKeys[0]), QDateTime.fromString(observationKeys[1], Qt.ISODate), unicode(prop), str(value)), simpleDataRecord, observation)
return components
def test_existing_complex_keywords(self):
"""Test for existing complex keywords in wizard in locale mode."""
from safe.gui.tools.wizard_dialog import WizardDialog
from safe.test.utilities import clone_shp_layer, remove_vector_temp_file
layer = clone_shp_layer(name="tsunami_polygon", include_keywords=True, source_directory="")
from safe.test.utilities import get_qgis_app
# Get QGis app handle
# noinspection PyPep8Naming
_, _, IFACE, PARENT = get_qgis_app()
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# select hazard
self.select_from_list_widget("ancaman", dialog.lstCategories)
dialog.pbnNext.click()
# select volcano
self.select_from_list_widget("gunung berapi", dialog.lstSubcategories)
dialog.pbnNext.click()
# select volcano categorical unit
self.select_from_list_widget("Kategori gunung berapi", dialog.lstUnits)
dialog.pbnNext.click()
# select GRIDCODE
self.select_from_list_widget("GRIDCODE", dialog.lstFields)
dialog.pbnNext.click()
unit = dialog.selected_unit()
default_classes = unit["classes"]
unassigned_values = [] # no need to check actually, not save in file
assigned_values = {"low": ["5.0"], "medium": ["3.0", "4.0"], "high": ["2.0"]}
dialog.populate_classified_values(unassigned_values, assigned_values, default_classes)
dialog.pbnNext.click()
source = "Source"
source_scale = "Source Scale"
source_url = "Source Url"
source_date = QDateTime.fromString("06-12-2015 12:30", "dd-MM-yyyy HH:mm")
dialog.leSource.setText(source)
dialog.leSource_scale.setText(source_scale)
dialog.leSource_url.setText(source_url)
dialog.leSource_date.seDateTime(source_date)
dialog.pbnNext.click() # next
dialog.pbnNext.click() # finish
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# step 1 of 7 - select category
self.check_current_text("ancaman", dialog.lstCategories)
# Click Next
dialog.pbnNext.click()
# step 2 of 7 - select subcategory
# noinspection PyTypeChecker
self.check_current_text("gunung berapi", dialog.lstSubcategories)
# Click Next
dialog.pbnNext.click()
# step 3 of 7 - select volcano units
self.check_current_text("Kategori gunung berapi", dialog.lstUnits)
# Click Next
dialog.pbnNext.click()
# step 4 of 7 - select field
self.check_current_text("GRIDCODE", dialog.lstFields)
# Click Next
dialog.pbnNext.click()
for index in range(dialog.lstUniqueValues.count()):
message = "%s Should be in unassigned values" % dialog.lstUniqueValues.item(index).text()
self.assertIn(dialog.lstUniqueValues.item(index).text(), unassigned_values, message)
real_assigned_values = dialog.selected_mapping()
self.assertDictEqual(real_assigned_values, assigned_values)
# Click Next
dialog.pbnNext.click()
# step 6 of 7 - enter source
message = "Invalid Next button state in step 6! Disabled while " "source is optional"
self.assertTrue(dialog.pbnNext.isEnabled(), message)
message = "Source should be %s" % source
self.assertEqual(dialog.leSource.text(), source, message)
message = "Source Url should be %s" % source_url
self.assertEqual(dialog.leSource_url.text(), source_url, message)
message = "Source Date should be %s" % source_date.toString("dd-MM-yyyy HH:mm")
self.assertEqual(dialog.leSource_date.dateTime(), source_date, message)
message = "Source Scale should be %s" % source_scale
self.assertEqual(dialog.leSource_scale.text(), source_scale, message)
dialog.pbnNext.click()
dialog.pbnCancel.click()
remove_vector_temp_file(layer.source())
def test_existing_complex_keywords(self):
"""Test for existing complex keywords in wizard in locale mode."""
from safe.test.utilities import (
clone_shp_layer, remove_vector_temp_file)
layer = clone_shp_layer(
name='tsunami_polygon', include_keywords=True, source_directory='')
from safe.test.utilities import get_qgis_app
# Get QGis app handle
# noinspection PyPep8Naming
_, _, IFACE, PARENT = get_qgis_app()
from safe.gui.tools.wizard.wizard_dialog import WizardDialog
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# select hazard
self.select_from_list_widget('ancaman',
dialog.step_kw_purpose.lstCategories)
dialog.pbnNext.click()
# select volcano
self.select_from_list_widget('gunung berapi', dialog.
step_kw_subcategory.lstSubcategories)
dialog.pbnNext.click()
# select volcano categorical unit
self.select_from_list_widget('Kategori gunung berapi',
dialog.step_kw_unit.lstUnits)
dialog.pbnNext.click()
# select GRIDCODE
self.select_from_list_widget(
'GRIDCODE', dialog.step_kw_field.lstFields)
dialog.pbnNext.click()
unit = dialog.step_kw_unit.selected_unit()
default_classes = unit['classes']
unassigned_values = [] # no need to check actually, not save in file
assigned_values = {
'low': ['5.0'],
'medium': ['3.0', '4.0'],
'high': ['2.0']
}
dialog.step_kw_classify.populate_classified_values(
unassigned_values, assigned_values, default_classes)
dialog.pbnNext.click()
source = 'Source'
source_scale = 'Source Scale'
source_url = 'Source Url'
source_date = QDateTime.fromString(
'06-12-2015 12:30',
'dd-MM-yyyy HH:mm')
dialog.step_kw_source.leSource.setText(source)
dialog.step_kw_source.leSource_scale.setText(source_scale)
dialog.step_kw_source.leSource_url.setText(source_url)
dialog.step_kw_source.leSource_date.seDateTime(source_date)
dialog.pbnNext.click() # next
dialog.pbnNext.click() # finish
# noinspection PyTypeChecker
dialog = WizardDialog(PARENT, IFACE)
dialog.set_keywords_creation_mode(layer)
# step 1 of 7 - select category
self.check_current_text(
'ancaman', dialog.step_kw_purpose.lstCategories)
# Click Next
dialog.pbnNext.click()
# step 2 of 7 - select subcategory
# noinspection PyTypeChecker
self.check_current_text('gunung berapi',
dialog.step_kw_subcategory.lstSubcategories)
# Click Next
dialog.pbnNext.click()
# step 3 of 7 - select volcano units
self.check_current_text('Kategori gunung berapi',
dialog.step_kw_unit.lstUnits)
# Click Next
dialog.pbnNext.click()
# step 4 of 7 - select field
self.check_current_text('GRIDCODE', dialog.step_kw_field.lstFields)
# Click Next
dialog.pbnNext.click()
for index in range(dialog.step_classify.lstUniqueValues.count()):
message = ('%s Should be in unassigned values' %
dialog.step_classify.lstUniqueValues.item(index).text())
self.assertIn(
dialog.step_classify.lstUniqueValues.item(index).text(),
unassigned_values,
message)
real_assigned_values = dialog.step_classify.selected_mapping()
self.assertDictEqual(real_assigned_values, assigned_values)
# Click Next
dialog.pbnNext.click()
# step 6 of 7 - enter source
message = ('Invalid Next button state in step 6! Disabled while '
'source is optional')
self.assertTrue(dialog.pbnNext.isEnabled(), message)
message = 'Source should be %s' % source
self.assertEqual(
dialog.step_kw_source.leSource.text(), source, message)
message = 'Source Url should be %s' % source_url
self.assertEqual(dialog.step_kw_source.leSource_url.text(),
source_url, message)
message = 'Source Date should be %s' % source_date.toString(
'dd-MM-yyyy HH:mm')
self.assertEqual(dialog.step_kw_source.leSource_date.dateTime(),
source_date, message)
message = 'Source Scale should be %s' % source_scale
self.assertEqual(dialog.step_kw_source.leSource_scale.text(),
source_scale, message)
dialog.pbnNext.click()
dialog.pbnCancel.click()
remove_vector_temp_file(layer.source())
def main():
import argparse
import sys
parser = argparse.ArgumentParser(description='')
parser.add_argument('-u', dest='user', default='dbuser')
parser.add_argument('-P', dest='password')
parser.add_argument('-t', dest='datetime', default=None)
parser.add_argument('-a', dest='host', default='37.44.41.26')
parser.add_argument('-p', dest='port', type=int, default='63306')
parser.add_argument('-d', dest='database', default='iemk')
parser.add_argument('-D', dest='dir', default=os.getcwd())
parser.add_argument('-T', dest='type', default='c')
args = vars(parser.parse_args(sys.argv[1:]))
if not args['user']:
print 'Error: you should specify user name'
sys.exit(-1)
if not args['password']:
print 'Error: you should specify password'
sys.exit(-2)
app = QtCore.QCoreApplication(sys.argv)
connectionInfo = {
'driverName': 'MYSQL',
'host': args['host'],
'port': args['port'],
'database': args['database'],
'user': args['user'],
'password': args['password'],
'connectionName': 'IEMK',
'compressData': True,
'afterConnectFunc': None
}
db = connectDataBaseByInfo(connectionInfo)
QtGui.qApp.db = db
curDateTime = QtCore.QDateTime.currentDateTime()
dt = args['datetime']
dt = QDateTime.fromString(
dt, 'yyyy-MM-ddTHH:mm:ss') if dt else curDateTime.addSecs(-86400)
typeDatetime = args['type']
if typeDatetime == 'c':
strTypeDatetime = u'Client.createDatetime'
typeFlag = 0
elif typeDatetime == 'm':
strTypeDatetime = u'Client.modifyDatetime'
typeFlag = 1
else:
print 'Error: wrong type'
sys.exit(-4)
stmt = '''
SELECT Client.id as clientId,
Client.lastName,
Client.firstName,
Client.patrName,
rbContactType.code as contactTypeCode,
ClientContact.contact as contactClient,
Client.sex,
Client.birthDate,
Client.birthTime,
AddressHouse.KLADRCode,
AddressHouse.KLADRStreetCode,
AddressHouse.number as houseNumber,
AddressHouse.corpus as houseCorpus,
ClientAddress.freeInput as freeInput,
Address.flat as flat,
Client.SNILS,
ClientPolicy.serial as policySerial,
ClientPolicy.number as policyNumber,
ClientPolicy.begDate as policyBegDate,
Organisation.fullName as insurerName,
Organisation.obsoleteInfisCode as insurerCode,
ClientDocument.serial as documentSerial,
ClientDocument.number as documentNumber,
ClientDocument.date as documentDate,
ClientDocument.origin as documentOrg,
Client.birthPlace,
Organisation.phone as orgPhone,
rbDocumentType.federalCode as docTypeCode
FROM Client
LEFT JOIN ClientContact ON ClientContact.client_id = Client.id AND ClientContact.deleted = 0
LEFT JOIN rbContactType ON rbContactType.id = ClientContact.contactType_id
LEFT JOIN ClientAddress ON ClientAddress.id = getClientRegAddressId(Client.id)
LEFT JOIN Address ON Address.id = ClientAddress.address_id AND Address.deleted = 0
LEFT JOIN AddressHouse ON AddressHouse.id = Address.house_id AND AddressHouse.deleted = 0
LEFT JOIN ClientPolicy ON ClientPolicy.id = getClientPolicyId(Client.id, 1)
LEFT JOIN Organisation ON Organisation.id = ClientPolicy.insurer_id AND Organisation.deleted = 0
LEFT JOIN ClientDocument ON ClientDocument.client_id = Client.id AND ClientDocument.deleted = 0
LEFT JOIN rbDocumentType ON rbDocumentType.id = ClientDocument.documentType_id AND rbDocumentType.code = 1
WHERE (%s >= TIMESTAMP('%s') OR IFNULL(TIMESTAMP(Client.notes), TIMESTAMP('0000-00-00')) >= TIMESTAMP('%s')) AND Client.deleted = 0
''' % (strTypeDatetime, dt.toString('yyyy-MM-dd hh:mm:ss'),
dt.toString('yyyy-MM-dd hh:mm:ss'))
query = db.query(stmt)
if query.size() > 0:
if typeFlag == 0:
fileName = u'RCIEMK_%s.xml' % (
curDateTime.toString('yyMMddThhmmss.zzz'))
elif typeFlag == 1:
fileName = u'RMIEMK_%s.xml' % (
curDateTime.toString('yyMMddThhmmss.zzz'))
if not (dt is None or dt.isValid()):
print 'Error: incorrect base datetime.'
sys.exit(-4)
outFile = QtCore.QFile(
os.path.join(forceStringEx(args['dir']), fileName))
outFile.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text)
clientsOut = CRegistryClientInIEMK(None)
clientsOut.setCodec(QtCore.QTextCodec.codecForName('cp1251'))
clientsOut.writeFileHeader(outFile)
clientsOut.writeRegistryClientInIEMK(query, curDateTime, typeFlag)
clientsOut.writeFileFooter()
outFile.close()
def process_result_value(self, value, dialect):
if value:
return QDateTime.fromString(value.isoformat(),
'yyyy-MM-ddTHH:mm:ss')
else:
return None
def init_date(self):
today = datetime.date.today()
date_end = str(today) + ' 00:00:00'
self.dt_EndTime_StayUser.setDateTime(QDateTime.fromString(date_end, 'yyyy-MM-dd hh:mm:ss'))
from_day = str(today + datetime.timedelta(-14)) + ' 00:00:00'
self.dt_FromTime_StayUser.setDateTime(QDateTime.fromString(from_day, 'yyyy-MM-dd hh:mm:ss'))
def restoreValue(self, fail=None):
valtype = self.attribute('type')
value = None
# Restore a list item
if (valtype == 'list'):
value = []
for child in self.children():
value.append(child.restoreValue())
# Restore a dictionary item
elif (valtype == 'dict'):
value = {}
for child in self.children():
value[child.attribute('key')] = child.restoreValue()
# Record a qdatetime
elif (valtype == 'QDateTime'):
value = QDateTime.fromString(self.attribute('value'),
'yyyy-MM-dd hh:mm:ss')
# Record a qdate
elif (valtype == 'QDate'):
value = QDate.fromString(self.attribute('value'), 'yyyy-MM-dd')
# Restore a QRect
elif (valtype == 'QRect'):
value = self.findRect('rect')
# Restore a QRectF
elif (valtype == 'QRectF'):
value = self.findRectF('rect')
# Restore a QSize
elif (valtype == 'QSize'):
value = self.findSize('size')
# Restore a QSizeF
elif (valtype == 'QSizeF'):
value = self.findSizeF('size')
# Restore a QPoint
elif (valtype == 'QPoint'):
value = self.findPoint('point')
# Restore a QPointF
elif (valtype == 'QPointF'):
value = self.findPointF('point')
# Restore a QColor
elif (valtype == 'QColor'):
value = self.findColor('color')
# restore a QFont
elif (valtype == 'QFont'):
value = QFont()
value.fromString(self.attribute('value'))
# Restore a string
elif (valtype in ('str', 'unicode', 'QString')):
value = unicode(self.attribute('value'))
elif (valtype == 'ViewMode'):
# If treated as a basic value would return fail
value = int(self.attribute('value'))
# Restore a QByteArray (Experimental)
elif (valtype == 'QByteArray'):
value = QByteArray.fromPercentEncoding(self.attribute('value', ''))
# Restore a Qt.CheckState
elif valtype == 'CheckState':
value = Qt.CheckState(self.attribute('value', 0))
# Restore a basic value
else:
try:
value = eval('%s(%s)' % (valtype, self.attribute('value')))
except:
value = fail
return value
