def getClientIdentificatorRecord(self, clientId, accountingSystemCode,
identifier):
accountingSystemCode = forceString(accountingSystemCode)
db = QtGui.qApp.db
tableClientIdentification = db.table('ClientIdentification')
tableAccountingSystem = db.table('rbAccountingSystem')
cond = [
tableClientIdentification['client_id'].eq(clientId),
tableAccountingSystem['code'].eq(accountingSystemCode),
tableClientIdentification['deleted'].eq(0)
]
record = db.getRecordEx(
tableClientIdentification.leftJoin(
tableAccountingSystem, tableAccountingSystem['id'].eq(
tableClientIdentification['accountingSystem_id'])),
'ClientIdentification.*', cond)
if record is None:
record = db.record('ClientIdentification')
record.setValue('client_id', toVariant(clientId))
record.setValue(
'accountingSystem_id',
toVariant(
forceRef(
db.translate('rbAccountingSystem', 'code',
accountingSystemCode, 'id'))))
record.setValue('identifier', toVariant(identifier))
return record
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
getLineEditValue(self.edtSerial, record, 'serial')
getLineEditValue(self.edtNumber, record, 'number')
getDateEditValue(self.edtDate, record, 'date')
getRBComboBoxValue(self.cmbPerson, record, 'person_id')
getRBComboBoxValue(self.cmbExpert, record, 'expert_id')
getLineEditValue(self.edtDestination, record, 'destination')
getRBComboBoxValue(self.cmbReason, record, 'reason_id')
getTextEditValue(self.edtNote, record, 'note')
getCheckBoxValue(self.chkInsuranceOfficeMark, record,
'insuranceOfficeMark')
record.setValue('tempInvalid_id', toVariant(self.tempInvalidId))
getLineEditValue(self.edtPlaceWork, record, 'placeWork')
if not self.defaultBlankMovingId:
blankMovingId = self.edtSerial.value()
else:
blankMovingId = self.defaultBlankMovingId
if blankMovingId:
db = QtGui.qApp.db
tableBlankTempInvalidMoving = db.table('BlankTempInvalid_Moving')
recordMoving = db.getRecordEx(tableBlankTempInvalidMoving, u'*', [
tableBlankTempInvalidMoving['deleted'].eq(0),
tableBlankTempInvalidMoving['id'].eq(blankMovingId)
])
if recordMoving:
used = forceInt(recordMoving.value('used'))
recordMoving.setValue('used', toVariant(used + 1))
db.updateRecord(tableBlankTempInvalidMoving, recordMoving)
return record
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
record.setValue(rbCode, toVariant(forceStringEx(self.edtCode.text())))
record.setValue('regionalCode',
toVariant(forceStringEx(self.edtRegionalCode.text())))
record.setValue(rbName, toVariant(forceStringEx(self.edtName.text())))
return record
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
record.setValue(rbCode, toVariant(forceStringEx(self.edtCode.text())))
record.setValue(rbName, toVariant(forceStringEx(self.edtName.text())))
modifier = u''
if self.chkReplaceService.isChecked():
action = 1
text = forceStringEx(self.edtReplaceService.text())
modifier = createModifier(action, text)
# Этот модификатор может выставляться/сохраняться/применяться вместе с ModifyTailService
if self.chkModifyHeadService.isChecked():
action = 2
text = forceStringEx(self.edtModifyHeadService.text())
n = forceInt(self.edtModifyHeadService_N.text())
modifier = createModifier(action, text, n)
# Этот модификатор может выставляться/сохраняться/применяться вместе с ModifyHeadService
if self.chkModifyTailService.isChecked():
action = 3
text = forceStringEx(self.edtModifyTailService.text())
n = forceInt(self.edtModifyTailService_N.text())
if modifier:
modifier = modifier + u'/' + createModifier(action, text, n)
else:
modifier = createModifier(action, text, n)
# Если было кликнуто ничего или chkNoModifyService, то modifier должен быть равен u''
record.setValue('serviceModifier', toVariant(modifier))
return record
def changeParent(self, id, parentId, parentClass):
if not (parentId in self.getItemIdList(self.findItemId(id))):
db = QtGui.qApp.db
table = db.table(self.tableName)
parentCode = forceString(
db.translate(table, 'id', parentId, 'code'))
oldCode = forceString(db.translate(table, 'id', id, 'code'))
newCode = self.getNewCode(oldCode, parentCode)
record = db.getRecord(
table,
[self.idColName, self.groupColName, self.classColName, 'code'],
id)
if record:
self.emit(QtCore.SIGNAL('saveExpandedState()'))
childIdList = db.getIdList(table, 'id',
table['group_code'].eq(oldCode))
variantParentCode = toVariant(
parentCode) if parentCode else QtCore.QVariant()
record.setValue(self.groupColName, variantParentCode)
record.setValue(self.classColName, toVariant(parentClass))
record.setValue('code', toVariant(newCode))
db.updateRecord(table, record)
for childId in childIdList:
self.changeChildren(childId, id, parentClass)
self.reset()
self.update()
self.emit(QtCore.SIGNAL('restoreExpandedState()'))
def updateEvents(self, eventIdList, updateContracts=False):
tableClient = self.db.table('Client')
tableEvent = self.db.table('Event')
for eventRec in self.db.iterRecordList(
tableEvent, where=tableEvent['id'].inlist(eventIdList)):
updateRecord = False
oldPolicy = forceRef(eventRec.value('clientPolicy_id'))
newPolicy = self.getPolicy(eventRec)
if newPolicy and newPolicy != oldPolicy:
eventRec.setValue('clientPolicy_id', toVariant(newPolicy))
updateRecord = True
if updateContracts:
clientId = forceRef(eventRec.value('client_id'))
clientRec = self.db.getRecord(tableClient, 'birthDate',
clientId)
oldContract = forceRef(eventRec.value('contract_id'))
newContract = self.getContract(eventRec, clientRec)
if newContract and newContract != oldContract:
eventRec.setValue('contract_id', toVariant(newContract))
updateRecord = True
if updateRecord:
self.db.updateRecord(tableEvent, eventRec)
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
record.setValue('finance_id', toVariant(self.cmbFinance.value()))
record.setValue(rbCode, toVariant(forceStringEx(self.edtCode.text())))
record.setValue(rbName, toVariant(forceStringEx(self.edtName.text())))
record.setValue('rerun', toVariant(self.chkCanRerun.isChecked()))
return record
def data(self, index, role=QtCore.Qt.DisplayRole):
if not index.isValid():
return QtCore.QVariant()
if not self._isExistsDentitionAction:
return QtCore.QVariant()
if not self._action:
return QtCore.QVariant()
row = index.row()
column = index.column()
if role == QtCore.Qt.DisplayRole:
property = self._getProperty(row, column)
return toVariant(property.getText())
elif role == QtCore.Qt.BackgroundRole:
if row == 0 or row == 7:
property = self._getProperty(row, column)
propertyValue = property.getValue()
fSmb = propertyValue[0] if propertyValue else None
if fSmb in [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10',
'11', '12', '13', '14', '15'
]:
return QtCore.QVariant(
QtGui.QColor(
CDentitionModel.colorStatus[forceInt(fSmb)]))
elif role == QtCore.Qt.EditRole:
property = self._getProperty(row, column)
return toVariant(property.getValue())
return QtCore.QVariant()
def saveData(self):
preferences = {}
setPref(preferences, 'address', toVariant(self.edtAddress.text()))
setPref(preferences, 'name', toVariant(self.edtName.text()))
setPref(preferences, 'password', toVariant(self.edtPassword.text()))
setPref(QtGui.qApp.preferences.appPrefs, 'EMSRNExchange', preferences)
return True
def saveData(self):
self.tableItems.ticketIsDirty = [False]*len(self.tableItems.tickets)
for i, ticket in enumerate(self.tableItems.tickets):
datetime = QtCore.QDateTime(self.items[i][4], self.items[i][0]) if i < len(self.items) else None
ticket.setValue('datetime', toVariant(datetime))
ticket.setValue('idx', toVariant(i))
self.tableItems.ticketIsDirty[i] = True
def saveDiagnostic(self, eventId):
db = QtGui.qApp.db
table = db.table('Diagnostic')
if not self.diagnosticRecord:
self.diagnosticRecord = table.newRecord()
self.diagnosticRecord.setValue('event_id', toVariant(eventId))
record = self.diagnosticRecord
diagnosisTypeId = self.getDiagnosisTypeId()
characterId = self.getCharacterId()
dispanserId = None
traumaTypeId = self.cmbTraumaType.value()
resultId = self.cmbResult.value()
MKB = forceString(self.edtMKB.text())
MKBEx = forceString(self.edtMKBEx.text())
diagnosisId, characterId = getDiagnosisId2(
self.eventDate, self.personId, self.clientId, diagnosisTypeId, MKB,
MKBEx, characterId, dispanserId, traumaTypeId,
forceRef(record.value('diagnosis_id')),
forceRef(record.value('id')))
record.setValue('diagnosisType_id', toVariant(diagnosisTypeId))
record.setValue('speciality_id', toVariant(self.personSpecialityId))
record.setValue('person_id', toVariant(self.personId))
record.setValue('setDate', toVariant(self.eventDate))
record.setValue('endDate', toVariant(self.eventDate))
record.setValue('diagnosis_id', toVariant(diagnosisId))
record.setValue('character_id', toVariant(characterId))
record.setValue('traumaType_id', toVariant(traumaTypeId))
record.setValue('result_id', toVariant(resultId))
db.insertOrUpdate(table, record)
self.modifyDiagnosises([(MKB, diagnosisId)])
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
record.setValue(rbCode, toVariant(forceStringEx(self.edtCode.text())))
record.setValue(rbName, toVariant(forceStringEx(self.edtName.text())))
record.setValue('amount', toVariant(forceStringEx(self.edtAmount.text())))
record.setValue('unit', toVariant(forceStringEx(self.edtUnit.text())))
return record
def addActionType(self, actionTypeId):
model = self.modelActions
item = model.getEmptyRecord()
item.setValue('actionType_id', toVariant(actionTypeId))
item.setValue('selectionGroup', toVariant(0))
item.setValue('include', QtCore.QVariant(1))
if self.showPrice:
item.setValue(
'cash',
QtCore.QVariant(self.wholeEventForCash
or bool(self.contractId)))
item.setValue(
'payable',
2 if self.wholeEventForCash else 1 if self.contractId else 0)
serviceIdList = CMapActionTypeIdToServiceIdList.getActionTypeServiceIdList(
actionTypeId, self.financeId)
visitTariffMap, actionTariffMap = self.getTariffMap()
price = self.contractTariffCache.getPrice(actionTariffMap,
serviceIdList,
self.tariffCategoryId)
item.setValue('price', QtCore.QVariant(price))
item.setValue('amount', QtCore.QVariant(1.0))
item.setValue('sum', QtCore.QVariant(price))
model.items().append(item)
count = len(model.items())
model.beginInsertRows(QtCore.QModelIndex(), count, count)
model.insertRows(count, 1)
model.endInsertRows()
def saveWorkItems(self, master_id, items, table, field):
if items:
masterId = toVariant(master_id)
idList = []
for value in items:
if not len(value):
continue
value = value.strip()
if not value:
continue
record = QtGui.qApp.db.record(table)
valueId = self.rbTypeId(value, table)
if not valueId:
self.error[table][master_id] = (
value, u'такого значения нет в справочнике %s' %
(u'Типы вредности' if table == 'ClientWork_Hurt' else
u'Факторы вредности'))
continue
record.setValue('master_id', masterId)
record.setValue(field, toVariant(valueId))
itemId = self.db.insertOrUpdate(table, record)
record.setValue('id', itemId)
idList.append(itemId)
table = self.db.table(table)
cond = [
table['master_id'].eq(masterId),
'not(' + table['id'].inlist(idList) + ')'
]
self.db.deleteRecord(table, cond)
return idList
def startImport(self):
self.btnImport.setEnabled(False)
fileName = str(self.edtFileName.text())
address = str(self.edtAddress.text())
port = str(self.edtPort.text())
QtGui.qApp.preferences.appPrefs['ImportPACSFileName'] = toVariant(fileName)
QtGui.qApp.preferences.appPrefs['ImportPACSAddress'] = toVariant(address)
QtGui.qApp.preferences.appPrefs['ImportPACSPort'] = toVariant(port)
# self.txtLog.append(subprocess.check_output(self.command + [address, port, fileName]))
p = Popen(self.command + [address, port, fileName], stdin=PIPE, stdout=PIPE, stderr=STDOUT, bufsize=1, close_fds=self.ON_POSIX, shell=True)
q = Queue()
t = Thread(target=self.enqueue_output, args=(p.stdout, q))
t.daemon = True
t.start()
while t.isAlive():
QtGui.qApp.processEvents()
try:
line = q.get_nowait()
except Empty:
pass
else:
self.txtLog.append(line)
self.btnImport.setEnabled(True)
def fillSPR69Record(self,
db,
table,
record,
begDate=None,
endDate=None,
ksgCode=None,
mkbx=None,
mkbx2=None,
kusl=None,
sex=None,
age=None,
duration=None,
ksgKoeff=None):
if begDate is not None: record.setValue('begDate', toVariant(begDate))
if endDate is not None: record.setValue('endDate', toVariant(endDate))
if ksgCode is not None: record.setValue('KSG', toVariant(ksgCode))
if mkbx is not None: record.setValue('MKBX', toVariant(mkbx))
if mkbx2 is not None: record.setValue('MKBX2', toVariant(mkbx2))
if kusl is not None: record.setValue('KUSL', toVariant(kusl))
if sex is not None: record.setValue('sex', toVariant(sex))
if age is not None: record.setValue('age', toVariant(age))
if duration is not None:
record.setValue('duration', toVariant(duration))
if ksgKoeff is not None:
record.setValue('KSGKoeff', toVariant(ksgKoeff))
self.cacheRecords.append(record)
if len(self.cacheRecords) >= 1000:
db.insertMultipleRecords(table, self.cacheRecords)
self.cacheRecords = []
def getEmptyRecord(self, sceneId=None, personId=None):
eventEditor = QtCore.QObject.parent(self)
eventEditor.getPersonServiceId(personId)
if not personId:
if QtGui.qApp.userSpecialityId:
personId = QtGui.qApp.userId
if not eventEditor.getPersonServiceId(personId):
personId = None
if not personId:
execPersonId = eventEditor.getExecPersonId()
if execPersonId:
personId = execPersonId
assistantId = eventEditor.getAssistantId(
) if self.hasAssistant and personId and personId == eventEditor.personId else None
result = CInDocTableModel.getEmptyRecord(self)
result.setValue('person_id', toVariant(personId))
result.setValue('assistant_id', toVariant(assistantId))
result.setValue(
'scene_id',
toVariant(sceneId if sceneId else self.getDefaultSceneId()))
result.setValue('visitType_id',
toVariant(self.getDefaultVisitTypeId()))
result.setValue('service_id', toVariant(self.getServiceId(result)))
result.setValue('finance_id', self.getFinanceId())
return result
def updateActionsBlankParty(self):
received = 0
used = 0
returnAmount = 0
for item in self.modelBlankActionsMoving.items():
received += forceInt(item.value('received'))
used += forceInt(item.value('used'))
returnAmount += forceInt(item.value('returnAmount'))
currentIndex = self.tblBlankActionsParty.currentIndex()
if currentIndex.isValid():
currentRow = currentIndex.row()
blankPartyId = self.getBlankPartyId(self.tblBlankActionsParty,
self.modelBlankActionsParty)
itemsParty = self.modelBlankActionsParty.items()
record = itemsParty[currentRow]
amountBlank = forceInt(record.value('amount'))
writingBlank = forceInt(record.value('writing'))
record.setValue('extradited', toVariant(received))
record.setValue('used', toVariant(used))
record.setValue('returnBlank', toVariant(returnAmount))
record.setValue(
'balance',
toVariant(amountBlank - received - writingBlank +
returnAmount))
itemsParty[currentRow] = record
self.modelBlankActionsParty.setItems(itemsParty)
self.modelBlankActionsParty.emitRowChanged(currentRow)
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
pType = '%.2d' % (self.cmbPaymentType.currentIndex() + 1)
codePart = '%.2d' % (self.cmbCodePart.currentIndex() + 1)
if (pType, codePart) in self.codes.keys():
code = '%s.%s.%.3d' % (pType, codePart, self.codes[(pType,
codePart)])
else:
code = '%s.%s.%.3d' % (pType, codePart, 1)
record.setValue(rbCode, toVariant(code))
record.setValue('type', toVariant(self.type))
getRBComboBoxValue(self.cmbOKPF, record, 'OKPF_id')
getRBComboBoxValue(self.cmbOrgId, record, 'org_id')
getLineEditValue(self.edtContractNumber, record, 'contractNumber')
getDateEditValue(self.edtDate, record, 'contractDate')
getDateEditValue(self.edtEndDate, record, 'contractEndDate')
getLineEditValue(self.edtContractSum, record, 'contractSum')
if QtGui.qApp.checkGlobalPreference('68', u'нет') and type == 2:
getLineEditValue(self.edtContragent, record, 'contragent')
getLineEditValue(self.edtProtocolNum, record, 'protocolNumber')
getLineEditValue(self.edtProtocolPhase, record, 'protocolPhase')
getLineEditValue(self.edtProtocolName, record, 'protocolName')
getComboBoxValue(self.cmbRecPatients, record, 'protocolRecruit')
elif QtGui.qApp.checkGlobalPreference('68', u'нет') and type == 1:
getLineEditValue(self.edtContragent, record, 'contragent')
getLineEditValue(self.edtContractItem, record, 'contractItem')
getLineEditValue(self.edtAddress, record, 'address')
return record
def saveItems(self, masterId):
if self._items is not None:
db = QtGui.qApp.db
table = self._table
masterId = toVariant(masterId)
masterIdFieldName = self._masterIdFieldName
idFieldName = self._idFieldName
for idx, record in enumerate(self._items):
record.setValue(masterIdFieldName, masterId)
if self._idxFieldName:
record.setValue(self._idxFieldName, toVariant(idx))
if self._extColsPresent:
outRecord = self.removeExtCols(record)
else:
outRecord = record
id = db.insertOrUpdate(table, outRecord)
record.setValue(idFieldName, toVariant(id))
if self.deletedIdList:
filter = [
table[masterIdFieldName].eq(masterId),
table[idFieldName].inlist(self.deletedIdList)
]
if self._filter:
filter.append(self._filter)
if table.hasField('deleted'):
db.markRecordsDeleted(table, filter)
def getRecord(self):
record = CItemEditorBaseDialog.getRecord(self)
getLineEditValue(self.edtCode, record, 'code')
getLineEditValue(self.edtName, record, 'name')
getLineEditValue(self.edtShortName, record, 'shortName')
getLineEditValue(self.edtOKSOName, record, 'OKSOName')
getLineEditValue(self.edtOKSOCode, record, 'OKSOCode')
getLineEditValue(self.edtFederalCode, record, 'federalCode')
getLineEditValue(self.edtRegionalCode, record, 'regionalCode')
getLineEditValue(self.edtSyncGUID, record, 'syncGUID')
getRBComboBoxValue(self.cmbLocalService, record, 'service_id')
getRBComboBoxValue(self.cmbProvinceService, record,
'provinceService_id')
getRBComboBoxValue(self.cmbOtherService, record, 'otherService_id')
getRBComboBoxValue(self.cmbFundingService, record, 'fundingService_id')
getComboBoxValue(self.cmbSex, record, 'sex')
record.setValue(
'age',
toVariant(
composeAgeSelector(self.cmbBegAgeUnit.currentIndex(),
forceStringEx(self.edtBegAgeCount.text()),
self.cmbEndAgeUnit.currentIndex(),
forceStringEx(self.edtEndAgeCount.text()))))
record.setValue(
'versSpec',
toVariant({
0: '',
1: 'V004',
2: 'V015'
}.get(self.cmbVersSpec.currentIndex(), '')))
getLineEditValue(self.edtMKBFilter, record, 'mkbFilter')
return record
def fillActionTypeRecord(db,
table,
record,
code=None,
name=None,
nom_id=None,
classProp=None,
insert=None):
if code is not None:
record.setValue('code', toVariant(code))
if name is not None:
record.setValue('name', toVariant(name))
if classProp is not None:
record.setValue('class', QtCore.QVariant(classProp))
record.setValue('nomenclativeService_id', toVariant(nom_id))
record.setValue('propertyNormVisible', QtCore.QVariant(name))
record.setValue('title', QtCore.QVariant(name))
if insert:
record.setValue('sex', QtCore.QVariant(0))
record.setValue('amountEvaluation', QtCore.QVariant(0))
record.setValue('isPreferable', QtCore.QVariant(1))
record.setValue('isPrinted', QtCore.QVariant(0))
record.setValue('showInForm', QtCore.QVariant(1))
record.setValue('propertyAssignedVisible', QtCore.QVariant(0))
record.setValue('propertyUnitVisible', QtCore.QVariant(0))
record.setValue('propertyEvaluationVisible', QtCore.QVariant(0))
record.setValue('amount', QtCore.QVariant(1))
db.insertOrUpdate(table, record)
def getEmptyRecord(self):
isFirst = not bool(self.items())
result = CInDocTableModel.getEmptyRecord(self)
result.append(QtSql.QSqlField('diagnosis_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('diagnosisType_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('speciality_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('person_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('dispanser_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('hospital', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('healthGroup_id', QtCore.QVariant.Int))
result.append(QtSql.QSqlField('setDate', QtCore.QVariant.DateTime))
result.append(QtSql.QSqlField('endDate', QtCore.QVariant.DateTime))
result.append(QtSql.QSqlField('payStatus', QtCore.QVariant.Int))
result.setValue('diagnosisType_id',
QtCore.QVariant(self.getDiagnosisTypeId(isFirst)))
if isFirst:
if self._parent.inheritResult == True:
result.setValue(
'result_id',
toVariant(
CEventEditDialog.defaultDiagnosticResultId.get(
self._parent.eventPurposeId)))
else:
result.setValue('result_id', toVariant(None))
return result
def on_btnAddEvent_clicked(self):
tableSmpEvents = self.db.table('SmpEvents')
item = self.tblEvents.model().items()[
self.tblEvents.currentIndex().row()]
if forceInt(self.cmbResult.currentIndex()):
responce = self.exchange.addEvent(
forceString(item.value('callNumberId')),
forceInt(self.cmbResult.currentIndex()), self.edtNote.text())
else:
QtGui.QMessageBox.warning(self, u'Ошибка',
u'Не выбран результат события')
return
if responce:
recEvent = self.db.getRecordEx(
tableSmpEvents, '*', tableSmpEvents['callNumberId'].eq(
forceString(item.value('callNumberId'))))
if recEvent:
recEvent.setValue('result',
toVariant(self.cmbResult.currentText()))
recEvent.setValue('isDone', toVariant(1))
self.db.updateRecord(tableSmpEvents, recEvent)
QtGui.QMessageBox.information(self, u'Успешно',
u'Событие успешно добавлено')
self.loadData()
else:
QtGui.QMessageBox.warning(
self, u'Ошибка', u'При регистрации события возникла ошибка')
def data(self, index, role=QtCore.Qt.DisplayRole):
column = self.cols()[index.column()]
columnFieldNames = column.fields()
row = index.row()
if role == QtCore.Qt.BackgroundColorRole:
if self.items[row].get('isVIP', None):
return QtCore.QVariant(self.items[row].get(
'vipColor', self.vipClientColor))
elif self.items[row].get('isUnconscious', None):
return toVariant(QtGui.QColor(self.unconsciousPatientRowColor))
if 'statusObservationCode' in columnFieldNames and self.items[
row].get('statusObservationCode', None):
return toVariant(
QtGui.QColor(self.items[row].get('statusObservationColor',
None)))
elif len(self.items[row].get('MKB', '')) <= 0:
return toVariant(QtGui.QColor(200, 230, 240))
if role == QtCore.Qt.DisplayRole:
if 'feed' in columnFieldNames:
return QtCore.QVariant()
elif role == QtCore.Qt.CheckStateRole:
if 'feed' in columnFieldNames:
item = self.items[row]
return toVariant(QtCore.Qt.Checked if item.
get('feed', None) else QtCore.Qt.Unchecked)
return CMonitoringModel.data(self, index, role)
def duplicateCurrentRow(self):
db = QtGui.qApp.db
reportRecord = db.getRecordEx(
'rcReport', '*', 'id = %s and deleted = 0' %
forceString(self.tblItems.currentItemId()))
translateQuery, translateField = self.duplicateQuery(
forceString(reportRecord.value('query_id')))
for id in translateQuery.values():
self.updateNewQuery(id, translateQuery, translateField)
reportRecord.setValue(
'query_id',
toVariant(translateQuery[forceString(
reportRecord.value('query_id'))]))
reportRecord.setValue(
'name',
toVariant(forceString(reportRecord.value('name')) + u' копия'))
curId = self.tblItems.currentItemId()
newId = self.insertRecord('rcReport', reportRecord)
self.duplicateRb('rcReport_Group', curId, newId, translateQuery, [])
self.duplicateRb('rcReport_Params', curId, newId, translateQuery, [])
self.duplicateRb('rcReport_TableCapCells', curId, newId,
translateQuery, ['name'])
self.model.setIdList(self.select())
return newId
def data(self, index, role=QtCore.Qt.DisplayRole):
column = self.cols()[index.column()]
columnFieldNames = column.fields()
# Получение данных о пользовательских ролях данных
columnOtherRolesInfo = column.otherRolesInfo()
row = index.row()
if role == QtCore.Qt.DisplayRole:
item = self.items[row]
displayFieldNumber = column.displayFieldNumber()
return toVariant(item.get(columnFieldNames[displayFieldNumber], QtCore.QVariant()))
elif role == QtCore.Qt.ToolTipRole:
result = []
item = self.items[row]
for fieldName in columnFieldNames:
value = item.get(fieldName, '')
if isinstance(value, basestring):
result.append(value)
return toVariant(' '.join(result))
# если роль совпадает с одной из настроенных пользвовательских ролей для столбца
elif columnOtherRolesInfo.has_key(role):
# получение имени поля, данные из которого необходимо вернуть для данной роли
userRoleFieldName = columnOtherRolesInfo[role]
item = self.items[row]
return toVariant(item.get(userRoleFieldName, QtCore.QVariant()))
return QtCore.QVariant()
def duplicateRb(self,
tableName,
curId,
newId,
translateQuery,
fieldListToTranslate,
translateField={}):
db = QtGui.qApp.db
table = db.table(tableName)
translate = {}
for record in db.getRecordList(
table, '*', 'master_id = %s' % forceString(curId) +
(' and deleted = 0' if table.hasField('deleted') else u'')):
for fieldName in fieldListToTranslate:
value = forceString(record.value(fieldName))
for curQueryId, newQueryId in translateQuery.items():
value = value.replace(u'q%s' % forceString(curQueryId),
u'q%s' % forceString(newQueryId))
for curFieldId, newFieldId in translateField.items():
value = value.replace(u'f%s' % forceString(curFieldId),
u'f%s' % forceString(newFieldId))
record.setValue(fieldName, toVariant(value))
record.setValue('master_id', toVariant(newId))
curRbId = forceString(record.value('id'))
newRbId = forceString(self.insertRecord(tableName, record))
translate[forceString(curRbId)] = forceString(newRbId)
return translate
def DoSchemaSync():
serverName = forceString(
getVal(QtGui.qApp.preferences.appPrefs, 'SchemaSyncServerName', ''))
serverPort = forceInt(
getVal(QtGui.qApp.preferences.appPrefs, 'SchemaSyncServerPort', 0))
dbName = forceString(
getVal(QtGui.qApp.preferences.appPrefs, 'SchemaSyncDbName', ''))
userName = forceString(
getVal(QtGui.qApp.preferences.appPrefs, 'SchemaSyncUserName', ''))
dlg = CSchemaSyncDialog()
dlg.edtServerName.setText(serverName)
dlg.edtServerPort.setValue(serverPort)
dlg.edtDatabaseName.setText(dbName)
dlg.edtUserName.setText(userName)
dlg.exec_()
QtGui.qApp.preferences.appPrefs['SchemaSyncServerName'] = toVariant(
dlg.edtServerName.text())
QtGui.qApp.preferences.appPrefs['SchemaSyncServerPort'] = toVariant(
dlg.edtServerPort.value())
QtGui.qApp.preferences.appPrefs['SchemaSyncDbName'] = toVariant(
dlg.edtDatabaseName.text())
QtGui.qApp.preferences.appPrefs['SchemaSyncUserName'] = toVariant(
dlg.edtUserName.text())
def addIfNotExistEvent(self, record):
db = QtGui.qApp.db
id = forceRef(
db.translateEx('Event', 'externalId', record['externalId'], 'id'))
if id:
self.clientId = forceRef(
db.translateEx('Event', 'id', id, 'client_id'))
return id
else:
event = db.table('Event').newRecord()
event.setValue('externalId', record['externalId'])
event.setValue('eventType_id', self.eventTypeId)
event.setValue('org_id', self.getOrganisationId(record))
self.clientId = self.addIfNotExistClient(record)
event.setValue('client_id', self.clientId)
# event.setValue('contract_id', ) #Нет
event.setValue('setDate', toVariant(forceDate(record['begDate'])))
event.setValue('execDate', toVariant(forceDate(record['endDate'])))
event.setValue('execPerson_id', forceRef(record['personId']))
event.setValue('createPerson_id', forceRef(record['personId']))
event.setValue('result_id', self.getEventResultId(record))
event.setValue('littleStranger_id',
self.addEventLittleStranger(record))
event.setValue('goal_id', self.getGoalId(record))
self.events += 1
return forceRef(db.insertRecord(db.table('Event'), event))
