Пример #1
0
void InputVariableRecord::constructRelatedRecords(const analysis::InputVariable& inputVariable) {
  AttributeVector attributes, dbAttributes;
  InputVariableRecord copyOfThis(getImpl<detail::InputVariableRecord_Impl>());

  if (analysis::OptionalUncertaintyDescription dbUDesc = uncertaintyDescription()) {
    dbAttributes = dbUDesc->cast<analysis::GenericUncertaintyDescription>().attributes();
  }
  if (analysis::OptionalUncertaintyDescription udesc = inputVariable.uncertaintyDescription()) {
    attributes = udesc->cast<analysis::GenericUncertaintyDescription>().attributes();
  }

  for (const Attribute& attribute : attributes) {
    // find in dbOptions
    auto dbIt = std::find_if(dbAttributes.begin(),dbAttributes.end(),
                             std::bind(uuidsEqual<Attribute,Attribute>,std::placeholders::_1,attribute));
    // if not there, or if different versionUUID, save it
    if ((dbIt == dbAttributes.end()) || (attribute.versionUUID() != dbIt->versionUUID())) {
      AttributeRecord udescAttributeRecord(attribute,copyOfThis);
    }

    // if there, erase from dbOptions
    if (dbIt != dbAttributes.end()) {
      dbAttributes.erase(dbIt);
    }
  }

  // any attributes left in dbAttributes should be removed from the database
  ProjectDatabase database = projectDatabase();
  for (const Attribute& toRemove : dbAttributes) {
    AttributeRecord dbUDescAttributeRecord = database.getObjectRecordByHandle<AttributeRecord>(toRemove.uuid()).get();
    database.removeRecord(dbUDescAttributeRecord);
  }
}
Пример #2
0
  std::vector<WorkflowRecord> ProblemRecord_Impl::workflowRecords() const {
    WorkflowRecordVector result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName() +
                            " WHERE problemRecordId=:problemRecordId ORDER BY workflowIndex"));
    query.bindValue(":problemRecordId",id());
    assertExec(query);
    OptionalInt previousIndex;
    bool resort(false);
    while (query.next()) {
      result.push_back(WorkflowRecord::factoryFromQuery(query, database).get());
      int index = result.back().workflowIndex();
      if (previousIndex) {
        if (index < previousIndex.get()) {
          resort = true;
        }
      }
      previousIndex = index;
    }

    if (resort) {
      WorkflowRecordWorkflowIndexLess comparator;
      std::sort(result.begin(),result.end(),comparator);
    }

    return result;
  }
Пример #3
0
  unsigned MeasureGroupRecord_Impl::numMeasures(bool selectedMeasuresOnly) const
  {
    unsigned result = 0;

    ProjectDatabase database = this->projectDatabase();

    QSqlQuery query(*(database.qSqlDatabase()));

    if (selectedMeasuresOnly){
      query.prepare(toQString("SELECT COUNT(*) FROM " + MeasureRecord::databaseTableName() +
          " WHERE variableRecordId=:id AND isSelected=:isSelected"));
      query.bindValue(":id", this->id());
      query.bindValue(":isSelected", true);
    }else{
      query.prepare(toQString("SELECT COUNT(*) FROM " + MeasureRecord::databaseTableName() +
          " WHERE variableRecordId=:id"));
      query.bindValue(":id", this->id());
    }

    assertExec(query);
    if (query.first()){
      result = query.value(0).toUInt();
    }

    return result;
  }
