AirMapFlightPlanManager.cc 40.1 KB
Newer Older
Gus Grubba's avatar
Gus Grubba committed
1 2 3 4 5 6 7 8 9 10 11 12
/****************************************************************************
 *
 *   (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

#include "AirMapFlightPlanManager.h"
#include "AirMapManager.h"
#include "AirMapRulesetsManager.h"
13
#include "AirMapAdvisoryManager.h"
Gus Grubba's avatar
Gus Grubba committed
14
#include "QGCApplication.h"
15
#include "SettingsManager.h"
Gus Grubba's avatar
Gus Grubba committed
16

17
#include "PlanMasterController.h"
Gus Grubba's avatar
Gus Grubba committed
18 19 20 21
#include "QGCMAVLink.h"

#include "airmap/date_time.h"
#include "airmap/flight_plans.h"
22
#include "airmap/flights.h"
Gus Grubba's avatar
Gus Grubba committed
23
#include "airmap/geometry.h"
24
#include "airmap/pilots.h"
Gus Grubba's avatar
Gus Grubba committed
25 26 27

using namespace airmap;

Gus Grubba's avatar
Gus Grubba committed
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
//-----------------------------------------------------------------------------
AirMapFlightAuthorization::AirMapFlightAuthorization(const Evaluation::Authorization auth, QObject *parent)
    : AirspaceFlightAuthorization(parent)
    , _auth(auth)
{
}

//-----------------------------------------------------------------------------
AirspaceFlightAuthorization::AuthorizationStatus
AirMapFlightAuthorization::status()
{
    switch(_auth.status) {
    case Evaluation::Authorization::Status::accepted:
        return AirspaceFlightAuthorization::Accepted;
    case Evaluation::Authorization::Status::rejected:
        return AirspaceFlightAuthorization::Rejected;
    case Evaluation::Authorization::Status::pending:
        return AirspaceFlightAuthorization::Pending;
    case Evaluation::Authorization::Status::accepted_upon_submission:
        return AirspaceFlightAuthorization::AcceptedOnSubmission;
    case Evaluation::Authorization::Status::rejected_upon_submission:
        return AirspaceFlightAuthorization::RejectedOnSubmission;
    }
    return AirspaceFlightAuthorization::Unknown;
}

Gus Grubba's avatar
Gus Grubba committed
54 55 56
//-----------------------------------------------------------------------------
AirMapFlightInfo::AirMapFlightInfo(const airmap::Flight& flight, QObject *parent)
    : AirspaceFlightInfo(parent)
Gus Grubba's avatar
Gus Grubba committed
57
    , _flight(flight)
Gus Grubba's avatar
Gus Grubba committed
58
{
59 60 61 62 63 64 65 66 67 68 69 70 71 72
    //-- Load bounding box geometry
    const Geometry& geometry = flight.geometry;
    if(geometry.type() == Geometry::Type::polygon) {
        const Geometry::Polygon& polygon = geometry.details_for_polygon();
        for (const auto& vertex :  polygon.outer_ring.coordinates) {
            QGeoCoordinate coord;
            if (vertex.altitude) {
                coord = QGeoCoordinate(vertex.latitude, vertex.longitude, vertex.altitude.get());
            } else {
                coord = QGeoCoordinate(vertex.latitude, vertex.longitude);
            }
            _boundingBox.append(QVariant::fromValue(coord));
        }
    }
Gus Grubba's avatar
Gus Grubba committed
73 74
}

Gus Grubba's avatar
Gus Grubba committed
75 76 77 78
//-----------------------------------------------------------------------------
QString
AirMapFlightInfo::createdTime()
{
Gus Grubba's avatar
Gus Grubba committed
79
    return QDateTime::fromMSecsSinceEpoch(static_cast<qint64>(airmap::milliseconds_since_epoch(_flight.created_at))).toString("yyyy MM dd - hh:mm:ss");
Gus Grubba's avatar
Gus Grubba committed
80 81 82 83 84 85
}

//-----------------------------------------------------------------------------
QString
AirMapFlightInfo::startTime()
{
Gus Grubba's avatar
Gus Grubba committed
86
    return QDateTime::fromMSecsSinceEpoch(static_cast<qint64>(airmap::milliseconds_since_epoch(_flight.start_time))).toString("yyyy MM dd - hh:mm:ss");
Gus Grubba's avatar
Gus Grubba committed
87 88
}

89 90 91 92
//-----------------------------------------------------------------------------
QDateTime
AirMapFlightInfo::qStartTime()
{
Gus Grubba's avatar
Gus Grubba committed
93
    return QDateTime::fromMSecsSinceEpoch(static_cast<qint64>(airmap::milliseconds_since_epoch(_flight.start_time)));
94 95 96 97 98 99
}

//-----------------------------------------------------------------------------
bool
AirMapFlightInfo::active()
{
Gus Grubba's avatar
Gus Grubba committed
100
    QDateTime end = QDateTime::fromMSecsSinceEpoch(static_cast<qint64>(airmap::milliseconds_since_epoch(_flight.end_time)));
101 102 103 104 105 106 107 108 109 110 111 112
    QDateTime now = QDateTime::currentDateTime();
    return end > now;
}

//-----------------------------------------------------------------------------
void
AirMapFlightInfo::setEndFlight(DateTime end)
{
    _flight.end_time = end;
    emit activeChanged();
}

Gus Grubba's avatar
Gus Grubba committed
113 114 115 116
//-----------------------------------------------------------------------------
QString
AirMapFlightInfo::endTime()
{
Gus Grubba's avatar
Gus Grubba committed
117
    return QDateTime::fromMSecsSinceEpoch(static_cast<qint64>(airmap::milliseconds_since_epoch(_flight.end_time))).toString("yyyy MM dd - hh:mm:ss");
Gus Grubba's avatar
Gus Grubba committed
118 119
}

Gus Grubba's avatar
Gus Grubba committed
120 121 122 123 124 125
//-----------------------------------------------------------------------------
AirMapFlightPlanManager::AirMapFlightPlanManager(AirMapSharedState& shared, QObject *parent)
    : AirspaceFlightPlanProvider(parent)
    , _shared(shared)
{
    connect(&_pollTimer, &QTimer::timeout, this, &AirMapFlightPlanManager::_pollBriefing);
Gus Grubba's avatar
Gus Grubba committed
126 127
    _flightStartTime = QDateTime::currentDateTime().addSecs(60);
    _flightEndTime   = _flightStartTime.addSecs(30 * 60);
Gus Grubba's avatar
Gus Grubba committed
128 129
}

Gus Grubba's avatar
Gus Grubba committed
130 131 132 133 134 135 136
//-----------------------------------------------------------------------------
AirMapFlightPlanManager::~AirMapFlightPlanManager()
{
    _advisories.deleteListAndContents();
    _rulesets.deleteListAndContents();
}

Gus Grubba's avatar
Gus Grubba committed
137 138
//-----------------------------------------------------------------------------
void
139 140
AirMapFlightPlanManager::setFlightStartTime(QDateTime start)
{
Gus Grubba's avatar
Gus Grubba committed
141 142 143 144 145
    if(start < QDateTime::currentDateTime()) {
        start = QDateTime::currentDateTime().addSecs(60);
    }
    if(_flightStartTime != start) {
        _flightStartTime = start;
146 147
        emit flightStartTimeChanged();
    }
Gus Grubba's avatar
Gus Grubba committed
148 149 150 151 152
    //-- End has to be after start
    if(_flightEndTime < _flightStartTime) {
        _flightEndTime = _flightStartTime.addSecs(30 * 60);
        emit flightEndTimeChanged();
    }
Gus Grubba's avatar
Gus Grubba committed
153
    qCDebug(AirMapManagerLog) << "Set time start time" << _flightStartTime << _flightEndTime;
154 155 156 157 158 159
}

//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::setFlightEndTime(QDateTime end)
{
Gus Grubba's avatar
Gus Grubba committed
160 161 162 163 164 165
    //-- End has to be after start
    if(end < _flightStartTime) {
        end = _flightStartTime.addSecs(30 * 60);
    }
    if(_flightEndTime != end) {
        _flightEndTime = end;
166 167
        emit flightEndTimeChanged();
    }
Gus Grubba's avatar
Gus Grubba committed
168
    qCDebug(AirMapManagerLog) << "Set time end time" << _flightStartTime << _flightEndTime;
169 170
}

171 172 173 174
//-----------------------------------------------------------------------------
QDateTime
AirMapFlightPlanManager::flightStartTime() const
{
Gus Grubba's avatar
Gus Grubba committed
175
    return _flightStartTime;
176 177 178 179 180 181
}

//-----------------------------------------------------------------------------
QDateTime
AirMapFlightPlanManager::flightEndTime() const
{
Gus Grubba's avatar
Gus Grubba committed
182
    return _flightEndTime;
183 184
}

185 186
//-----------------------------------------------------------------------------
void
187
AirMapFlightPlanManager::startFlightPlanning(PlanMasterController *planController)
Gus Grubba's avatar
Gus Grubba committed
188 189 190 191 192 193 194
{
    if (!_shared.client()) {
        qCDebug(AirMapManagerLog) << "No AirMap client instance. Will not create a flight";
        return;
    }

    if (_state != State::Idle) {
Gus Grubba's avatar
Gus Grubba committed
195
        qCWarning(AirMapManagerLog) << "AirMapFlightPlanManager::startFlightPlanning: State not idle";
Gus Grubba's avatar
Gus Grubba committed
196 197 198
        return;
    }

199
    //-- TODO: Check if there is an ongoing flight plan and do something about it (Delete it?)
200 201

    /*
202
     * if(!flightPlanID().isEmpty()) {
203 204 205 206
     *     do something;
     * }
     */

