/**
* Finds the destination file by @srcUrl and @role.
* Checks hash for both destination and source files.
* If hashes are ok then returns the destination file.
*/
static QString getFileToFileInfo(const QString &srcUrl, const QString &role, WorkflowProcess &process) {
AppFileStorage *fileStorage = AppContext::getAppFileStorage();
if (NULL != fileStorage) {
U2OpStatus2Log os;
QString dstUrl = fileStorage->getFileInfo(srcUrl, role, process, os);
CHECK_OP(os, "");
if (!dstUrl.isEmpty() && QFile::exists(dstUrl)) {
QString srcHash = fileStorage->getFileInfo(srcUrl, StorageRoles::HASH, process, os);
CHECK_OP(os, "");
QString dstHash = fileStorage->getFileInfo(dstUrl, StorageRoles::HASH, process, os);
CHECK_OP(os, "");
if ((getCommonHashForFile(dstUrl) == dstHash) &&
(getCommonHashForFile(srcUrl) == srcHash)) {
FileInfo fToFInfo(srcUrl, role, dstUrl);
fileStorage->addFileOwner(fToFInfo, process, os);
CHECK_OP(os, "");
return dstUrl;
}
}
}
return "";
}
QList<U2ObjectRelation> MysqlObjectRelationsDbi::getObjectRelations( const U2DataId &object,
U2OpStatus &os )
{
QList<U2ObjectRelation> result;
static const QString queryString = "SELECT o.type, o.name, o_r.object, o_r.reference, o_r.role FROM ObjectRelation AS o_r "
"INNER JOIN Object AS o ON o.id = o_r.reference WHERE o_r.object = :object";
U2SqlQuery q( queryString, db, os );
CHECK_OP(os, result);
q.bindDataId( ":object", object );
while ( q.step( ) ) {
U2ObjectRelation relation;
const U2DataType objectType = U2DbiUtils::toType( object );
const U2DataType referenceType = q.getInt32( 0 );
relation.referencedType = U2ObjectTypeUtils::toGObjectType( referenceType );
relation.referencedName = q.getString( 1 );
relation.id = q.getDataId( 2, objectType );
relation.referencedObject = q.getDataId( 3, referenceType );
relation.relationRole = static_cast<GObjectRelationRole>( q.getInt32( 4 ) );
result << relation;
CHECK_OP(os, result);
}
return result;
}
int LMDBEngine::Del(const Slice& key, const Options& options)
{
LMDBContext& holder = m_ctx_local.GetValue();
MDB_txn *txn = holder.readonly_txn;
if (NULL == txn || holder.batch_write == 0)
{
MDB_val k;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
CHECK_OP(mdb_txn_begin(m_env, NULL, 0, &txn));
CHECK_OP(mdb_del(txn, m_dbi, &k, NULL));
CHECK_OP(mdb_txn_commit(txn));
return 0;
}
DelOperation* op = new DelOperation;
op->key.assign((const char*) key.data(), key.size());
m_write_queue.Push(op);
if (holder.batch_write == 0)
{
CheckPointOperation* ck = new CheckPointOperation(holder.cond);
m_write_queue.Push(ck);
NotifyBackgroundThread();
ck->Wait();
DELETE(ck);
return 0;
}
return 0;
}
Task::ReportResult GTest_DNAcompareSequencesInTwoObjects::report() {
Document* doc = getContext<Document>(this, docContextName);
if (doc == NULL) {
stateInfo.setError(QString("document not found %1").arg(docContextName));
return ReportResult_Finished;
}
Document* doc2 = getContext<Document>(this, secondDocContextName);
if (doc2 == NULL) {
stateInfo.setError(QString("document not found %1").arg(secondDocContextName));
return ReportResult_Finished;
}
const QList<GObject*>& objs = doc->getObjects();
const QList<GObject*>& objs2 = doc2->getObjects();
GObject*obj=NULL;
GObject*obj2=NULL;
U2SequenceObject * mySequence;
U2SequenceObject * mySequence2;
for(int i=0;(i!=objs.size())&&(i!=objs2.size());i++){
obj = objs.at(i);
obj2 = objs2.at(i);
if((obj->getGObjectType()== GObjectTypes::SEQUENCE)&&(obj2->getGObjectType()== GObjectTypes::SEQUENCE)){
mySequence = qobject_cast<U2SequenceObject*>(obj);
if(mySequence==NULL){
stateInfo.setError(QString("can't cast to sequence from: %1 in position %2").arg(obj->getGObjectName()).arg(i));
return ReportResult_Finished;
}
mySequence2 = qobject_cast<U2SequenceObject*>(obj2);
if(mySequence2==NULL){
stateInfo.setError(QString("can't cast to sequence from: %1 in position %2").arg(obj2->getGObjectName()).arg(i));
return ReportResult_Finished;
}
if(mySequence->getWholeSequenceData(stateInfo) != mySequence2->getWholeSequenceData(stateInfo)){
CHECK_OP(stateInfo, ReportResult_Finished);
stateInfo.setError(QString("Sequences of object in position %1 not matched").arg(i));
return ReportResult_Finished;
}
CHECK_OP(stateInfo, ReportResult_Finished);
}
}
if (objs.size() != objs2.size()) {
QString error("Number of objects in doc mismatches: [%1=%2] vs [%3=%4]");
error = error.arg(docContextName).arg(objs.size())
.arg(secondDocContextName).arg(objs2.size());
if (obj) {
error += QString("\nLast good object: %1").arg(obj->getGObjectName());
}
stateInfo.setError(error);
}
return ReportResult_Finished;
}
void CProtoGearPrice::GetGearArrField(VT_PROTO_FIELD &vtField, const GearPriceAckItem &ackItem)
{
static BOOL arOptional[] = {
FALSE, FALSE, FALSE,
FALSE, FALSE, FALSE,
};
static EProtoFildType arFieldType[] = {
ProtoFild_Int32, ProtoFild_Int32, ProtoFild_Int64,
ProtoFild_Int32, ProtoFild_Int32, ProtoFild_Int64,
};
static LPCSTR arFieldKey[] = {
"BuyPrice", "BuyOrder", "BuyVol",
"SellPrice", "SellOrder", "SellVol",
};
GearPriceAckItem &item = const_cast<GearPriceAckItem &>(ackItem);
void *arPtr[] = {
&item.nBuyPrice, &item.nBuyOrder, &item.nBuyVolume,
&item.nSellPrice, &item.nSellOrder, &item.nSellVolume,
};
CHECK_OP(_countof(arOptional) == _countof(arFieldType), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arFieldKey), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arPtr), NOOP);
vtField.clear();
PROTO_FIELD field;
for ( int n = 0; n < _countof(arOptional); n++ )
{
field.bOptional = arOptional[n];
field.eFieldType = arFieldType[n];
field.strFieldKey = arFieldKey[n];
switch (field.eFieldType)
{
case ProtoFild_Int32:
field.pInt32 = (int*)arPtr[n];
break;
case ProtoFild_Int64:
field.pInt64 = (INT64*)arPtr[n];
break;
case ProtoFild_StringA:
field.pStrA = (std::string*)arPtr[n];
break;
case ProtoFild_StringW:
field.pStrW = (std::wstring*)arPtr[n];
break;
default:
CHECK_OP(FALSE, NOOP);
break;
}
vtField.push_back(field);
}
}
//tomodify 7
void CProtoQueryHKOrder::GetProtoBodyField_Req(VT_PROTO_FIELD &vtField, const ProtoReqBodyType &reqData)
{
static BOOL arOptional[] = {
TRUE, FALSE,
};
static EProtoFildType arFieldType[] = {
ProtoFild_Int32, ProtoFild_Int32,
};
static LPCSTR arFieldKey[] = {
"EnvType", "Cookie",
};
ProtoReqBodyType &body = const_cast<ProtoReqBodyType &>(reqData);
void *arPtr[] = {
&body.nEnvType, &body.nCookie,
};
CHECK_OP(_countof(arOptional) == _countof(arFieldType), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arFieldKey), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arPtr), NOOP);
vtField.clear();
PROTO_FIELD field;
for ( int n = 0; n < _countof(arOptional); n++ )
{
field.bOptional = arOptional[n];
field.eFieldType = arFieldType[n];
field.strFieldKey = arFieldKey[n];
switch (field.eFieldType)
{
case ProtoFild_Int32:
field.pInt32 = (int*)arPtr[n];
break;
case ProtoFild_Int64:
field.pInt64 = (INT64*)arPtr[n];
break;
case ProtoFild_StringA:
field.pStrA = (std::string*)arPtr[n];
break;
case ProtoFild_StringW:
field.pStrW = (std::wstring*)arPtr[n];
break;
default:
CHECK_OP(FALSE, NOOP);
break;
}
vtField.push_back(field);
}
}
//tomodify 8
void CProtoGearPrice::GetProtoBodyField_Ack(VT_PROTO_FIELD &vtField, const ProtoAckBodyType &ackData)
{
static BOOL arOptional[] = {
FALSE, FALSE,
};
static EProtoFildType arFieldType[] = {
ProtoFild_Int32, ProtoFild_StringA
};
static LPCSTR arFieldKey[] = {
"Market", "StockCode",
};
ProtoAckBodyType &body = const_cast<ProtoAckBodyType &>(ackData);
void *arPtr[] = {
&body.nStockMarket, &body.strStockCode,
};
CHECK_OP(_countof(arOptional) == _countof(arFieldType), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arFieldKey), NOOP);
CHECK_OP(_countof(arOptional) == _countof(arPtr), NOOP);
vtField.clear();
PROTO_FIELD field;
for ( int n = 0; n < _countof(arOptional); n++ )
{
field.bOptional = arOptional[n];
field.eFieldType = arFieldType[n];
field.strFieldKey = arFieldKey[n];
switch (field.eFieldType)
{
case ProtoFild_Int32:
field.pInt32 = (int*)arPtr[n];
break;
case ProtoFild_Int64:
field.pInt64 = (INT64*)arPtr[n];
break;
case ProtoFild_StringA:
field.pStrA = (std::string*)arPtr[n];
break;
case ProtoFild_StringW:
field.pStrW = (std::wstring*)arPtr[n];
break;
default:
CHECK_OP(FALSE, NOOP);
break;
}
vtField.push_back(field);
}
}
Task* HMM3SearchWorker::tick() {
while (hmmPort->hasMessage()) {
hmms << hmmPort->get().getData().toMap().value(HMM3Lib::HMM3_SLOT.getId()).value<const P7_HMM*>();
}
if (!hmmPort->isEnded()) { // || hmms.isEmpty() || !seqPort->hasMessage()
return NULL;
}
if (seqPort->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(seqPort);
if (inputMessage.isEmpty() || hmms.isEmpty()) {
output->transit();
return NULL;
}
SharedDbiDataHandler seqId = inputMessage.getData().toMap().value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence dnaSequence = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
if (dnaSequence.alphabet->getType() != DNAAlphabet_RAW) {
QList<Task*> subtasks;
UHMM3SearchTaskSettings settings;
settings.inner = cfg;
foreach(const P7_HMM* hmm, hmms) {
subtasks << new UHMM3SWSearchTask (hmm, dnaSequence, settings);
}
void LMDBIterator::Next()
{
int rc;
rc = mdb_cursor_get(m_cursor, &m_key, &m_value, MDB_NEXT);
CHECK_OP(rc);
m_valid = rc == 0;
}
QList<U2MsaRow> MysqlMsaDbi::getRows(const U2DataId& msaId, U2OpStatus& os) {
QList<U2MsaRow> res;
MysqlTransaction t(db, os);
Q_UNUSED(t);
static const QString rowString = "SELECT rowId, sequence, gstart, gend, length FROM MsaRow WHERE msa = :msa ORDER BY pos";
U2SqlQuery rowQuery(rowString, db, os);
rowQuery.bindDataId(":msa", msaId);
static const QString gapString = "SELECT gapStart, gapEnd FROM MsaRowGap WHERE msa = :msa AND rowId = :rowId ORDER BY gapStart";
while (rowQuery.step()) {
U2MsaRow row;
row.rowId = rowQuery.getInt64(0);
row.sequenceId = rowQuery.getDataId(1, U2Type::Sequence);
row.gstart = rowQuery.getInt64(2);
row.gend = rowQuery.getInt64(3);
row.length = rowQuery.getInt64(4);
U2SqlQuery gapQuery(gapString, db, os);
gapQuery.bindDataId(":msa", msaId);
gapQuery.bindInt64(":rowId", row.rowId);
while (gapQuery.step()) {
U2MsaGap gap;
gap.offset = gapQuery.getInt64(0);
gap.gap = gapQuery.getInt64(1) - gap.offset;
row.gaps.append(gap);
}
CHECK_OP(os, res);
res.append(row);
}
return res;
}
int LMDBEngine::Get(const Slice& key, std::string* value, const Options& options)
{
MDB_val k, v;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
int rc;
LMDBContext& holder = m_ctx_local.GetValue();
MDB_txn *txn = holder.readonly_txn;
if (NULL == holder.readonly_txn)
{
rc = mdb_txn_begin(m_env, NULL, MDB_RDONLY, &txn);
if (rc != 0)
{
ERROR_LOG("Failed to create txn for get for reason:%s", mdb_strerror(rc));
return -1;
}
}
rc = mdb_get(txn, m_dbi, &k, &v);
if (NULL == holder.readonly_txn)
{
CHECK_OP(mdb_txn_commit(txn));
}
if (0 == rc && NULL != value && NULL != v.mv_data)
{
value->assign((const char*) v.mv_data, v.mv_size);
}
return rc;
}
void CPluginChangeOrder_US::SetTradeReqData(int nCmdID, const Json::Value &jsnVal, SOCKET sock)
{
CHECK_RET(nCmdID == PROTO_ID_QUOTE && sock != INVALID_SOCKET, NORET);
CHECK_RET(m_pTradeOp && m_pTradeServer, NORET);
CProtoQuote proto;
CProtoQuote::ProtoReqDataType req;
proto.SetProtoData_Req(&req);
if ( !proto.ParseJson_Req(jsnVal) )
{
CHECK_OP(false, NORET);
return;
}
CHECK_RET(req.head.nProtoID == nCmdID && req.body.nCookie, NORET);
ChangeOrderReqBody &body = req.body;
StockDataReq *pReq = new StockDataReq;
CHECK_RET(pReq, NORET);
pReq->sock = sock;
pReq->dwReqTick = ::GetTickCount();
pReq->req = req;
pReq->bWaitDelaySvrID = true;
DoTryProcessTradeOpt(pReq);
}
U2VariantTrack MysqlVariantDbi::getVariantTrack(const U2DataId& variantTrackId, U2OpStatus& os) {
U2VariantTrack res;
DBI_TYPE_CHECK(variantTrackId, U2Type::VariantTrack, os, res);
MysqlTransaction t(db, os);
Q_UNUSED(t);
dbi->getMysqlObjectDbi()->getObject(res, variantTrackId, os);
CHECK_OP(os, res);
static const QString queryString = "SELECT sequence, sequenceName, trackType, fileHeader FROM VariantTrack WHERE object = :object";
U2SqlQuery q(queryString, db, os);
q.bindDataId(":object", variantTrackId);
if (q.step()) {
res.sequence = q.getDataId(0, U2Type::Sequence);
res.sequenceName = q.getString(1);
int trackType = q.getInt32(2);
CHECK_EXT(TrackType_FIRST <= trackType && trackType <= TrackType_LAST,
os.setError(U2DbiL10n::tr("Invalid variant track type: %1").arg(trackType)), res);
res.trackType = static_cast<VariantTrackType>(trackType);
res.fileHeader = q.getString(3);
q.ensureDone();
}
return res;
}
QList<Task*> AceImporterTask::onSubTaskFinished(Task* subTask) {
QList<Task*> res;
CHECK_OP(stateInfo, res);
if (isSqliteDbTransit && convertTask == subTask) {
initCloneObjectTasks();
res << cloneTasks;
}
else if (isSqliteDbTransit && cloneTasks.contains(subTask)) {
cloneTasks.removeOne(subTask);
if (cloneTasks.isEmpty()) {
initLoadDocumentTask();
CHECK(NULL != loadDocTask, res);
res << loadDocTask;
}
}
else if (!isSqliteDbTransit && convertTask == subTask) {
initLoadDocumentTask();
CHECK(NULL != loadDocTask, res);
res << loadDocTask;
}
if (loadDocTask == subTask) {
resultDocument = loadDocTask->takeDocument();
}
return res;
}
Task::ReportResult PairwiseAlignmentHirschbergTask::report() {
propagateSubtaskError();
CHECK_OP(stateInfo, ReportResult_Finished);
assert(kalignSubTask->inputMA.getNumRows() == kalignSubTask->resultMA.getNumRows());
return ReportResult_Finished;
}
void LMDBIterator::Seek(const Slice& target)
{
m_key.mv_data = const_cast<char*>(target.data());
m_key.mv_size = target.size();
int rc = mdb_cursor_get(m_cursor, &m_key, &m_value, MDB_SET_RANGE);
CHECK_OP(rc);
m_valid = rc == 0;
}
Task::ReportResult GTest_CalculateTreeFromAligment::report()
{
if (task == NULL) {
return ReportResult_Finished;
}
if (!task->hasError()) {
PhyTree tree = task->getResult();
U2DbiRef dbiRef = AppContext::getDbiRegistry()->getSessionTmpDbiRef(stateInfo);
CHECK_OP(stateInfo, ReportResult_Finished);
PhyTreeObject *obj = PhyTreeObject::createInstance(tree, treeObjContextName, dbiRef, stateInfo);
CHECK_OP(stateInfo, ReportResult_Finished);
addContext(treeObjContextName,obj);
}
return ReportResult_Finished;
}
QList<Task *> FindORFsToAnnotationsTask::onSubTaskFinished(Task *subTask) {
CHECK(subTask == fTask, QList<Task *>());
const QList<ORFFindResult> results = fTask->popResults();
QList<SharedAnnotationData> annotationList;
foreach (const ORFFindResult &res, results) {
CHECK_OP(stateInfo, QList<Task *>());
annotationList << res.toAnnotation(ORFAlgorithmSettings::ANNOTATION_GROUP_NAME);
}
U2Msa MAlignmentExporter::getAlignmentObject(const U2DbiRef &dbiRef, const U2DataId &msaId, U2OpStatus &os) const {
SAFE_POINT(!con.isOpen(), OPENED_DBI_CONNECTION_ERROR, U2Msa());
con.open(dbiRef, false, os);
U2Msa msa = exportAlignmentObject(msaId, os);
CHECK_OP(os, U2Msa());
return msa;
}
BioStruct3DObject * BioStruct3DObject::createInstance(const BioStruct3D &bioStruct3D,
const QString &objectName, const U2DbiRef &dbiRef, U2OpStatus &os, const QVariantMap &hintsMap)
{
U2BioStruct3D object(dbiRef);
object.visualName = objectName;
object.serializer = BioStruct3DSerializer::ID;
const QString folder = hintsMap.value(DocumentFormat::DBI_FOLDER_HINT, U2ObjectDbi::ROOT_FOLDER).toString();
RawDataUdrSchema::createObject(dbiRef, folder, object, os);
CHECK_OP(os, NULL);
const U2EntityRef entRef(dbiRef, object.id);
const QByteArray data = BioStruct3DSerializer::serialize(bioStruct3D);
RawDataUdrSchema::writeContent(data, entRef, os);
CHECK_OP(os, NULL);
return new BioStruct3DObject(bioStruct3D, objectName, entRef, hintsMap);
}
QList<Task*> DNASequenceGeneratorTask::onGenerateTaskFinished( ) {
QList<Task *> resultTasks;
SAFE_POINT( generateTask->isFinished( ) && !generateTask->getStateInfo( ).isCoR( ),
"Invalid task encountered", resultTasks );
IOAdapterFactory *iof = AppContext::getIOAdapterRegistry( )->getIOAdapterFactoryById(
IOAdapterUtils::url2io( cfg.getOutUrlString( ) ) );
if (cfg.saveDoc) {
DocumentFormat *format = AppContext::getDocumentFormatRegistry()->getFormatById(cfg.getDocumentFormatId());
Document* doc = format->createNewLoadedDocument(iof, cfg.getOutUrlString(), stateInfo);
CHECK_OP( stateInfo, resultTasks );
const QSet<QString> &supportedFormats = format->getSupportedObjectTypes( );
const bool isSequenceFormat = supportedFormats.contains( GObjectTypes::SEQUENCE );
if ( isSequenceFormat) {
addSequencesToSeqDoc( doc );
} else { // consider alignment format
SAFE_POINT( supportedFormats.contains( GObjectTypes::MULTIPLE_SEQUENCE_ALIGNMENT ),
"Unexpected format encountered", resultTasks );
addSequencesToMsaDoc( doc );
}
saveTask = new SaveDocumentTask(doc, SaveDoc_Overwrite);
resultTasks << saveTask;
} else { // TODO: avoid high memory consumption here
const DNAAlphabet *alp = cfg.getAlphabet( );
SAFE_POINT( NULL != alp, "Generated sequence has invalid alphabet", resultTasks );
const U2DbiRef dbiRef = generateTask->getDbiRef( );
const QString baseSeqName = cfg.getSequenceName( );
QList<U2Sequence> seqs = generateTask->getResults( );
for ( int sequenceNum = 0, totalSeqCount = seqs.size( ); sequenceNum < totalSeqCount;
++sequenceNum )
{
const QString seqName = ( 1 < totalSeqCount )
? ( baseSeqName + " " + QString::number( sequenceNum + 1 ) ) : baseSeqName;
DbiConnection con( dbiRef, stateInfo );
CHECK_OP( stateInfo, resultTasks );
const QByteArray seqContent = con.dbi->getSequenceDbi( )->getSequenceData(
seqs[sequenceNum].id, U2_REGION_MAX, stateInfo );
results << DNASequence( seqName, seqContent, alp );
}
}
return resultTasks;
}
void CPluginChangeOrder_US::HandleTimeoutReq()
{
if ( m_vtReqData.empty() )
{
SetTimerHandleTimeout(false);
return;
}
DWORD dwTickNow = ::GetTickCount();
VT_REQ_TRADE_DATA::iterator it_req = m_vtReqData.begin();
for ( ; it_req != m_vtReqData.end(); )
{
StockDataReq *pReq = *it_req;
if ( pReq == NULL )
{
CHECK_OP(false, NOOP);
++it_req;
continue;
}
//
if (pReq->bWaitDelaySvrID)
{
continue;;
}
if ( int(dwTickNow - pReq->dwReqTick) > 8000 )
{
TradeAckType ack;
ack.head = pReq->req.head;
ack.head.ddwErrCode= PROTO_ERR_SERVER_TIMEROUT;
CA::Unicode2UTF(L"协议超时", ack.head.strErrDesc);
//tomodify 5
ack.body.nEnvType = pReq->req.body.nEnvType;
ack.body.nCookie = pReq->req.body.nCookie;
ack.body.nSvrOrderID = pReq->req.body.nSvrOrderID;
ack.body.nLocalOrderID = pReq->req.body.nLocalOrderID;
ack.body.nSvrResult = Trade_SvrResult_Failed;
HandleTradeAck(&ack, pReq->sock);
it_req = m_vtReqData.erase(it_req);
delete pReq;
}
else
{
++it_req;
}
}
if ( m_vtReqData.empty() )
{
SetTimerHandleTimeout(false);
return;
}
}
Task * AssemblyModel::createLoadReferenceAndAddToProjectTask(const U2CrossDatabaseReference& ref) {
QString url = ref.dataRef.dbiRef.dbiId;
U2OpStatus2Log os;
Document* refDoc = ObjectViewTask::createDocumentAndAddToProject(url, AppContext::getProject(), os);
CHECK_OP(os, NULL);
Task * t = new LoadUnloadedDocumentTask(refDoc);
return t;
}
QList<U2DataId> MysqlObjectRelationsDbi::getReferenceRelatedObjects( const U2DataId &reference,
GObjectRelationRole relationRole, U2OpStatus &os )
{
QList<U2DataId> result;
static const QString queryString = "SELECT o.id, o.type FROM Object AS o INNER JOIN ObjectRelation AS o_r "
"ON o.id = o_r.object WHERE o_r.reference = :reference AND o_r.role = :role";
U2SqlQuery q( queryString, db, os );
CHECK_OP(os, result);
q.bindDataId( ":reference", reference );
q.bindInt32( ":role", relationRole );
while ( q.step( ) ) {
const U2DataType objType = q.getInt32( 1 );
result.append( q.getDataId( 0, objType ) );
CHECK_OP(os, result);
}
return result;
}
UdrRecordId createObjectCore(UdrDbi *dbi, const QString& folder, U2RawData &object, U2OpStatus &os) {
dbi->createObject(RawDataUdrSchema::ID, object, folder, os);
CHECK_OP(os, UdrRecordId("", ""));
QList<UdrValue> data;
data << UdrValue(object.id);
data << UdrValue();
data << UdrValue(object.serializer);
return dbi->addRecord(RawDataUdrSchema::ID, data, os);
}
UdrRecordId retrieveObject(UdrDbi *dbi, U2RawData &object, U2OpStatus &os) {
UdrRecordId recId = getRecordId(dbi, object.id, os);
CHECK_OP(os, recId);
UdrRecord record = dbi->getRecord(recId, os);
CHECK_OP(os, recId);
U2Object obj;
dbi->getRootDbi()->getObjectDbi()->getObject(obj, object.id, os);
CHECK_OP(os, recId);
object.visualName = obj.visualName;
object.version = obj.version;
CHECK_OP(os, recId);
object.serializer = record.getString(SERIALIZER, os);
CHECK_OP(os, recId);
return recId;
}
QWidget * BowtieWidgetController::createGUI(U2OpStatus &os) {
QScopedPointer<QWidget> result(new QWidget());
QVBoxLayout *vl = new QVBoxLayout();
vl->setContentsMargins(0, 0, 0, 0);
QHBoxLayout *hl = new QHBoxLayout(result.data());
hl->setContentsMargins(0, 0, 0, 0);
hl->addLayout(vl);
vl->addWidget(dirCtrl->createGUI(os));
CHECK_OP(os, NULL);
vl->addWidget(nameCtrl->createGUI(os));
CHECK_OP(os, NULL);
QPushButton *browseButton = new QPushButton(tr("Select\nbowtie index file"), result.data());
browseButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
connect(browseButton, SIGNAL(clicked()), SLOT(sl_browse()));
hl->addWidget(browseButton);
return result.take();
}
bool TestDbiProvider::init(const QString& dbiFileName, bool _useConnectionPool){
if(initialized){
close();
initialized = false;
}
TestRunnerSettings* trs = AppContext::getAppSettings()->getTestRunnerSettings();
QString originalFile = trs->getVar("COMMON_DATA_DIR") + "/" + dbiFileName;
QString tmpFile = QDir::temp().absoluteFilePath(QFileInfo(originalFile).fileName());
if(QFile::exists(tmpFile)) {
QFile::remove(tmpFile);
}
bool _create = false;
if (QFile::exists(originalFile)) {
SAFE_POINT(QFile::copy(originalFile, tmpFile), "db file not copied", false);
}else{
_create = true;
}
dbUrl = tmpFile;
useConnectionPool = _useConnectionPool;
U2DbiFactory *factory = AppContext::getDbiRegistry()->getDbiFactoryById(SQLITE_DBI_ID);
SAFE_POINT(factory!=NULL, "No dbi factory", false);
U2OpStatusImpl opStatus;
if(useConnectionPool){
U2DbiRef ref;
ref.dbiFactoryId = factory->getId();
ref.dbiId = dbUrl;
dbi = AppContext::getDbiRegistry()->getGlobalDbiPool()->openDbi(ref, _create, opStatus);
CHECK_OP(opStatus, false);
}else{
dbi = factory->createDbi();
SAFE_POINT(NULL != dbi, "dbi not created", false);
QHash<QString, QString> properties;
if(_create){
properties[U2DbiOptions::U2_DBI_OPTION_CREATE] = U2DbiOptions::U2_DBI_VALUE_ON;
}
properties["url"] = dbUrl;
QVariantMap persistentData;
dbi->init(properties, persistentData, opStatus);
SAFE_POINT_OP(opStatus, false);
}
U2ObjectDbi* objDbi = dbi->getObjectDbi();
SAFE_POINT(NULL != objDbi, "object dbi not loaded", false);
initialized = true;
return true;
}
QList<MAlignmentRowReplacementData> MAlignmentExporter::getAlignmentRows(const U2DbiRef& dbiRef,
const U2DataId& msaId, const QList<qint64> rowIds, U2OpStatus& os) const
{
SAFE_POINT(!con.isOpen(), OPENED_DBI_CONNECTION_ERROR, QList<MAlignmentRowReplacementData>());
con.open(dbiRef, false, os);
CHECK_OP(os, QList<MAlignmentRowReplacementData>());
QList<U2MsaRow> rows = exportRows(msaId, rowIds, os);
CHECK_OP(os, QList<MAlignmentRowReplacementData>());
QList<DNASequence> sequences = exportSequencesOfRows(rows, os);
CHECK_OP(os, QList<MAlignmentRowReplacementData>());
QList<MAlignmentRowReplacementData> result;
SAFE_POINT(rows.count() == sequences.count(), ROWS_SEQS_COUNT_MISMATCH_ERROR,
QList<MAlignmentRowReplacementData>());
for ( int i = 0; i < rows.length( ); ++i ) {
result << MAlignmentRowReplacementData( sequences.at(i), rows.at( i ) );
}
return result;
}
//tomodify 5(数组等复杂结构或单层的结构体)
bool CProtoGearPrice::MakeProtoBody_Req(Json::Value &jsnVal, const ProtoReqDataType &data)
{
CHECK_RET(warn_if_prop_exists(jsnVal, KEY_REQ_PARAM), false);
VT_PROTO_FIELD vtField;
GetProtoBodyField_Req(vtField, data.body);
Json::Value &jsnBody = jsnVal[KEY_REQ_PARAM];
bool bSuc = CProtoParseBase::MakeProtoFields(jsnBody, vtField);
CHECK_OP(bSuc, NOOP);
return bSuc;
}