Пример #4
0
  std::vector<VariableRecord> FunctionRecord_Impl::variableRecords() const {
    VariableRecordVector result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() +
        " WHERE functionRecordId=:functionRecordId ORDER BY variableVectorIndex"));
    query.bindValue(":functionRecordId",id());
    assertExec(query);
    OptionalInt previousIndex;
    bool resort(false);
    while (query.next()) {
      result.push_back(VariableRecord::factoryFromQuery(query, database).get());
      int index = result.back().variableVectorIndex();
      if (previousIndex) {
        if (index <= previousIndex.get()) {
          resort = true; // if variables are changed around, order in database itself can
                         // get out of date (as compared to database + dirty records).
        }
      }
      previousIndex = index;
    }

    if (resort) {
      VariableRecordVariableVectorIndexLess comparator;
      std::sort(result.begin(),result.end(),comparator);
    }

    return result;
  }
  std::vector<FunctionRecord> OptimizationProblemRecord_Impl::objectiveRecords() const {
    FunctionRecordVector result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName() +
                  " WHERE problemRecordId=:problemRecordId AND functionType=:functionType " +
                  "ORDER BY functionVectorIndex"));
    query.bindValue(":problemRecordId", id());
    query.bindValue(":functionType",FunctionType::Objective);
    assertExec(query);
    OptionalInt previousIndex;
    bool resort(false);
    while (query.next()) {
      result.push_back(FunctionRecord::factoryFromQuery(query, database).get());
      int index = result.back().functionVectorIndex();
      if (previousIndex) {
        if (index <= previousIndex.get()) {
          resort = true; // if functions are moved around, order in database itself can
                         // get out of date (as compared to database + dirty records).
        }
      }
      previousIndex = index;
    }

    if (resort) {
      FunctionRecordFunctionVectorIndexLess comparator;
      std::sort(result.begin(),result.end(),comparator);
    }

    return result;
  }
Пример #6
0
  MeasureRecord MeasureGroupRecord_Impl::getMeasureRecord(int measureVectorIndex) const
  {
    ProjectDatabase database = this->projectDatabase();
    OptionalMeasureRecord candidate;

    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() +
        " WHERE variableRecordId=:variableRecordId AND measureVectorIndex=:measureVectorIndex"));
    query.bindValue(":variableRecordId", this->id());
    query.bindValue(":measureVectorIndex", measureVectorIndex);
    assertExec(query);
    if (query.first()) {
      candidate = MeasureRecord::factoryFromQuery(query,database).get();
    }

    // check actual vector index. can get out of date during construction.
    if ((!candidate) ||
        (!candidate->measureVectorIndex()) ||
        (candidate->measureVectorIndex().get() != measureVectorIndex))
    {
      // get all and look for index by hand
      for (const MeasureRecord& dpr : measureRecords(false)) {
        if (dpr.measureVectorIndex() && (dpr.measureVectorIndex().get() == measureVectorIndex)) {
          return dpr;
        }
      }
    }
    else {
      return *candidate;
    }
    LOG_AND_THROW("Invalid DiscretMeasure measureVectorIndex "
        << measureVectorIndex << " for MeasureGroup '" << name() << "'.");
    return MeasureRecord(std::shared_ptr<detail::MeasureRecord_Impl>(),database);
  }
Пример #7
0
TEST_F(ProjectFixture, AttributeRecord_ManyAnnualEndUses)
{
  ProjectDatabase database = getCleanDatabase("AttributeRecord_ManyAnnualEndUses");

  for (unsigned i = 0; i < 10; ++i){

    EndUses endUses;
    endUses.addEndUse(25.0, EndUseFuelType::Gas, EndUseCategoryType::Heating);
    endUses.addEndUse(2.0, EndUseFuelType::Electricity, EndUseCategoryType::Cooling);
    endUses.addEndUse(1.0, EndUseFuelType::Electricity, EndUseCategoryType::InteriorLights);
    endUses.addEndUse(10.0, EndUseFuelType::Electricity, EndUseCategoryType::Fans, "Fan Energy");
    endUses.addEndUse(10.0, EndUseFuelType::Water, EndUseCategoryType::Humidifier);

    std::stringstream ss;
    ss << "model " << i;

    FileReferenceRecord model(FileReference(toPath("./in.osm")),database);

    AttributeRecord attributeRecord(endUses.attribute(), model);
    ASSERT_TRUE(model.getAttributeRecord(EndUses::attributeName()));
    EXPECT_TRUE(endUses.attribute() == model.getAttributeRecord(EndUses::attributeName()).get().attribute());
  }

  database.save();
}
Пример #8
0
  std::vector<UrlRecord> CloudSessionRecord_Impl::workerUrlRecords() const {
    UrlRecordVector result;

    // return UrlRecords for which this CloudSessionRecord is the parent and the id is not
    // equal to m_serverUrlRecordId.
    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    std::stringstream ss;
    ss << "SELECT * FROM " << UrlRecord::databaseTableName();
    ss << " WHERE parentDatabaseTableName=:parentDatabaseTableName AND ";
    ss << "parentRecordId=:parentRecordId";
    if (m_serverUrlRecordId) {
      ss << " AND (NOT id=:id)";
    }
    query.prepare(toQString(ss.str()));
    query.bindValue(":parentDatabaseTableName",toQString(databaseTableName()));
    query.bindValue(":parentRecordId",id());
    if (m_serverUrlRecordId) {
      query.bindValue(":id",*m_serverUrlRecordId);
    }
    assertExec(query);
    while (query.next()) {
      UrlRecord workerUrlRecord(query,database);
      result.push_back(workerUrlRecord);
    }

    return result;
  }