207 208
    if(!_planController) {
        _planController = planController;
209
        //-- Get notified of mission changes
210
        connect(planController->missionController(), &MissionController::missionBoundingCubeChanged, this, &AirMapFlightPlanManager::_missionChanged);
Gus Grubba's avatar
Gus Grubba committed
211
    }
Gus Grubba's avatar
Gus Grubba committed
212 213
    //-- Set initial flight start time
    setFlightStartTime(QDateTime::currentDateTime().addSecs(5 * 60));
Gus Grubba's avatar
Gus Grubba committed
214 215
}

216 217 218 219
//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::submitFlightPlan()
{
220
    if(flightPlanID().isEmpty()) {
221 222 223
        qCWarning(AirMapManagerLog) << "Submit flight with no flight plan.";
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
224
    _flightId.clear();
Gus Grubba's avatar
Gus Grubba committed
225
    emit flightIDChanged(_flightId);
226 227 228
    _state = State::FlightSubmit;
    FlightPlans::Submit::Parameters params;
    params.authorization = _shared.loginToken().toStdString();
229
    params.id            = flightPlanID().toStdString();
230 231 232 233 234
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
    _shared.client()->flight_plans().submit(params, [this, isAlive](const FlightPlans::Submit::Result& result) {
        if (!isAlive.lock()) return;
        if (_state != State::FlightSubmit) return;
        if (result) {
235 236 237
            _flightPlan = result.value();
            _flightId = QString::fromStdString(_flightPlan.flight_id.get());
            _state = State::Idle;
238
            _pollBriefing();
Gus Grubba's avatar
Gus Grubba committed
239
            emit flightIDChanged(_flightId);
240 241 242 243 244
        } else {
            QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
            emit error("Failed to submit Flight Plan",
                    QString::fromStdString(result.error().message()), description);
            _state = State::Idle;
Gus Grubba's avatar
Gus Grubba committed
245 246
            _flightPermitStatus = AirspaceFlightPlanProvider::PermitRejected;
            emit flightPermitStatusChanged();
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
        }
    });
}

//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::updateFlightPlan()
{
    //-- Are we enabled?
    if(!qgcApp()->toolbox()->settingsManager()->airMapSettings()->enableAirMap()->rawValue().toBool()) {
        return;
    }
    //-- Do we have a license?
    if(!_shared.hasAPIKey()) {
        return;
    }
    _flightPermitStatus = AirspaceFlightPlanProvider::PermitPending;
    emit flightPermitStatusChanged();
265
    _updateFlightPlan(true);
266 267
}

Gus Grubba's avatar
Gus Grubba committed
268 269
//-----------------------------------------------------------------------------
void
270
AirMapFlightPlanManager::endFlight(QString flightID)
Gus Grubba's avatar
Gus Grubba committed
271
{
272 273
    qCDebug(AirMapManagerLog) << "End flight";
    _flightToEnd = flightID;
Gus Grubba's avatar
Gus Grubba committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
    if (_pilotID == "") {
        //-- Need to get the pilot id
        qCDebug(AirMapManagerLog) << "Getting pilot ID";
        _state = State::GetPilotID;
        std::weak_ptr<LifetimeChecker> isAlive(_instance);
        _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
            if (!isAlive.lock()) return;
            Pilots::Authenticated::Parameters params;
            params.authorization = login_token.toStdString();
            _shared.client()->pilots().authenticated(params, [this, isAlive](const Pilots::Authenticated::Result& result) {
                if (!isAlive.lock()) return;
                if (_state != State::GetPilotID) return;
                if (result) {
                    _pilotID = QString::fromStdString(result.value().id);
                    qCDebug(AirMapManagerLog) << "Got Pilot ID:"<<_pilotID;
                    _state = State::Idle;
290
                    _endFlight();
Gus Grubba's avatar
Gus Grubba committed
291 292 293 294 295 296 297 298 299
                } else {
                    _state = State::Idle;
                    QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
                    emit error("Failed to get pilot ID", QString::fromStdString(result.error().message()), description);
                    return;
                }
            });
        });
    } else {
300
        _endFlight();
Gus Grubba's avatar
Gus Grubba committed
301 302 303 304 305
    }
}

