def toQDateTime(dt):
if isinstance(dt, datetime.date):
return QDateTime(Serializeable.toQDate(dt), QTime())
elif isinstance(dt, datetime.datetime):
return QDateTime(Serializeable.toQDate(dt),
QTime(dt.hour, dt.minute, dt.second))
return QDateTime()
def datetimeFromJSON(strDatetime):
try:
pyDT = datetime.datetime.strptime(
strDatetime, "%Y-%m-%dT%H:%M:%S.%fZ") if strDatetime else None
except ValueError:
pyDT = datetime.datetime.strptime(
strDatetime, "%Y-%m-%dT%H:%M:%SZ") if strDatetime else None
return QDateTime(pyDT.year, pyDT.month, pyDT.day, pyDT.hour,
pyDT.minute, pyDT.second) if pyDT else QDateTime()
def testDateTimeWriteTabfile(self):
"""Check writing date and time fields to an MapInfo tabfile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test', 'memory')
assert ml is not None, 'Provider not initialised'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributes([
1,
QDate(2014, 3, 5),
QTime(13, 45, 22),
QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))
])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.tab')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'MapInfo File')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name),
u'test', u'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
self.assertEqual(
fields.at(fields.indexFromName('time_f')).type(), QVariant.Time)
self.assertEqual(
fields.at(fields.indexFromName('dt_f')).type(), QVariant.DateTime)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex('date_f')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fieldNameIndex('time_f')
assert isinstance(f.attributes()[time_idx], QTime)
self.assertEqual(f.attributes()[time_idx], QTime(13, 45, 22))
datetime_idx = created_layer.fieldNameIndex('dt_f')
assert isinstance(f.attributes()[datetime_idx], QDateTime)
self.assertEqual(f.attributes()[datetime_idx],
QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)))
def forceDateTime(val):
if isinstance(val, QVariant):
return val.toDateTime()
if isinstance(val, QDateTime):
return val
if isinstance(val, QDate):
return QDateTime(val, QTime())
if isinstance(val, QTime):
return QDateTime(QDate(), val)
if val is None:
return QDateTime()
return QDateTime(val)
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 __init__(self, parent=None):
super(TSDateWidget, self).__init__(parent=parent)
self.setupUi(self)
self.setWindowTitle("TSAnalyzer - Date Tool")
self.mjd = 51544.5
self.julday = 2451545
self.demical_year = 2000.0
self.doy = "2000-001"
self.date = datetime(2000, 1, 1, 12)
self.dateEdit.setDateTime(QDateTime(2000, 1, 1, 12, 0))
self.conversionButton.clicked.connect(self._click_conversionButton)
self.ydEdit.setInputMask("9999-999")
self.dyEdit.setInputMask("9999.9999")
self.mjdEdit.setValue(51544.5)
self.juldayEdit.setInputMask("9999999")
self.gpsweekEdit.setInputMask("99999")
self.radios = [
self.dateRadio, self.mjdRadio, self.juldayRadio, self.dyRadio,
self.ydRadio, self.gpsweekRadio
]
self.edits = [
self.dateEdit, self.mjdEdit, self.juldayEdit, self.dyEdit,
self.ydEdit, self.gpsweekEdit
]
def dateTimeStart(self):
"""
Returns a merging of data from the date end with the date start.
:return <QDateTime>
"""
return QDateTime(self.dateStart(), self.timeStart())
def dateTimeEnd(self):
"""
Returns a merging of data from the date end with the time end.
:return <QDateTime>
"""
return QDateTime(self.dateEnd(), self.timeEnd())
def setHoraEquipo(self):
horaEquipoRaw = placaService.getDateTime()
horaEquipo = QDateTime(horaEquipoRaw[0], horaEquipoRaw[1],
horaEquipoRaw[2], horaEquipoRaw[3],
horaEquipoRaw[4], horaEquipoRaw[5])
self.dateTimeEdit.setDateTime(horaEquipo)
def testDateTimeTypes(self):
vl = QgsVectorLayer(
'%s table="qgis_test"."date_times" sql=' % (self.dbconn),
"testdatetimes", "postgres")
assert (vl.isValid())
fields = vl.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_field')).type(),
QVariant.Date)
self.assertEqual(
fields.at(fields.indexFromName('time_field')).type(),
QVariant.Time)
self.assertEqual(
fields.at(fields.indexFromName('datetime_field')).type(),
QVariant.DateTime)
f = vl.getFeatures(QgsFeatureRequest()).next()
date_idx = vl.fieldNameIndex('date_field')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2004, 3, 4))
time_idx = vl.fieldNameIndex('time_field')
assert isinstance(f.attributes()[time_idx], QTime)
self.assertEqual(f.attributes()[time_idx], QTime(13, 41, 52))
datetime_idx = vl.fieldNameIndex('datetime_field')
assert isinstance(f.attributes()[datetime_idx], QDateTime)
self.assertEqual(f.attributes()[datetime_idx],
QDateTime(QDate(2004, 3, 4), QTime(13, 41, 52)))
def getRecord(self, record):
dateTime = QDateTime(self.edtDate.date(), QTime().currentTime())
record.setValue('dateTime', dateTime)
i = self.cmbSocCodes.currentIndex()
socCode = forceString(self.cmbSocCodes.itemData(i))
record.setValue('socCode', socCode)
pregCard = forceInt(self.edtPregCard.text())
if pregCard > 0:
record.setValue('pregCard', pregCard)
else:
record.setNull('pregCard')
getRBComboBoxValue(self.cmbFinance, record, 'finance_id')
record.setValue('mkb', toVariant(self.cmbMKB.text()))
getRBComboBoxValue(self.cmbDrug, record, 'formularyItem_id')
getLineEditValue(self.edtDosage, record, 'dosage')
getSpinBoxValue(self.spbQnt, record, 'qnt')
getLineEditValue(self.edtSigna, record, 'signa')
getSpinBoxValue(self.spbDuration, record, 'duration')
getSpinBoxValue(self.spbNumPerDay, record, 'numPerDay')
record.setValue('isVk', int(self.rbtnVkYes.isChecked()))
record.setValue('printMnn', int(self.rbtnPrintMNN.isChecked()))
record.setValue('percentage',
int(50 if self.rbtn50proc.isChecked() else 100))
getComboBoxValue(self.cmbTerm, record, 'term')
record.setValue(
'status',
self.modelRecipeStatus.getCode(self.cmbStatus.currentIndex()))
record.setValue('deleted', 0)
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_talk(self):
date = self.addTalkWidget.dateEdit.date()
time = self.addTalkWidget.timeEdit.time()
datetime = QDateTime(date, time)
presentation = Presentation(
unicode(self.addTalkWidget.titleLineEdit.text()),
unicode(self.addTalkWidget.presenterLineEdit.text()),
"", # description
"", # level
unicode(self.addTalkWidget.eventLineEdit.text()),
unicode(self.addTalkWidget.roomLineEdit.text()),
unicode(datetime.toString(Qt.ISODate)))
# Do not add talks if they are empty strings
if (len(presentation.title) == 0):
return
self.db.insert_presentation(presentation)
# cleanup
self.addTalkWidget.titleLineEdit.clear()
self.addTalkWidget.presenterLineEdit.clear()
self.presentationModel.select()
self.hide_add_talk_widget()
# If this is launched from the recording app
# refresh the talk list
if self.recordapp:
self.recordapp.load_event_list()
def add_talk(self):
date = self.addTalkWidget.dateEdit.date()
startTime = self.addTalkWidget.startTimeEdit.time()
datetime = QDateTime(date,
startTime) # original "time" is now "startTime"
presentation = Presentation(
unicode(self.addTalkWidget.titleLineEdit.text()),
unicode(self.addTalkWidget.presenterLineEdit.text()),
"", # description
"", # level
unicode(self.addTalkWidget.eventLineEdit.text()),
unicode(self.addTalkWidget.roomLineEdit.text()),
unicode(datetime.toString()),
unicode(self.addTalkWidget.endTimeEdit.text()))
# Do not add talks if they are empty strings
if (len(presentation.title) == 0):
return
self.db.insert_presentation(presentation)
# cleanup
self.addTalkWidget.titleLineEdit.clear()
self.addTalkWidget.presenterLineEdit.clear()
self.failureModel.select()
self.hide_add_talk_widget()
def from_datetime(datetime):
if datetime is not None:
return QDateTime(datetime.year, datetime.month, datetime.day,
datetime.hour, datetime.minute)
else:
return QDateTime.currentDateTime()
def test_datetime_textbox_changed(self):
gui = self.window.getGui()
signal_mock = Mock()
gui.signalCurrentTimeUpdated = signal_mock
qdate = QDateTime(2010, 1, 1, 1, 2)
gui.currentTimeChangedDateText(qdate)
# assert that the signal was called with the correct datetime
signal_mock.emit.assert_called_with(qdate)
def lastModified(self, path):
fi = QFileInfo(path)
if fi.exists():
return fi.lastModified()
else:
err = 'No such file or directory'
qDebug("FileSystem.lastModified - %s: '%s'" % (err, path))
return QDateTime()
def _qgs_memory_layer(self, style, features=None):
""" Create QgsVectorLayer with memory backend and load
features into it """
result = QgsVectorLayer(style.parent.geometry_type, None, 'memory')
provider = result.dataProvider()
# Setup layer fields
fldmap = {}
for fld in style.parent.fields:
provider.addAttributes(
[QgsField(fld.keyname, *FIELD_TYPE_TO_QGIS[fld.datatype])])
fldmap[fld.keyname] = len(fldmap)
qgsfields = provider.fields()
result.updateFields()
# Load style from qml file
result.loadNamedStyle(self.env.file_storage.filename(
style.qml_fileobj))
# Disable read only flag when it was set via qml file
result.setReadOnly(False)
# Load features into layers if needed
if features is not None:
result.startEditing()
for feat in features:
qgsfeat = QgsFeature(qgsfields)
fattrs = [None] * len(fldmap)
for k, v in feat.fields.iteritems():
if v is None:
continue
elif isinstance(v, date):
v = QDate(v.year, v.month, v.day)
elif isinstance(v, time):
v = QTime(v.hour, v.minute, v.second)
elif isinstance(v, datetime):
v = QDateTime(v.year, v.month, v.day, v.hour, v.minute,
v.second)
fattrs[fldmap[k]] = v
qgsfeat.setAttributes(fattrs)
# Method fromWkb() is much faster constructor fromWkt()
# TODO: QGIS 3 have constructor fromWkb()
qgsgeom = QgsGeometry()
qgsgeom.fromWkb(feat.geom.wkb)
qgsfeat.setGeometry(qgsgeom)
result.addFeature(qgsfeat)
result.commitChanges()
result.setCrs(QgsCoordinateReferenceSystem(style.parent.srs.id))
return result
def __init__(self):
QARecord.__init__()
self.Type = QARecordType.Session
self.NULLDATE = QDateTime(QDate(2222, 2, 22), QTime(22, 22, 22, 22))
self.dwgCreated = QDateTime()
self.dwgSaved = QDateTime()
self.dwgFileName = None
self.dwgSizeOpened = 0
self.dwgSizeClosed = 0
self.tagName = None
self.tagProject = None
self.tagReason = None
self.tagSection = None
self.sessionType = None
self.qaLastSaved = QDateTime()
self.closed = QDateTime()
self.correlation = None
self.corrupted = None
def convert_timestamp_to_qdatetime(timestamp):
from PyQt4.QtCore import QDateTime
from math import modf
timestamp_frac, timestamp_whole = modf(timestamp)
# Qt time
qdatetime = QDateTime()
qdatetime.setTime_t(int(timestamp_whole))
qdatetime = qdatetime.addMSecs(int(timestamp_frac * 1000))
#
return qdatetime
def dateTimeAt(self, point):
"""
Returns the date time at the inputed point.
:param point | <QPoint>
"""
for dtime, data in self._dateTimeGrid.items():
if (data[1].contains(point)):
return QDateTime.fromTime_t(dtime)
return QDateTime()
def tickStringsDate(self, values, scale, spacing):
"""Return HH:mm:ss strings from unixtime values"""
# FIXME Change date format depending of min max value
# FIXME Make better date locator
out = []
for value in values:
t = QDateTime()
t.setTime_t(value)
out.append(t.toString('HH:mm:ss'))
return out
def test_extact_rmc_handles_empty_values():
gps = GPSService()
msg = "$GNRMC,033523.00,V,,,,,,,270115,,,N*67"
data = pynmea2.parse(msg)
info = gps.extract_rmc(data)
assert info.longitude == 0.0
assert info.latitude == 0.0
assert info.speed == 0.0
assert info.status == "V"
assert info.direction == 0
assert info.utcDateTime == QDateTime(2015, 1, 27, 3, 35, 23, 0, Qt.UTC)
msg = "$GPRMC,,V,,,,,,,,,,N*53"
data = pynmea2.parse(msg)
info = gps.extract_rmc(data)
assert info.longitude == 0.0
assert info.latitude == 0.0
assert info.speed == 0.0
assert info.status == "V"
assert info.direction == 0
assert info.utcDateTime == QDateTime(2015, 1, 27, 3, 35, 23, 0, Qt.UTC)
def test_extact_rmc_returns_correct_info():
gps = GPSService()
msg = "$GNRMC,033615.00,A,3157.10477,S,11549.42965,E,0.120,,270115,,,A*73"
data = pynmea2.parse(msg)
info = gps.extract_rmc(data)
assert info.longitude == 115.8238275
assert info.latitude == -31.951746166666666
assert info.speed == 0.22224
assert info.status == "A"
assert info.direction == 0
assert info.utcDateTime == QDateTime(2015, 1, 27, 3, 36, 15, 0, Qt.UTC)
def setEditorData(self, editor, index):
"""Overriding method setEditorData
Model --> Editor"""
value = self.get_value(index)
if isinstance(editor, QLineEdit):
if not isinstance(value, basestring):
value = unicode(value)
editor.setText(value)
elif isinstance(editor, QDateEdit):
editor.setDate(value)
elif isinstance(editor, QDateTimeEdit):
editor.setDateTime(QDateTime(value.date(), value.time()))
def on_searchButton_clicked(self):
self.layer = self.layerComboManager.getLayer()
pkeyName = primaryKey(self.layer)
if self.layer is None or pkeyName is None:
return
self.loggedActionsTable.geomColumn = self.layer.hasGeometryType()
featureId = int(self.featureEdit.text() or 0)
searchBeforeDate = QDateTime()
if self.searchBefore.isChecked():
searchBeforeDate = self.searchAfterDate.dateTime()
searchAfterDate = QDateTime()
if self.searchAfter.isChecked():
searchAfterDate = self.searchAfterDate.dateTime()
self.buttonDisplayMode(True)
self.results = self.logLayer.performSearch(self.layer, featureId, pkeyName,
self.searchInserts.isChecked(), self.searchUpdates.isChecked(),
self.searchDeletes.isChecked(), self.searchOnlyGeometry.isChecked(),
searchAfterDate, searchBeforeDate)
self.buttonDisplayMode(False)
self.panShowGeometry.setEnabled(self.layer.hasGeometryType())
self.displayLoggedActions()
def on_actAdd_triggered(self):
db = QtGui.qApp.db
clientInfo = getClientInfo(self.clientId)
if len(clientInfo.SNILS) == 0:
QtGui.QMessageBox.warning(
self, u'Внимание', u'У пациента не заполнен СНИЛС.\n'
u'Укажите СНИЛС пациента в рег. карте.',
QtGui.QMessageBox.Close)
return
if len(clientInfo.socStatuses) == 0:
QtGui.QMessageBox.warning(self, u'Внимание',
u'У пациента отсутствуют льготы.',
QMessageBox.Close)
return
federalCode = forceString(
db.translate('Person', 'id', self.personId, 'federalCode'))
if len(federalCode) == 0:
QtGui.QMessageBox.warning(
self, u'Внимание',
u'У ответственного за событие врача не указан федеральный код.',
QMessageBox.Close)
return
record = self.tblItems.model().getEmptyRecord()
record.setValue('dateTime', toVariant(QDateTime().currentDateTime()))
try:
record.setValue('percentage', toVariant(100))
if self.mkb:
record.setValue('mkb', toVariant(self.mkb))
record.setValue('term', toVariant(2))
record.setValue('printMnn', toVariant(1))
context = CInfoContext()
client, setPerson = self.getEventInfo(context)
if len(client.socStatuses) == 0:
raise Exception(u'В регистрационной карте не указаны льготы!')
dlg = CRecipeEditDialog(self, client.socStatuses, client.id,
setPerson.personId)
dlg.setRecord(record)
if dlg.exec_() == QDialog.Accepted:
dlg.getRecord(record)
recipeNumber = self.getRecipeNumber(record)
record.setValue('number', recipeNumber)
self.tblItems.model().addRecord(record)
self.tblItems.model().reset()
self.tblItems.setCurrentRow(self.tblItems.model().rowCount() -
1)
except Exception as ex:
QtGui.QMessageBox.question(self, u'Внимание', ex.message,
QMessageBox.Close)
def __init__(self, logFeature, featureLayer, pkeyName, geomColumn):
self.featureLayer = featureLayer
self.fields = featureLayer.dataProvider().fields()
self.logFeature = QgsFeature(logFeature)
self.geomColumn = geomColumn
self.date = QDateTime().fromString(logFeature["action_tstamp_clk"],
Qt.ISODate)
print logFeature[
"action_tstamp_clk"], self.date, self.date.toMSecsSinceEpoch()
self.dateMs = self.date.toMSecsSinceEpoch()
self.logData = self.logFeature["row_data"]
self.layerFeatureId = int(self.getFieldValue(self.logData, pkeyName))
def log_table_entry(self, instance):
"""
Ensure that only import are done once
:return:
"""
try:
current_time = QDateTime()
import_time = current_time.currentDateTime()
log_entry = instance + ' '+ str(import_time.toPyDateTime())
self.importlogger.log_action(log_entry)
except IOError as io:
self._notif_bar_str.insertErrorNotification(MSG + ": "+io.message)
pass
def isDirty(self, *args):
date = self.getSelectedDate()
time = self.getSelectedTime()
datetime = QDateTime(date, time)
if self.mode == "Date":
value = datetime.toString("ddd d MMM yyyy")
elif self.mode == "Time":
value = datetime.toString("h:m ap")
else:
value = datetime.toString("ddd d MMM yyyy 'at' h:m ap")
self.label.setText(value)