Пример #9
0
 void ProjectDatabaseRecord_Impl::updatePathData(const openstudio::path& originalBase,
                                                 const openstudio::path& newBase)
 {
   // don't use arguments -- go to the source
   ProjectDatabase database = projectDatabase();
   setName(toString(database.path()));
   setRunManagerDBPath(completeAndNormalize(database.runManager().dbPath()));
 }
Пример #10
0
 ProjectDatabaseRecord_Impl::ProjectDatabaseRecord_Impl(const std::string& version,
                                                        const openstudio::path& runManagerDBPath,
                                                        const ProjectDatabase& projectDatabase)
   : ObjectRecord_Impl(projectDatabase,
                       toString(projectDatabase.path()),
                       toString(projectDatabase.path().filename()),
                       ""),
   m_version(version),
   m_runManagerDBPath(completeAndNormalize(runManagerDBPath))
 {
 }
Пример #11
0
void ProjectDatabaseRecord::updatePathData(ProjectDatabase database,
                                           const openstudio::path& originalBase,
                                           const openstudio::path& newBase)
{
  bool didStartTransaction = database.startTransaction();

  ProjectDatabaseRecord record = getProjectDatabaseRecord(database);
  record.getImpl<detail::ProjectDatabaseRecord_Impl>()->updatePathData(originalBase,newBase);

  if (didStartTransaction) {
    bool test = database.commitTransaction();
    OS_ASSERT(test);
  }
}
Пример #12
0
  std::vector<AttributeRecord> InputVariableRecord_Impl::attributeRecords() const {
    AttributeRecordVector result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + AttributeRecord::databaseTableName() + " WHERE variableRecordId=:variableRecordId"));
    query.bindValue(":variableRecordId",id());
    assertExec(query);
    while (query.next()) {
      result.push_back(database.getFromQuery<AttributeRecord>(query));
    }

    return result;
  }