//-----------------------------------------------------------------------------
void
306
AirMapFlightPlanManager::_endFlight()
Gus Grubba's avatar
Gus Grubba committed
307
{
308 309
    if(_flightToEnd.isEmpty()) {
        qCDebug(AirMapManagerLog) << "End non existing flight";
Gus Grubba's avatar
Gus Grubba committed
310 311
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
312
    qCDebug(AirMapManagerLog) << "End Flight. State:" << static_cast<int>(_state);
Gus Grubba's avatar
Gus Grubba committed
313
    if(_state != State::Idle) {
314
        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_endFlight);
Gus Grubba's avatar
Gus Grubba committed
315 316
        return;
    }
317 318
    qCDebug(AirMapManagerLog) << "Ending flight:" << _flightToEnd;
    _state = State::FlightEnd;
Gus Grubba's avatar
Gus Grubba committed
319
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
320
    Flights::EndFlight::Parameters params;
Gus Grubba's avatar
Gus Grubba committed
321
    params.authorization = _shared.loginToken().toStdString();
322 323 324
    params.id = _flightToEnd.toStdString();
    //-- End flight
    _shared.client()->flights().end_flight(params, [this, isAlive](const Flights::EndFlight::Result& result) {
Gus Grubba's avatar
Gus Grubba committed
325
        if (!isAlive.lock()) return;
326
        if (_state != State::FlightEnd) return;
Gus Grubba's avatar
Gus Grubba committed
327
        if (result) {
328 329 330 331 332 333 334 335
            qCDebug(AirMapManagerLog) << "Flight Ended";
            int idx = _flightList.findFlightID(_flightToEnd);
            if(idx >= 0) {
                AirMapFlightInfo* pInfo = qobject_cast<AirMapFlightInfo*>(_flightList.get(idx));
                if(pInfo) {
                    pInfo->setEndFlight(result.value().end_time);
                }
            }
Gus Grubba's avatar
Gus Grubba committed
336 337
        } else {
            QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
338
            emit error("End flight failed", QString::fromStdString(result.error().message()), description);
Gus Grubba's avatar
Gus Grubba committed
339
        }
340
        _flightToEnd.clear();
Gus Grubba's avatar
Gus Grubba committed
341 342 343 344
        _state = State::Idle;
    });
}

Gus Grubba's avatar
Gus Grubba committed
345
//-----------------------------------------------------------------------------
346 347
bool
AirMapFlightPlanManager::_collectFlightDtata()
Gus Grubba's avatar
Gus Grubba committed
348
{
349 350 351
    if(!_planController || !_planController->missionController()) {
        return false;
    }
Gus Grubba's avatar
Gus Grubba committed
352
    //-- Get flight bounding cube and prepare (box) polygon
353
    QGCGeoBoundingCube bc = *_planController->missionController()->travelBoundingCube();
Gus Grubba's avatar
Gus Grubba committed
354
    if(!bc.isValid() || (fabs(bc.area()) < 0.0001)) {
355
        //-- TODO: If single point, we need to set a point and a radius instead
356 357
        qCDebug(AirMapManagerLog) << "Not enough points for a flight plan.";
        return false;
358
    }
Gus Grubba's avatar
Gus Grubba committed
359
    _flight.maxAltitude   = static_cast<float>(fmax(bc.pointNW.altitude(), bc.pointSE.altitude()));
360
    _flight.takeoffCoord  = _planController->missionController()->takeoffCoordinate();
361
    _flight.coords        = bc.polygon2D();
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
    _flight.bc            = bc;
    emit missionAreaChanged();
    return true;
}

