PHP Runalyze\Configuration类代码示例

 /**
  * Database key
  * @return string
  */
 public function column()
 {
     if (\Runalyze\Configuration::Vdot()->useElevationCorrection()) {
         return 'vdot_with_elevation';
     }
     return 'vdot';
 }

 public function testStaticMethod()
 {
     Configuration::General()->temperatureUnit()->set(TemperatureUnit::CELSIUS);
     $unit = ' ' . Configuration::General()->TemperatureUnit()->unit();
     $this->assertEquals('10.0' . $unit, Temperature::format(10, true, 1));
     $this->assertEquals('12.35' . $unit, Temperature::format(12.3456, true, 2));
 }

 /**
  * Init pointer to DB/Error-object
  */
 protected function initInternalObjects()
 {
     parent::initInternalObjects();
     if (!\Runalyze\Configuration::Privacy()->showPrivateActivitiesInList()) {
         $this->DatasetQuery->showOnlyPublicActivities();
     }
 }

 /**
  * Athlete
  * @return \Runalyze\Athlete
  */
 public static function Athlete()
 {
     if (!isset(self::$Objects['athlete'])) {
         self::$Objects['athlete'] = new Athlete(Configuration::General()->gender(), Configuration::Data()->HRmax(), Configuration::Data()->HRrest(), null, null, Configuration::Data()->vdot());
     }
     return self::$Objects['athlete'];
 }

 /**
  * Add to plot
  * @param \Plot $Plot
  * @param int $yAxis
  * @param boolean $addAnnotations [optional]
  */
 public function addTo(Plot &$Plot, $yAxis, $addAnnotations = true)
 {
     if (empty($this->Data)) {
         return;
     }
     parent::addTo($Plot, $yAxis, $addAnnotations);
     switch ($this->XAxis) {
         case DataCollector::X_AXIS_DISTANCE:
             $Plot->setXUnitFactor(Configuration::General()->distanceUnitSystem()->distanceToPreferredUnitFactor(), Configuration::General()->distanceUnitSystem()->distanceUnit());
             $stepSize = Configuration::General()->distanceUnitSystem()->distanceToKmFactor();
             if ($stepSize != round($stepSize)) {
                 end($this->Data);
                 $totalDistanceInKm = key($this->Data);
                 while ($totalDistanceInKm / $stepSize > 15) {
                     $stepSize *= 2;
                 }
                 while ($totalDistanceInKm / $stepSize < 4) {
                     $stepSize /= 2;
                 }
                 $Plot->Options['xaxis']['tickSize'] = $stepSize;
             }
             break;
         case DataCollector::X_AXIS_TIME:
             $Plot->setXAxisAsTime();
             $Plot->setXAxisTimeFormat("%h:%M:%S");
             $Plot->Options['xaxis']['ticks'] = 5;
             break;
         case DataCollector::X_AXIS_INDEX:
             $Plot->hideXLabels();
     }
 }

 /**
  * Move Distance
  * @return bool
  */
 public function nextDistance()
 {
     if (Configuration::General()->distanceUnitSystem()->isImperial()) {
         return $this->nextMile();
     }
     return $this->nextKilometer();
 }

 /**
  * Parse general values
  */
 protected function parseGeneralValues()
 {
     $this->TrainingObject->setTimestamp(strtotime((string) $this->XML['StartTime']));
     if (!empty($this->XML['categoryName'])) {
         $this->guessSportID((string) $this->XML['categoryName']);
     } else {
         $this->TrainingObject->setSportid(Configuration::General()->mainSport());
     }
     if (!empty($this->XML->Duration['TotalSeconds'])) {
         $this->TrainingObject->setTimeInSeconds(round((double) $this->XML->Duration['TotalSeconds']));
     }
     if (!empty($this->XML->Distance['TotalMeters'])) {
         $this->TrainingObject->setDistance(round((double) $this->XML->Distance['TotalMeters']) / 1000);
     }
     if (!empty($this->XML->Calories['TotalCal'])) {
         $this->TrainingObject->setCalories((int) $this->XML->Calories['TotalCal']);
     }
     if (!empty($this->XML->Location['Name'])) {
         $this->TrainingObject->setRoute((string) $this->XML->Location['Name']);
     }
     if (!empty($this->XML->Weather['Temp'])) {
         $this->TrainingObject->setTemperature((int) $this->XML->Weather['Temp']);
     }
     if (!empty($this->XML->HeartRateMaximumBPM)) {
         $this->TrainingObject->setPulseMax((int) $this->XML->HeartRateMaximumBPM);
     }
     if (!empty($this->XML->HeartRateAverageBPM)) {
         $this->TrainingObject->setPulseAvg((int) $this->XML->HeartRateAverageBPM);
     }
 }

 /**
  * Parse general values
  */
 protected function parseGeneralValues()
 {
     $this->TrainingObject->setTimestamp(strtotime((string) $this->XML->GeneralInformation->startDate));
     $this->TrainingObject->setCalories((int) $this->XML->GeneralInformation->calories);
     $this->TrainingObject->setSportid(Configuration::General()->mainSport());
     $this->TrainingObject->setCreatorDetails($this->findCreator());
     $this->TrainingObject->setComment((string) $this->XML->GeneralInformation->name);
 }

 /**
  * Prepare summary
  */
 protected function prepare()
 {
     $this->Title = __('All years');
     $this->Timerange = 366 * DAY_IN_S;
     $this->TimeEnd = mktime(23, 59, 59, 12, 31, date('Y'));
     $this->TimeStart = mktime(0, 0, 1, 1, 1, date('Y', START_TIME));
     $this->AdditionalColumns = 1 * ($this->Sportid == Configuration::General()->runningSport());
 }

 public function testStaticMethod()
 {
     Configuration::General()->weightUnit()->set(WeightUnit::KG);
     $unit = ' ' . Configuration::General()->weightUnit()->unit();
     $this->assertEquals('10.0' . $unit, Weight::format(10, true, 1));
     $this->assertEquals('12.346' . $unit, Weight::format(12.3456, true, 3));
     $this->assertEquals('12.3', Weight::format(12.3456, false, 1));
 }

 /**
  * Parse general values
  */
 protected function parseGeneralValues()
 {
     $this->TrainingObject->setTimestamp(strtotime((string) $this->XML->DeviceLog->Header->DateTime));
     if (!empty($this->XML->DeviceLog->Header->Activity)) {
         $this->guessSportID((string) $this->XML->DeviceLog->Header->Activity);
     } else {
         $this->TrainingObject->setSportid(Configuration::General()->runningSport());
     }
 }

 /**
  * Tasks before insertion
  */
 protected function before()
 {
     parent::before();
     $Calculator = new Calculator($this->Object);
     if (Configuration::ActivityForm()->correctElevation() && !$this->Object->hasCorrectedElevations()) {
         $Calculator->tryToCorrectElevation();
     }
     $Calculator->calculateElevation();
 }

 /**
  * Manipulate data
  */
 protected function manipulateData()
 {
     $UnitSystem = Configuration::General()->distanceUnitSystem();
     if ($UnitSystem->isImperial()) {
         $this->Data = array_map(function ($value) {
             return $value * DistanceUnitSystem::FEET_MULTIPLIER / 1000 / 100;
         }, $this->Data);
     }
 }

 /**
  * Create series
  * @var \Runalyze\View\Activity\Context $context
  */
 public function __construct(Activity\Context $context)
 {
     $this->isRunning = $context->activity()->sportid() == Configuration::General()->runningSport();
     $cadence = $this->isRunning ? new CadenceUnitRunning(0) : new CadenceUnit(0);
     $this->initOptions();
     $this->initData($context->trackdata(), Trackdata::CADENCE);
     $this->initStrings($cadence);
     $this->manipulateData($cadence);
 }

 /**
  * Initialize internal sports-array from database
  */
 private static function initAllSports()
 {
     self::$AllSports = array();
     $sports = self::cacheAllSports();
     foreach ($sports as $sport) {
         self::$AllSports[(string) $sport['id']] = $sport;
     }
     Configuration::ActivityForm()->orderSports()->sort(self::$AllSports);
 }