// Test not yet to scale re: data points.
TEST_F(ProjectFixture,Profile_SaveAnalysis) {
  Analysis analysis = getAnalysisToRun(100,500);

  // time the process of saving to database
  ptime start = microsec_clock::local_time();
  ProjectDatabase db = getCleanDatabase(toPath("./SaveAnalysis"));
  ASSERT_TRUE(db.startTransaction());
  AnalysisRecord record(analysis,db);
  db.save();
  ASSERT_TRUE(db.commitTransaction());
  time_duration saveTime = microsec_clock::local_time() - start;

  std::cout << "Time: " << to_simple_string(saveTime) << std::endl;
}
// Test not yet to scale re: data points.
TEST_F(ProjectFixture,Profile_ClearAnalysisResults) {
  ProjectDatabase db = getPopulatedDatabase(100,500,true,toPath("./ClearAnalysisResults"));

  // mimic code in AnalysisDriver to avoid adding AnalysisDriver as a dependency

  // time the process of retrieving response function data
  ptime start = microsec_clock::local_time();
  db.unloadUnusedCleanRecords();
  ASSERT_TRUE(db.startTransaction());
  DataPointRecordVector dataPointRecords = DataPointRecord::getDataPointRecords(db);
  EXPECT_EQ(500u,dataPointRecords.size());
  BOOST_FOREACH(project::DataPointRecord& dataPointRecord,dataPointRecords) {
    // in AnalysisDriver, removes DataPoint directories, but they don't exist here
    db.removeRecord(dataPointRecord);
  }
Пример #15
0
  openstudio::runmanager::Workflow WorkflowRecord_Impl::workflow() const {
    ProjectDatabase projectDatabase = this->projectDatabase();

    openstudio::runmanager::Workflow result;
    openstudio::runmanager::RunManager runManager = projectDatabase.runManager();
    try {
      result = runManager.loadWorkflow(m_runManagerWorkflowKey);
      result.setUUID(handle());
    }
    catch (...) {
      LOG(Error,"Unable to load workflow from RunManager using key "
          << m_runManagerWorkflowKey << ". Returning empty Workflow.");
    }

    return result;
  }
Пример #16
0
  std::vector<OSArgumentRecord> RubyMeasureRecord_Impl::osArgumentRecords() const
  {
    OSArgumentRecordVector result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + OSArgumentRecord::databaseTableName() +
                            " WHERE rubyPerturbationRecordId=:rubyPerturbationId"));
    query.bindValue(":rubyPerturbationRecordId",id());
    assertExec(query);
    while (query.next()) {
      result.push_back(OSArgumentRecord(query,database));
    }

    return result;
  }
  OSArgumentRecord RubyContinuousVariableRecord_Impl::osArgumentRecord() const {
    OptionalOSArgumentRecord result;

    ProjectDatabase database = projectDatabase();
    QSqlQuery query(*(database.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + OSArgumentRecord::databaseTableName() +
        " WHERE rubyContinuousVariableRecordId=:rubyContinuousVariableRecordId" ));
    query.bindValue(":rubyContinuousVariableRecordId",id());
    assertExec(query);
    if (query.first()) {
      result = OSArgumentRecord::factoryFromQuery(query, database);
    }
    OS_ASSERT(result);

    return *result;
  }