//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_createFlightPlan()
{
    _flight.reset();

    //-- Get flight data
    if(!_collectFlightDtata()) {
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
377 378 379

    qCDebug(AirMapManagerLog) << "About to create flight plan";
    qCDebug(AirMapManagerLog) << "Takeoff:     " << _flight.takeoffCoord;
380
    qCDebug(AirMapManagerLog) << "Bounding box:" << _flight.bc.pointNW << _flight.bc.pointSE;
381 382
    qCDebug(AirMapManagerLog) << "Flight Start:" << flightStartTime().toString();
    qCDebug(AirMapManagerLog) << "Flight End:  " << flightEndTime().toString();
Gus Grubba's avatar
Gus Grubba committed
383

Gus Grubba's avatar
Gus Grubba committed
384
    if (_pilotID == "" && !_shared.settings().userName.isEmpty() && !_shared.settings().password.isEmpty()) {
Gus Grubba's avatar
Gus Grubba committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398
        //-- Need to get the pilot id before uploading the flight plan
        qCDebug(AirMapManagerLog) << "Getting pilot ID";
        _state = State::GetPilotID;
        std::weak_ptr<LifetimeChecker> isAlive(_instance);
        _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
            if (!isAlive.lock()) return;
            Pilots::Authenticated::Parameters params;
            params.authorization = login_token.toStdString();
            _shared.client()->pilots().authenticated(params, [this, isAlive](const Pilots::Authenticated::Result& result) {
                if (!isAlive.lock()) return;
                if (_state != State::GetPilotID) return;
                if (result) {
                    _pilotID = QString::fromStdString(result.value().id);
                    qCDebug(AirMapManagerLog) << "Got Pilot ID:"<<_pilotID;
399
                    _state = State::Idle;
Gus Grubba's avatar
Gus Grubba committed
400 401
                    _uploadFlightPlan();
                } else {
402
                    _flightPermitStatus = AirspaceFlightPlanProvider::PermitNone;
Gus Grubba's avatar
Gus Grubba committed
403 404 405 406
                    emit flightPermitStatusChanged();
                    _state = State::Idle;
                    QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
                    emit error("Failed to create Flight Plan", QString::fromStdString(result.error().message()), description);
407
                    return;
Gus Grubba's avatar
Gus Grubba committed
408 409 410 411 412 413 414 415 416 417 418
                }
            });
        });
    } else {
        _uploadFlightPlan();
    }

    _flightPermitStatus = AirspaceFlightPlanProvider::PermitPending;
    emit flightPermitStatusChanged();
}