Пример #18
0
  static bool unlink(int leftId, int rightId, ProjectDatabase projectDatabase)
  {
    bool result = false;

    QSqlQuery query(*(projectDatabase.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE leftId=:leftId AND rightId=:rightId"));
    query.bindValue(":leftId", leftId);
    query.bindValue(":rightId", rightId);
    assertExec(query);
    if (query.first()){
      T object(std::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase);
      result = projectDatabase.removeRecord(object);
    }

    return result;
  }
Пример #19
0
TEST_F(ProjectFixture, AttributeRecord_AttributeTypes)
{
  ProjectDatabase database = getCleanDatabase("AttributeRecord_AttributeTypes");

  FileReferenceRecord model(FileReference(toPath("./in.osm")),database);

  EXPECT_EQ(static_cast<unsigned>(0), AttributeRecord::getAttributeRecords(database).size());
  EXPECT_EQ(static_cast<unsigned>(0), model.attributeRecords().size());

  // make attributes
  Attribute boolAttribute("bool", true);
  Attribute unsignedAttribute("unsigned", 2u);
  Attribute intAttribute("int", -1);
  Attribute doubleAttribute("double", 1.23, std::string("m"));
  Attribute stringAttribute("string", "hello");
  // because of tracking by UUID, have to make separate child attributes
  AttributeVector childAttributes;
  childAttributes.push_back(Attribute("bool", true));
  childAttributes.push_back(Attribute("bool", true));
  Attribute vectorAttribute("vector", childAttributes);

  // create AttributeRecords
  AttributeRecord boolAttributeRecord(boolAttribute, model);
  AttributeRecord unsignedAttributeRecord(unsignedAttribute, model);
  AttributeRecord intAttributeRecord(intAttribute, model);
  AttributeRecord doubleAttributeRecord(doubleAttribute, model);
  AttributeRecord stringAttributeRecord(stringAttribute, model);
  AttributeRecord vectorAttributeRecord(vectorAttribute, model);

  ASSERT_TRUE(model.getAttributeRecord("bool"));
  EXPECT_TRUE(boolAttribute == model.getAttributeRecord("bool").get().attribute());
  ASSERT_TRUE(model.getAttributeRecord("unsigned"));
  EXPECT_TRUE(unsignedAttribute == model.getAttributeRecord("unsigned").get().attribute());
  ASSERT_TRUE(model.getAttributeRecord("int"));
  EXPECT_TRUE(intAttribute == model.getAttributeRecord("int").get().attribute());
  ASSERT_TRUE(model.getAttributeRecord("double"));
  EXPECT_TRUE(doubleAttribute == model.getAttributeRecord("double").get().attribute());
  ASSERT_TRUE(model.getAttributeRecord("string"));
  EXPECT_TRUE(stringAttribute == model.getAttributeRecord("string").get().attribute());
  ASSERT_TRUE(model.getAttributeRecord("vector"));
  EXPECT_TRUE(vectorAttribute == model.getAttributeRecord("vector").get().attribute());

  EXPECT_EQ(static_cast<unsigned>(6), AttributeRecord::getAttributeRecords(database).size());
  EXPECT_EQ(static_cast<unsigned>(6), model.attributeRecords().size());

  database.save();
}
Пример #20
0
      static bool unlinkLeft(int leftId, ProjectDatabase projectDatabase)
      {
        bool result = false;

        std::vector<T> toRemove;
        
        QSqlQuery query(*(projectDatabase.qSqlDatabase()));
        query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE leftId=:leftId"));
        query.bindValue(":leftId", leftId);
        assertExec(query);
        while(query.next()){
          T object(boost::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase);
          toRemove.push_back(object);
        }

        BOOST_FOREACH(T object, toRemove){
          result = projectDatabase.removeRecord(object);
        }
Пример #21
0
  std::vector<MeasureRecord> MeasureGroupRecord_Impl::measureRecords(bool selectedMeasuresOnly) const
  {
    std::vector<MeasureRecord> result;

    ProjectDatabase database = this->projectDatabase();

    QSqlQuery query(*(database.qSqlDatabase()));

    if (selectedMeasuresOnly){
      query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() +
          " WHERE variableRecordId=:id AND isSelected=:isSelected ORDER BY measureVectorIndex"));
      query.bindValue(":id", this->id());
      query.bindValue(":isSelected", true);
    }else{
      query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() +
          " WHERE variableRecordId=:id ORDER BY measureVectorIndex"));
      query.bindValue(":id", this->id());
    }

    assertExec(query);
    OptionalInt previousIndex;
    bool resort(false);
    while (query.next()){
      boost::optional<MeasureRecord> measure = MeasureRecord::factoryFromQuery(query, database);
      OS_ASSERT(measure);
      result.push_back(*measure);
      OptionalInt index = result.back().measureVectorIndex();
      if (previousIndex && index) {
        if (index.get() <= previousIndex.get()) {
          resort = true;
        }
      }
      if (index) {
        previousIndex = index;
      }
    }

    if (resort) {
      MeasureRecordMeasureVectorIndexLess comparator;
      std::sort(result.begin(),result.end(),comparator);
    }

    return result;
  }
Пример #22
0
void MeasureGroupRecord::constructMeasureRecords(const analysis::MeasureGroup& measureGroup) {
  MeasureGroupRecord copyOfThis(getImpl<detail::MeasureGroupRecord_Impl>());
  ProjectDatabase database = copyOfThis.projectDatabase();
  bool isNew = database.isNewRecord(copyOfThis);

  int i = 0;
  std::vector<UUID> measureUUIDs;
  for (const Measure& measure : measureGroup.measures(false)) {
    measureUUIDs.push_back(measure.uuid());
    if (measure.isDirty() || isNew) {
      MeasureRecord newMeasureRecord =
          MeasureRecord::factoryFromMeasure(measure,copyOfThis,i);
    }
    ++i;
  }
  if (!isNew) {
    removeMeasureRecords(measureUUIDs,database);
  }
}
Пример #23
0
TEST_F(ProjectFixture, ProblemRecord_RubyContinuousVariables)
{
  // Create a database containing a ProblemRecord with a chain of 
  // RubyContinuousVariables that reference the same RubyMeasure
  analysis::Problem problem("Contains Linked RubyContinuousVariables");

  // Measure with two RubyContinuousVariables  
  analysis::RubyMeasure wwrScript(openstudio::toPath(rubyLibDir()) / 
                                  openstudio::toPath("openstudio/sketchup_plugin/user_scripts/Alter or Add Model Elements/Set_Window_to_Wall_Ratio.rb"),
                                  FileReferenceType::OSM,
                                  FileReferenceType::OSM,
                                  true);
  ruleset::OSArgument arg = ruleset::OSArgument::makeDoubleArgument("wwr");
  analysis::RubyContinuousVariable wwr("Window to Wall Ratio",arg,wwrScript);
  wwr.setMinimum(0.15);
  wwr.setMaximum(0.60);
  problem.push(wwr);
  arg = ruleset::OSArgument::makeDoubleArgument("offset");
  analysis::RubyContinuousVariable offset("Window Offset from Floor",arg,wwrScript);
  offset.setMinimum(0.5);
  offset.setMaximum(2.0);
  problem.push(offset);
  EXPECT_EQ(wwr.measure(), offset.measure());
  
  // Project Database
  ProjectDatabase database = getCleanDatabase("ProblemRecord_RubyContinuousVariables");

  // Problem Record
  ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
  database.save();

  // Deserialize the problem and verify that the deserialized RubyMeasures are 
  // all equal.  
  problemRecord = ProblemRecord::getProblemRecords(database)[0];
  problem = problemRecord.problem();
  ASSERT_EQ(2u,problem.variables().size());
  ASSERT_TRUE(problem.variables()[0].optionalCast<RubyContinuousVariable>());
  ASSERT_TRUE(problem.variables()[1].optionalCast<RubyContinuousVariable>());
  EXPECT_EQ(problem.variables()[0].cast<RubyContinuousVariable>().measure(), 
            problem.variables()[1].cast<RubyContinuousVariable>().measure());
}
Пример #24
0
  static bool unlinkRight(int rightId, ProjectDatabase projectDatabase)
  {
    bool result = false;

    std::vector<T> toRemove;

    QSqlQuery query(*(projectDatabase.qSqlDatabase()));
    query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE rightId=:rightId"));
    query.bindValue(":rightId", rightId);
    assertExec(query);
    while(query.next()){
      T object(std::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase);
      toRemove.push_back(object);
    }

    for (T object : toRemove){
      result = projectDatabase.removeRecord(object);
    }

    return result;
  }