419 420
//-----------------------------------------------------------------------------
void
421
AirMapFlightPlanManager::_updateRulesAndFeatures(std::vector<RuleSet::Id>& rulesets, std::unordered_map<std::string, RuleSet::Feature::Value>& features, bool updateFeatures)
422 423 424 425 426 427 428 429
{
    AirMapRulesetsManager* pRulesMgr = dynamic_cast<AirMapRulesetsManager*>(qgcApp()->toolbox()->airspaceManager()->ruleSets());
    if(pRulesMgr) {
        for(int rs = 0; rs < pRulesMgr->ruleSets()->count(); rs++) {
            AirMapRuleSet* ruleSet = qobject_cast<AirMapRuleSet*>(pRulesMgr->ruleSets()->get(rs));
            //-- If this ruleset is selected
            if(ruleSet && ruleSet->selected()) {
                rulesets.push_back(ruleSet->id().toStdString());
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
                //-- Features within each rule (only when updating)
                if(updateFeatures) {
                    for(int r = 0; r < ruleSet->rules()->count(); r++) {
                        AirMapRule* rule = qobject_cast<AirMapRule*>(ruleSet->rules()->get(r));
                        if(rule) {
                            for(int f = 0; f < rule->features()->count(); f++) {
                                AirMapRuleFeature* feature = qobject_cast<AirMapRuleFeature*>(rule->features()->get(f));
                                if(features.find(feature->name().toStdString()) != features.end()) {
                                    qCDebug(AirMapManagerLog) << "Removing duplicate:" << feature->name();
                                    continue;
                                }
                                if(feature && feature->value().isValid()) {
                                    switch(feature->type()) {
                                    case AirspaceRuleFeature::Boolean:
                                        if(feature->value().toInt() == 0 || feature->value().toInt() == 1) {
                                            features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toBool());
                                        } else {
                                            //-- If not set, default to false
                                            features[feature->name().toStdString()] = RuleSet::Feature::Value(false);
                                        }
                                        break;
                                    case AirspaceRuleFeature::Float:
                                        //-- Sanity check for floats
                                        if(std::isfinite(feature->value().toFloat())) {
Gus Grubba's avatar
Gus Grubba committed
454
                                            features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toDouble());
455 456 457 458 459 460 461 462 463 464
                                        }
                                        break;
                                    case AirspaceRuleFeature::String:
                                        //-- Skip empty responses
                                        if(!feature->value().toString().isEmpty()) {
                                            features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toString().toStdString());
                                        }
                                        break;
                                    default:
                                        qCWarning(AirMapManagerLog) << "Unknown type for feature" << feature->name();
465 466 467 468 469 470 471 472 473 474 475
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Gus Grubba's avatar
Gus Grubba committed
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_updateFlightStartEndTime(DateTime& start_time, DateTime& end_time)
{
    if(_flightStartTime < QDateTime::currentDateTime()) {
        //-- Can't start in the past
        _flightStartTime = QDateTime::currentDateTime();
        emit flightStartTimeChanged();
    }
    quint64 startt = static_cast<quint64>(_flightStartTime.toUTC().toMSecsSinceEpoch());
    start_time = airmap::from_milliseconds_since_epoch(airmap::milliseconds(static_cast<qint64>(startt)));
    //-- End has to be after start
    if(_flightEndTime < _flightStartTime) {
        _flightEndTime = _flightStartTime.addSecs(30 * 60);
        emit flightEndTimeChanged();
    }
    quint64 endt = static_cast<quint64>(_flightEndTime.toUTC().toMSecsSinceEpoch());
    end_time = airmap::from_milliseconds_since_epoch(airmap::milliseconds(static_cast<qint64>(endt)));
}

Gus Grubba's avatar
Gus Grubba committed
496 497 498 499
//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_uploadFlightPlan()
{
Gus Grubba's avatar
Gus Grubba committed
500
    qCDebug(AirMapManagerLog) << "Uploading flight plan. State:" << static_cast<int>(_state);
Gus Grubba's avatar
Gus Grubba committed
501 502 503 504
    if(_state != State::Idle) {
        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_uploadFlightPlan);
        return;
    }
505 506
    //-- Reset "relevant" features
    _importantFeatures.clear();
Gus Grubba's avatar
Gus Grubba committed
507 508 509 510 511 512 513
    _state = State::FlightUpload;
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
    _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
        if (!isAlive.lock()) return;
        if (_state != State::FlightUpload) return;
        FlightPlans::Create::Parameters params;
        params.max_altitude = _flight.maxAltitude;
514
        params.min_altitude = 0.0;
Gus Grubba's avatar
Gus Grubba committed
515
        params.buffer       = 10.f;
Gus Grubba's avatar
Gus Grubba committed
516 517
        params.latitude     = static_cast<float>(_flight.takeoffCoord.latitude());
        params.longitude    = static_cast<float>(_flight.takeoffCoord.longitude());
Gus Grubba's avatar
Gus Grubba committed
518
        params.pilot.id     = _pilotID.toStdString();
Gus Grubba's avatar
Gus Grubba committed
519 520
        //-- Handle flight start/end
        _updateFlightStartEndTime(params.start_time, params.end_time);
521 522
        //-- Rules & Features
        _updateRulesAndFeatures(params.rulesets, params.features);
523 524
        //-- Geometry: polygon
        Geometry::Polygon polygon;
Gus Grubba's avatar
Gus Grubba committed
525 526 527 528
        for (const auto& qcoord : _flight.coords) {
            Geometry::Coordinate coord;
            coord.latitude  = qcoord.latitude();
            coord.longitude = qcoord.longitude();
529
            polygon.outer_ring.coordinates.push_back(coord);
Gus Grubba's avatar
Gus Grubba committed
530
        }
531
        params.geometry = Geometry(polygon);
Gus Grubba's avatar
Gus Grubba committed
532 533 534 535 536
        params.authorization = login_token.toStdString();
        //-- Create flight plan
        _shared.client()->flight_plans().create_by_polygon(params, [this, isAlive](const FlightPlans::Create::Result& result) {
            if (!isAlive.lock()) return;
            if (_state != State::FlightUpload) return;
537
            _state = State::Idle;
Gus Grubba's avatar
Gus Grubba committed
538
            if (result) {
539 540
                _flightPlan = result.value();
                qCDebug(AirMapManagerLog) << "Flight plan created:" << flightPlanID();
Gus Grubba's avatar
Gus Grubba committed
541 542 543
                _pollBriefing();
            } else {
                QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
Gus Grubba's avatar
Gus Grubba committed
544
                emit error("Flight Plan creation failed", QString::fromStdString(result.error().message()), description);
Gus Grubba's avatar
Gus Grubba committed
545 546 547 548 549
            }
        });
    });
}

550 551
//-----------------------------------------------------------------------------
void
552
AirMapFlightPlanManager::_updateFlightPlanOnTimer()
553
{
554 555
    _updateFlightPlan(false);
}
556

557 558 559 560
//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_updateFlightPlan(bool interactive)
{
Gus Grubba's avatar
Gus Grubba committed
561
    qCDebug(AirMapManagerLog) << "Updating flight plan. State:" << static_cast<int>(_state);
Gus Grubba's avatar
Gus Grubba committed
562 563

    if(_state != State::Idle) {
564
        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_updateFlightPlanOnTimer);
Gus Grubba's avatar
Gus Grubba committed
565 566
        return;
    }
567 568 569 570 571
    //-- Get flight data
    if(!_collectFlightDtata()) {
        return;
    }

572 573 574 575
    //-- Update local instance of the flight plan
    _flightPlan.altitude_agl.max  = _flight.maxAltitude;
    _flightPlan.altitude_agl.min  = 0.0f;
    _flightPlan.buffer            = 2.f;
Gus Grubba's avatar
Gus Grubba committed
576 577
    _flightPlan.takeoff.latitude  = static_cast<float>(_flight.takeoffCoord.latitude());
    _flightPlan.takeoff.longitude = static_cast<float>(_flight.takeoffCoord.longitude());
578 579 580
    //-- Rules & Features
    _flightPlan.rulesets.clear();
    _flightPlan.features.clear();
581 582
    //-- If interactive, we collect features otherwise we don't
    _updateRulesAndFeatures(_flightPlan.rulesets, _flightPlan.features, interactive);
Gus Grubba's avatar
Gus Grubba committed
583 584
    //-- Handle flight start/end
    _updateFlightStartEndTime(_flightPlan.start_time, _flightPlan.end_time);
585 586 587 588 589 590 591 592 593
    //-- Geometry: polygon
    Geometry::Polygon polygon;
    for (const auto& qcoord : _flight.coords) {
        Geometry::Coordinate coord;
        coord.latitude  = qcoord.latitude();
        coord.longitude = qcoord.longitude();
        polygon.outer_ring.coordinates.push_back(coord);
    }
    _flightPlan.geometry = Geometry(polygon);
Gus Grubba's avatar
Gus Grubba committed
594 595 596 597 598 599

    qCDebug(AirMapManagerLog) << "Takeoff:     " << _flight.takeoffCoord;
    qCDebug(AirMapManagerLog) << "Bounding box:" << _flight.bc.pointNW << _flight.bc.pointSE;
    qCDebug(AirMapManagerLog) << "Flight Start:" << flightStartTime().toString();
    qCDebug(AirMapManagerLog) << "Flight End:  " << flightEndTime().toString();

600 601 602 603 604
    _state = State::FlightUpdate;
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
    _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
        if (!isAlive.lock()) return;
        if (_state != State::FlightUpdate) return;
605 606
        FlightPlans::Update::Parameters params = {};
        params.authorization                 = login_token.toStdString();
607
        params.flight_plan                   = _flightPlan;
608 609 610 611
        //-- Update flight plan
        _shared.client()->flight_plans().update(params, [this, isAlive](const FlightPlans::Update::Result& result) {
            if (!isAlive.lock()) return;
            if (_state != State::FlightUpdate) return;
612
            _state = State::Idle;
613
            if (result) {
614
                qCDebug(AirMapManagerLog) << "Flight plan updated:" << flightPlanID();
615 616 617
                _pollBriefing();
            } else {
                QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
Gus Grubba's avatar
Gus Grubba committed
618
                emit error("Flight Plan update failed", QString::fromStdString(result.error().message()), description);
619 620 621 622 623
            }
        });
    });
}

624 625 626 627 628 629 630
//-----------------------------------------------------------------------------
static bool
adv_sort(QObject* a, QObject* b)
{
    AirMapAdvisory* aa = qobject_cast<AirMapAdvisory*>(a);
    AirMapAdvisory* bb = qobject_cast<AirMapAdvisory*>(b);
    if(!aa || !bb) return false;
631
    return static_cast<int>(aa->color()) > static_cast<int>(bb->color());
632 633
}

Gus Grubba's avatar
Gus Grubba committed
634 635 636 637 638 639 640
//-----------------------------------------------------------------------------
static bool
rules_sort(QObject* a, QObject* b)
{
    AirMapRule* aa = qobject_cast<AirMapRule*>(a);
    AirMapRule* bb = qobject_cast<AirMapRule*>(b);
    if(!aa || !bb) return false;
641
    return static_cast<int>(aa->status()) > static_cast<int>(bb->status());
Gus Grubba's avatar
Gus Grubba committed
642 643
}

644 645 646 647 648 649 650 651 652 653 654 655 656
//-----------------------------------------------------------------------------
bool
AirMapFlightPlanManager::_findBriefFeature(const QString& name)
{
    for(int i = 0; i < _briefFeatures.count(); i++ ) {
        AirMapRuleFeature* feature = qobject_cast<AirMapRuleFeature*>(_briefFeatures.get(i));
        if (feature && feature->name() == name) {
            return true;
        }
    }
    return false;
}

Gus Grubba's avatar
Gus Grubba committed
657 658 659 660
//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_pollBriefing()
{
661
    qCDebug(AirMapManagerLog) << "Poll Briefing. State:" << static_cast<int>(_state);
662 663
    if(_state != State::Idle) {
        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_pollBriefing);
Gus Grubba's avatar
Gus Grubba committed
664 665
        return;
    }
666
    _state = State::FlightPolling;
Gus Grubba's avatar
Gus Grubba committed
667 668
    FlightPlans::RenderBriefing::Parameters params;
    params.authorization = _shared.loginToken().toStdString();
669
    params.id            = flightPlanID().toStdString();
Gus Grubba's avatar
Gus Grubba committed
670 671 672
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
    _shared.client()->flight_plans().render_briefing(params, [this, isAlive](const FlightPlans::RenderBriefing::Result& result) {
        if (!isAlive.lock()) return;
673
        if (_state != State::FlightPolling) return;
Gus Grubba's avatar
Gus Grubba committed
674 675 676
        if (result) {
            const FlightPlan::Briefing& briefing = result.value();
            qCDebug(AirMapManagerLog) << "Flight polling/briefing response";
677 678 679 680
            //-- Collect advisories
            _valid = false;
            _advisories.clearAndDeleteContents();
            const std::vector<Status::Advisory> advisories = briefing.airspace.advisories;
Gus Grubba's avatar
Gus Grubba committed
681
            _airspaceColor = static_cast<AirspaceAdvisoryProvider::AdvisoryColor>(briefing.airspace.color);
682 683 684 685
            for (const auto& advisory : advisories) {
                AirMapAdvisory* pAdvisory = new AirMapAdvisory(this);
                pAdvisory->_id          = QString::fromStdString(advisory.airspace.id());
                pAdvisory->_name        = QString::fromStdString(advisory.airspace.name());
Gus Grubba's avatar
Gus Grubba committed
686 687
                pAdvisory->_type        = static_cast<AirspaceAdvisory::AdvisoryType>(advisory.airspace.type());
                pAdvisory->_color       = static_cast<AirspaceAdvisoryProvider::AdvisoryColor>(advisory.color);
688 689 690 691 692 693 694 695
                _advisories.append(pAdvisory);
                qCDebug(AirMapManagerLog) << "Adding briefing advisory" << pAdvisory->name();
            }
            //-- Sort in order of color (priority)
            _advisories.beginReset();
            std::sort(_advisories.objectList()->begin(), _advisories.objectList()->end(), adv_sort);
            _advisories.endReset();
            _valid = true;
Gus Grubba's avatar
Gus Grubba committed
696
            //-- Collect Rulesets
Gus Grubba's avatar
Gus Grubba committed
697
            _authorizations.clearAndDeleteContents();
698 699 700 701
            _rulesViolation.clearAndDeleteContents();
            _rulesInfo.clearAndDeleteContents();
            _rulesReview.clearAndDeleteContents();
            _rulesFollowing.clearAndDeleteContents();
702
            _briefFeatures.clear();
Gus Grubba's avatar
Gus Grubba committed
703 704 705 706 707 708
            for(const auto& ruleset : briefing.evaluation.rulesets) {
                AirMapRuleSet* pRuleSet = new AirMapRuleSet(this);
                pRuleSet->_id = QString::fromStdString(ruleset.id);
                //-- Iterate Rules
                for (const auto& rule : ruleset.rules) {
                    AirMapRule* pRule = new AirMapRule(rule, this);
709 710 711 712
                    //-- Iterate Rule Features
                    for (const auto& feature : rule.features) {
                        AirMapRuleFeature* pFeature = new AirMapRuleFeature(feature, this);
                        pRule->_features.append(pFeature);
713
                        if(rule.status == RuleSet::Rule::Status::missing_info) {
714 715
                            if(!_findBriefFeature(pFeature->name())) {
                                _briefFeatures.append(pFeature);
Gus Grubba's avatar
Gus Grubba committed
716
                                _importantFeatures.append(pFeature);
717 718 719 720
                                qCDebug(AirMapManagerLog) << "Adding briefing feature" << pFeature->name() << pFeature->description() << pFeature->type();
                            } else {
                                qCDebug(AirMapManagerLog) << "Skipping briefing feature duplicate" << pFeature->name() << pFeature->description() << pFeature->type();
                            }
721
                        }
722
                    }
723 724
                    //-- When a flight is first created, we send no features. That means that all "missing_info" are "relevant" features.
                    //   We keep a list of them so they will be always shown to the user even when they are no longer "missing_info"
Gus Grubba's avatar
Gus Grubba committed
725 726 727 728 729
                    for(const auto& feature : _importantFeatures) {
                        if(!_findBriefFeature(feature->name())) {
                            _briefFeatures.append(feature);
                        }
                    }
Gus Grubba's avatar
Gus Grubba committed
730
                    pRuleSet->_rules.append(pRule);
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
                    //-- Rules separated by status for presentation
                    switch(rule.status) {
                    case RuleSet::Rule::Status::conflicting:
                        _rulesViolation.append(new AirMapRule(rule, this));
                        break;
                    case RuleSet::Rule::Status::not_conflicting:
                        _rulesFollowing.append(new AirMapRule(rule, this));
                        break;
                    case RuleSet::Rule::Status::missing_info:
                        _rulesInfo.append(new AirMapRule(rule, this));
                        break;
                    case RuleSet::Rule::Status::informational:
                        _rulesReview.append(new AirMapRule(rule, this));
                        break;
                    default:
                        break;
                    }
Gus Grubba's avatar
Gus Grubba committed
748 749
                }
                //-- Sort rules by relevance order
750
                pRuleSet->_rules.beginReset();
Gus Grubba's avatar
Gus Grubba committed
751
                std::sort(pRuleSet->_rules.objectList()->begin(), pRuleSet->_rules.objectList()->end(), rules_sort);
752
                pRuleSet->_rules.endReset();
Gus Grubba's avatar
Gus Grubba committed
753 754 755
                _rulesets.append(pRuleSet);
                qCDebug(AirMapManagerLog) << "Adding briefing ruleset" << pRuleSet->id();
            }
756
            //-- Evaluate briefing status
Gus Grubba's avatar
Gus Grubba committed
757 758 759 760
            bool rejected = false;
            bool accepted = false;
            bool pending  = false;
            for (const auto& authorization : briefing.evaluation.authorizations) {
Gus Grubba's avatar
Gus Grubba committed
761 762
                AirMapFlightAuthorization* pAuth = new AirMapFlightAuthorization(authorization, this);
                _authorizations.append(pAuth);
763
                qCDebug(AirMapManagerLog) << "Autorization:" << pAuth->name() << " (" << pAuth->message() << ")" << static_cast<int>(pAuth->status());
Gus Grubba's avatar
Gus Grubba committed
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
                switch (authorization.status) {
                case Evaluation::Authorization::Status::accepted:
                case Evaluation::Authorization::Status::accepted_upon_submission:
                    accepted = true;
                    break;
                case Evaluation::Authorization::Status::rejected:
                case Evaluation::Authorization::Status::rejected_upon_submission:
                    rejected = true;
                    break;
                case Evaluation::Authorization::Status::pending:
                    pending = true;
                    break;
                }
            }
            if (briefing.evaluation.authorizations.size() == 0) {
                // If we don't get any authorizations, we assume it's accepted
                accepted = true;
            }
Gus Grubba's avatar
Gus Grubba committed
782 783
            emit advisoryChanged();
            emit rulesChanged();
Gus Grubba's avatar
Gus Grubba committed
784
            qCDebug(AirMapManagerLog) << "Flight approval: accepted=" << accepted << "rejected" << rejected << "pending" << pending;
785
            _state = State::Idle;
Gus Grubba's avatar
Gus Grubba committed
786 787 788 789 790 791 792
            if ((rejected || accepted) && !pending) {
                if (rejected) { // rejected has priority
                    _flightPermitStatus = AirspaceFlightPlanProvider::PermitRejected;
                } else {
                    _flightPermitStatus = AirspaceFlightPlanProvider::PermitAccepted;
                }
                emit flightPermitStatusChanged();
793 794
            } else {
                //-- Pending. Try again.
Gus Grubba's avatar
Gus Grubba committed
795
                _pollTimer.setSingleShot(true);
796
                _pollTimer.start(1000);
Gus Grubba's avatar
Gus Grubba committed
797 798
            }
        } else {
799
            _state = State::Idle;
Gus Grubba's avatar
Gus Grubba committed
800 801 802 803 804 805 806 807 808
            QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
            emit error("Brief Request failed",
                    QString::fromStdString(result.error().message()), description);
        }
    });
}