Пример #25
0
std::vector<UrlRecord> UrlRecord::getUrlRecords(ProjectDatabase& database) {
  std::vector<UrlRecord> result;

  QSqlQuery query(*(database.qSqlDatabase()));
  query.prepare(toQString("SELECT * FROM " + UrlRecord::databaseTableName()));
  assertExec(query);
  while (query.next()) {
    result.push_back(UrlRecord(query, database));
  }

  return result;
}
Пример #26
0
TEST_F(ProjectFixture,CloudSessionRecord_VagrantPopulated) {
  std::string id;
  UUID uuid, versionUUID;
  {
    ProjectDatabase database = getCleanDatabase("CloudSessionRecord_VagrantPopulated");

    VagrantSession session(toString(createUUID()),
                           Url("http://localhost:8080"),
                           UrlVector(1u,Url("http://localhost:8081")));
    id = session.sessionId();
    uuid = session.uuid();
    versionUUID = session.versionUUID();

    CloudSessionRecord record = CloudSessionRecord::factoryFromCloudSession(session,database);
    database.save();

    EXPECT_EQ(1u,CloudSessionRecord::getCloudSessionRecords(database).size());    
  }
  {
    ProjectDatabase database = getExistingDatabase("CloudSessionRecord_VagrantPopulated");

    EXPECT_EQ(1u,CloudSessionRecord::getCloudSessionRecords(database).size());
    ASSERT_FALSE(CloudSessionRecord::getCloudSessionRecords(database).empty());

    CloudSessionRecord record = CloudSessionRecord::getCloudSessionRecords(database)[0];

    CloudSession session = record.cloudSession();
    ASSERT_TRUE(session.optionalCast<VagrantSession>());

    VagrantSession vagrantSession = session.cast<VagrantSession>();
    EXPECT_EQ(uuid,vagrantSession.uuid());
    EXPECT_EQ(versionUUID,vagrantSession.versionUUID());
    EXPECT_EQ("VagrantProvider",vagrantSession.cloudProviderType());
    EXPECT_EQ(id,vagrantSession.sessionId());
    ASSERT_TRUE(vagrantSession.serverUrl());
    EXPECT_EQ(Url("http://localhost:8080"),vagrantSession.serverUrl().get());
    ASSERT_EQ(1u,vagrantSession.workerUrls().size());
    EXPECT_EQ(Url("http://localhost:8081"),vagrantSession.workerUrls()[0]);
  }
}
Пример #27
0
std::vector<VagrantSessionRecord> VagrantSessionRecord::getVagrantSessionRecords(ProjectDatabase& database) {
  std::vector<VagrantSessionRecord> result;

  QSqlQuery query(*(database.qSqlDatabase()));
  query.prepare(toQString("SELECT * FROM " + CloudSessionRecord::databaseTableName() + " WHERE cloudSessionRecordType=:cloudSessionRecordType"));
  query.bindValue(":cloudSessionRecordType", CloudSessionRecordType::VagrantSessionRecord);
  assertExec(query);
  while (query.next()) {
    result.push_back(VagrantSessionRecord(query, database));
  }

  return result;
}
Пример #28
0
boost::optional<FunctionRecord> FunctionRecord::getFunctionRecord(int id, ProjectDatabase& database) {
  boost::optional<FunctionRecord> result;

  QSqlQuery query(*(database.qSqlDatabase()));
  query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName() + " WHERE id=:id"));
  query.bindValue(":id",id);
  assertExec(query);
  if (query.first()) {
    result = FunctionRecord::factoryFromQuery(query, database);
  }

  return result;
}
Пример #29
0
std::vector<WorkflowRecord> WorkflowRecord::getWorkflowRecords(ProjectDatabase& projectDatabase)
{
  std::vector<WorkflowRecord> result;

  QSqlQuery query(*(projectDatabase.qSqlDatabase()));
  query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName()));
  assertExec(query);
  while (query.next()) {
    result.push_back(projectDatabase.getFromQuery<WorkflowRecord>(query));
  }

  return result;
}
Пример #30
0
void CloudSessionRecord::constructRelatedRecords(const CloudSession& cloudSession,
                                                 ProjectDatabase& database)
{
  CloudSessionRecord copyOfThis(getImpl<detail::CloudSessionRecord_Impl>());
  bool isNew = database.isNewRecord(copyOfThis);
  if (!isNew) {
    getImpl<detail::CloudSessionRecord_Impl>()->revertToLastRecordIds();
  }
  
  if (isNew || (getImpl<detail::CloudSessionRecord_Impl>()->lastUuidLast() != cloudSession.versionUUID())) {
    // remove any existing UrlRecords that have this object as its parent
    ObjectRecordVector childUrls = children();
    for (ObjectRecord& childUrl : childUrls) {
      database.removeRecord(childUrl);
    }
    // create new UrlRecords 
    OptionalAWSSession awsSession = cloudSession.optionalCast<AWSSession>();
    if (OptionalUrl serverUrl = cloudSession.serverUrl()) {
      UrlRecord serverRecord(*serverUrl,copyOfThis);
      if (awsSession) {
        serverRecord.setName(awsSession->serverId());
      }
      getImpl<detail::CloudSessionRecord_Impl>()->setServerUrlRecordId(serverRecord.id());
    }
    StringVector workerIds;
    if (awsSession) {
      workerIds = awsSession->workerIds();
    }
    unsigned index(0);
    for (const Url& workerUrl : cloudSession.workerUrls()) {
      UrlRecord workerRecord(workerUrl,copyOfThis);
      if (index < workerIds.size()) {
        workerRecord.setName(workerIds[index]);
      }
      ++index;
    }
  }
}