//-----------------------------------------------------------------------------
void
809
AirMapFlightPlanManager::_missionChanged()
Gus Grubba's avatar
Gus Grubba committed
810
{
811 812 813 814 815 816 817 818
    //-- Are we enabled?
    if(!qgcApp()->toolbox()->settingsManager()->airMapSettings()->enableAirMap()->rawValue().toBool()) {
        return;
    }
    //-- Do we have a license?
    if(!_shared.hasAPIKey()) {
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
819
    //-- Creating a new flight plan?
820
    if(_state == State::Idle) {
821
        if(flightPlanID().isEmpty()) {
822 823 824
            _createFlightPlan();
        } else {
            //-- Plan is being modified
825
            _updateFlightPlan();
826
        }
Gus Grubba's avatar
Gus Grubba committed
827 828
    }
}
Gus Grubba's avatar
Gus Grubba committed
829 830 831

//-----------------------------------------------------------------------------
void
Gus Grubba's avatar
Gus Grubba committed
832
AirMapFlightPlanManager::loadFlightList(QDateTime startTime, QDateTime endTime)
Gus Grubba's avatar
Gus Grubba committed
833
{
Gus Grubba's avatar
Gus Grubba committed
834 835 836 837 838 839 840 841
    //-- TODO: This is not checking if the state is Idle. Again, these need to
    //   queued up and handled by a worker thread.
    qCDebug(AirMapManagerLog) << "Preparing load flight list";
    _loadingFlightList = true;
    emit loadingFlightListChanged();
    _rangeStart = startTime;
    _rangeEnd   = endTime;
    qCDebug(AirMapManagerLog) << "List flights from:" << _rangeStart.toString("yyyy MM dd - hh:mm:ss") << "to" << _rangeEnd.toString("yyyy MM dd - hh:mm:ss");
Gus Grubba's avatar
Gus Grubba committed
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
    if (_pilotID == "") {
        //-- Need to get the pilot id
        qCDebug(AirMapManagerLog) << "Getting pilot ID";
        _state = State::GetPilotID;
        std::weak_ptr<LifetimeChecker> isAlive(_instance);
        _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
            if (!isAlive.lock()) return;
            Pilots::Authenticated::Parameters params;
            params.authorization = login_token.toStdString();
            _shared.client()->pilots().authenticated(params, [this, isAlive](const Pilots::Authenticated::Result& result) {
                if (!isAlive.lock()) return;
                if (_state != State::GetPilotID) return;
                if (result) {
                    _pilotID = QString::fromStdString(result.value().id);
                    qCDebug(AirMapManagerLog) << "Got Pilot ID:"<<_pilotID;
                    _state = State::Idle;
                    _loadFlightList();
                } else {
                    _state = State::Idle;
                    QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
                    emit error("Failed to get pilot ID", QString::fromStdString(result.error().message()), description);
Gus Grubba's avatar
Gus Grubba committed
863 864
                    _loadingFlightList = false;
                    emit loadingFlightListChanged();
Gus Grubba's avatar
Gus Grubba committed
865 866 867 868 869 870 871 872 873 874 875 876 877
                    return;
                }
            });
        });
    } else {
        _loadFlightList();
    }
}

//-----------------------------------------------------------------------------
void
AirMapFlightPlanManager::_loadFlightList()
{
878
    qCDebug(AirMapManagerLog) << "Load flight list. State:" << static_cast<int>(_state);
Gus Grubba's avatar
Gus Grubba committed
879 880 881 882
    if(_state != State::Idle) {
        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_loadFlightList);
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
883
    _flightList.clear();
Gus Grubba's avatar
Gus Grubba committed
884 885 886 887 888 889 890 891
    emit flightListChanged();
    _state = State::LoadFlightList;
    std::weak_ptr<LifetimeChecker> isAlive(_instance);
    _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
        if (!isAlive.lock()) return;
        if (_state != State::LoadFlightList) return;
        Flights::Search::Parameters params;
        params.authorization = login_token.toStdString();
892 893 894 895
        quint64 start   = static_cast<quint64>(_rangeStart.toUTC().toMSecsSinceEpoch());
        quint64 end     = static_cast<quint64>(_rangeEnd.toUTC().toMSecsSinceEpoch());
        params.start_after  = airmap::from_milliseconds_since_epoch(airmap::milliseconds(static_cast<long long>(start)));
        params.start_before = airmap::from_milliseconds_since_epoch(airmap::milliseconds(static_cast<long long>(end)));
Gus Grubba's avatar
Gus Grubba committed
896
        params.limit    = 250;
Gus Grubba's avatar
Gus Grubba committed
897 898 899 900 901 902 903 904 905
        params.pilot_id = _pilotID.toStdString();
        _shared.client()->flights().search(params, [this, isAlive](const Flights::Search::Result& result) {
            if (!isAlive.lock()) return;
            if (_state != State::LoadFlightList) return;
            if (result && result.value().flights.size() > 0) {
                const Flights::Search::Response& response = result.value();
                for (const auto& flight : response.flights) {
                    AirMapFlightInfo* pFlight = new AirMapFlightInfo(flight, this);
                    _flightList.append(pFlight);
906
                    qCDebug(AirMapManagerLog) << "Found:" << pFlight->flightID() << pFlight->flightPlanID() << pFlight->endTime();
Gus Grubba's avatar
Gus Grubba committed
907
                }
908
                _flightList.sortStartFlight();
Gus Grubba's avatar
Gus Grubba committed
909 910 911 912 913 914 915
                emit flightListChanged();
            } else {
                if(!result) {
                    QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
                    emit error("Flight search failed", QString::fromStdString(result.error().message()), description);
                }
            }
Gus Grubba's avatar
Gus Grubba committed
916 917 918
            _state = State::Idle;
            _loadingFlightList = false;
            emit loadingFlightListChanged();
Gus Grubba's avatar
Gus Grubba committed
919 920 921 922
        });
    });
}