src/drive/drives.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2019 David Barchiesi <david@barchie.si>
0003
0004     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0005 */
0006
0007 #include "drives.h"
0008 #include "driveservice.h"
0009 #include "utils_p.h"
0010
0011 #include <QJsonDocument>
0012 #include <QUrlQuery>
0013 #include <QVariant>
0014
0015 namespace
0016 {
0017 static const QString ApiKind = QStringLiteral("drive#drive");
0018 static const QString ApiKindList = QStringLiteral("drive#driveList");
0019 }
0020
0021 using namespace KGAPI2;
0022 using namespace KGAPI2::Drive;
0023
0024 ///// Drives::Restrictions
0025
0026 class Q_DECL_HIDDEN Drives::Restrictions::Private
0027 {
0028 public:
0029     Private() = default;
0030     Private(const Private &other) = default;
0031
0032     bool adminManagedRestrictions = false;
0033     bool copyRequiresWriterPermission = false;
0034     bool domainUsersOnly = false;
0035     bool driveMembersOnly = false;
0036 };
0037
0038 Drives::Restrictions::Restrictions()
0039     : d(new Private)
0040 {
0041 }
0042
0043 Drives::Restrictions::Restrictions(const Drives::Restrictions &other)
0044     : d(new Private(*(other.d)))
0045 {
0046 }
0047
0048 Drives::Restrictions::~Restrictions() = default;
0049
0050 bool Drives::Restrictions::operator==(const Drives::Restrictions &other) const
0051 {
0052     GAPI_COMPARE(adminManagedRestrictions);
0053     GAPI_COMPARE(copyRequiresWriterPermission);
0054     GAPI_COMPARE(domainUsersOnly);
0055     GAPI_COMPARE(driveMembersOnly);
0056     return true;
0057 }
0058
0059 bool Drives::Restrictions::adminManagedRestrictions() const
0060 {
0061     return d->adminManagedRestrictions;
0062 }
0063
0064 void Drives::Restrictions::setAdminManagedRestrictions(bool adminManagedRestrictions) const
0065 {
0066     d->adminManagedRestrictions = adminManagedRestrictions;
0067 }
0068
0069 bool Drives::Restrictions::copyRequiresWriterPermission() const
0070 {
0071     return d->copyRequiresWriterPermission;
0072 }
0073
0074 void Drives::Restrictions::setCopyRequiresWriterPermission(bool copyRequiresWriterPermission) const
0075 {
0076     d->copyRequiresWriterPermission = copyRequiresWriterPermission;
0077 }
0078
0079 bool Drives::Restrictions::domainUsersOnly() const
0080 {
0081     return d->domainUsersOnly;
0082 }
0083
0084 void Drives::Restrictions::setDomainUsersOnly(bool domainUsersOnly) const
0085 {
0086     d->domainUsersOnly = domainUsersOnly;
0087 }
0088
0089 bool Drives::Restrictions::driveMembersOnly() const
0090 {
0091     return d->driveMembersOnly;
0092 }
0093
0094 void Drives::Restrictions::setDriveMembersOnly(bool driveMembersOnly) const
0095 {
0096     d->driveMembersOnly = driveMembersOnly;
0097 }
0098
0099 ///// Drives::Capabilities
0100
0101 class Q_DECL_HIDDEN Drives::Capabilities::Private
0102 {
0103 public:
0104     Private() = default;
0105     Private(const Private &other) = default;
0106
0107     bool canAddChildren = false;
0108     bool canChangeCopyRequiresWriterPermissionRestriction = false;
0109     bool canChangeDomainUsersOnlyRestriction = false;
0110     bool canChangeDriveBackground = false;
0111     bool canChangeDriveMembersOnlyRestriction = false;
0112     bool canComment = false;
0113     bool canCopy = false;
0114     bool canDeleteChildren = false;
0115     bool canDeleteDrive = false;
0116     bool canDownload = false;
0117     bool canEdit = false;
0118     bool canListChildren = false;
0119     bool canManageMembers = false;
0120     bool canReadRevisions = false;
0121     bool canRename = false;
0122     bool canRenameDrive = false;
0123     bool canShare = false;
0124     bool canTrashChildren = false;
0125 };
0126
0127 Drives::Capabilities::Capabilities()
0128     : d(new Private)
0129 {
0130 }
0131
0132 Drives::Capabilities::Capabilities(const Drives::Capabilities &other)
0133     : d(new Private(*(other.d)))
0134 {
0135 }
0136
0137 Drives::Capabilities::~Capabilities() = default;
0138
0139 bool Drives::Capabilities::operator==(const Drives::Capabilities &other) const
0140 {
0141     GAPI_COMPARE(canAddChildren);
0142     GAPI_COMPARE(canChangeCopyRequiresWriterPermissionRestriction);
0143     GAPI_COMPARE(canChangeDomainUsersOnlyRestriction);
0144     GAPI_COMPARE(canChangeDriveBackground);
0145     GAPI_COMPARE(canChangeDriveMembersOnlyRestriction);
0146     GAPI_COMPARE(canComment);
0147     GAPI_COMPARE(canCopy);
0148     GAPI_COMPARE(canDeleteChildren);
0149     GAPI_COMPARE(canDeleteDrive);
0150     GAPI_COMPARE(canDownload);
0151     GAPI_COMPARE(canEdit);
0152     GAPI_COMPARE(canListChildren);
0153     GAPI_COMPARE(canManageMembers);
0154     GAPI_COMPARE(canReadRevisions);
0155     GAPI_COMPARE(canRename);
0156     GAPI_COMPARE(canRenameDrive);
0157     GAPI_COMPARE(canShare);
0158     GAPI_COMPARE(canTrashChildren);
0159     return true;
0160 }
0161
0162 bool Drives::Capabilities::canAddChildren() const
0163 {
0164     return d->canAddChildren;
0165 }
0166
0167 bool Drives::Capabilities::canChangeCopyRequiresWriterPermissionRestriction() const
0168 {
0169     return d->canChangeCopyRequiresWriterPermissionRestriction;
0170 }
0171
0172 bool Drives::Capabilities::canChangeDomainUsersOnlyRestriction() const
0173 {
0174     return d->canChangeDomainUsersOnlyRestriction;
0175 }
0176
0177 bool Drives::Capabilities::canChangeDriveBackground() const
0178 {
0179     return d->canChangeDriveBackground;
0180 }
0181
0182 bool Drives::Capabilities::canChangeDriveMembersOnlyRestriction() const
0183 {
0184     return d->canChangeDriveMembersOnlyRestriction;
0185 }
0186
0187 bool Drives::Capabilities::canComment() const
0188 {
0189     return d->canComment;
0190 }
0191
0192 bool Drives::Capabilities::canCopy() const
0193 {
0194     return d->canCopy;
0195 }
0196
0197 bool Drives::Capabilities::canDeleteChildren() const
0198 {
0199     return d->canDeleteChildren;
0200 }
0201
0202 bool Drives::Capabilities::canDeleteDrive() const
0203 {
0204     return d->canDeleteDrive;
0205 }
0206
0207 bool Drives::Capabilities::canDownload() const
0208 {
0209     return d->canDownload;
0210 }
0211
0212 bool Drives::Capabilities::canEdit() const
0213 {
0214     return d->canEdit;
0215 }
0216
0217 bool Drives::Capabilities::canListChildren() const
0218 {
0219     return d->canListChildren;
0220 }
0221
0222 bool Drives::Capabilities::canManageMembers() const
0223 {
0224     return d->canManageMembers;
0225 }
0226
0227 bool Drives::Capabilities::canReadRevisions() const
0228 {
0229     return d->canReadRevisions;
0230 }
0231
0232 bool Drives::Capabilities::canRename() const
0233 {
0234     return d->canRename;
0235 }
0236
0237 bool Drives::Capabilities::canRenameDrive() const
0238 {
0239     return d->canRenameDrive;
0240 }
0241
0242 bool Drives::Capabilities::canShare() const
0243 {
0244     return d->canShare;
0245 }
0246
0247 bool Drives::Capabilities::canTrashChildren() const
0248 {
0249     return d->canTrashChildren;
0250 }
0251
0252 ///// Drives::BackgroundImageFile
0253
0254 class Q_DECL_HIDDEN Drives::BackgroundImageFile::Private
0255 {
0256 public:
0257     Private() = default;
0258     Private(const Private &other) = default;
0259
0260     QString id;
0261     float xCoordinate = 0.0f;
0262     float yCoordinate = 0.0f;
0263     float width = 0.0f;
0264 };
0265
0266 Drives::BackgroundImageFile::BackgroundImageFile()
0267     : d(new Private)
0268 {
0269 }
0270
0271 Drives::BackgroundImageFile::BackgroundImageFile(const Drives::BackgroundImageFile &other)
0272     : d(new Private(*(other.d)))
0273 {
0274 }
0275
0276 Drives::BackgroundImageFile::~BackgroundImageFile() = default;
0277
0278 bool Drives::BackgroundImageFile::operator==(const Drives::BackgroundImageFile &other) const
0279 {
0280     GAPI_COMPARE(id);
0281     GAPI_COMPARE(xCoordinate);
0282     GAPI_COMPARE(yCoordinate);
0283     GAPI_COMPARE(width);
0284     return true;
0285 }
0286
0287 QString Drives::BackgroundImageFile::id() const
0288 {
0289     return d->id;
0290 }
0291
0292 void Drives::BackgroundImageFile::setId(const QString &id) const
0293 {
0294     d->id = id;
0295 }
0296
0297 float Drives::BackgroundImageFile::xCoordinate() const
0298 {
0299     return d->xCoordinate;
0300 }
0301
0302 void Drives::BackgroundImageFile::setXCoordinate(const float xCoordinate) const
0303 {
0304     d->xCoordinate = xCoordinate;
0305 }
0306
0307 float Drives::BackgroundImageFile::yCoordinate() const
0308 {
0309     return d->yCoordinate;
0310 }
0311
0312 void Drives::BackgroundImageFile::setYCoordinate(const float yCoordinate) const
0313 {
0314     d->yCoordinate = yCoordinate;
0315 }
0316
0317 float Drives::BackgroundImageFile::width() const
0318 {
0319     return d->width;
0320 }
0321
0322 void Drives::BackgroundImageFile::setWidth(const float width) const
0323 {
0324     d->width = width;
0325 }
0326
0327 ///// Drives
0328
0329 class Q_DECL_HIDDEN Drives::Private
0330 {
0331 public:
0332     Private() = default;
0333     Private(const Private &other) = default;
0334
0335     QString id;
0336     QString name;
0337     QString themeId;
0338     QString colorRgb;
0339     BackgroundImageFilePtr backgroundImageFile;
0340     QString backgroundImageLink;
0341     CapabilitiesPtr capabilities;
0342     QDateTime createdDate;
0343     bool hidden = false;
0344     RestrictionsPtr restrictions;
0345
0346     static DrivesPtr fromJSON(const QVariantMap &map);
0347 };
0348
0349 DrivesPtr Drives::Private::fromJSON(const QVariantMap &map)
0350 {
0351     if (!map.contains(Drives::Fields::Kind) || map[Drives::Fields::Kind].toString() != ApiKind) {
0352         return DrivesPtr();
0353     }
0354
0355     auto drives = DrivesPtr::create();
0356     if (map.contains(Drives::Fields::Id)) {
0357         drives->d->id = map[Drives::Fields::Id].toString();
0358     }
0359     if (map.contains(Drives::Fields::Name)) {
0360         drives->d->name = map[Drives::Fields::Name].toString();
0361     }
0362     if (map.contains(Drives::Fields::ThemeId)) {
0363         drives->d->themeId = map[Drives::Fields::ThemeId].toString();
0364     }
0365     if (map.contains(Drives::Fields::ColorRgb)) {
0366         drives->d->colorRgb = map[Drives::Fields::ColorRgb].toString();
0367     }
0368     if (map.contains(Drives::Fields::BackgroundImageLink)) {
0369         drives->d->backgroundImageLink = map[Drives::Fields::BackgroundImageLink].toString();
0370     }
0371     if (map.contains(Drives::Fields::CreatedDate)) {
0372         drives->d->createdDate = QDateTime::fromString(map[Drives::Fields::CreatedDate].toString(), Qt::ISODate);
0373     }
0374     if (map.contains(Drives::Fields::Hidden)) {
0375         drives->d->hidden = map[Drives::Fields::Hidden].toBool();
0376     }
0377
0378     if (map.contains(Drives::Fields::BackgroundImageFile)) {
0379         const QVariantMap backgroundImageFileMap = map[Drives::Fields::BackgroundImageFile].toMap();
0380         auto backgroundImageFile = BackgroundImageFilePtr::create();
0381         backgroundImageFile->d->id = backgroundImageFileMap[Drives::BackgroundImageFile::Fields::Id].toString();
0382         backgroundImageFile->d->xCoordinate = backgroundImageFileMap[Drives::BackgroundImageFile::Fields::XCoordinate].toReal();
0383         backgroundImageFile->d->yCoordinate = backgroundImageFileMap[Drives::BackgroundImageFile::Fields::YCoordinate].toReal();
0384         backgroundImageFile->d->width = backgroundImageFileMap[Drives::BackgroundImageFile::Fields::Width].toReal();
0385         drives->d->backgroundImageFile = backgroundImageFile;
0386     }
0387
0388     if (map.contains(Drives::Fields::Capabilities)) {
0389         const QVariantMap capabilitiesMap = map[Drives::Fields::Capabilities].toMap();
0390         auto capabilities = CapabilitiesPtr::create();
0391         capabilities->d->canAddChildren = capabilitiesMap[Drives::Capabilities::Fields::CanAddChildren].toBool();
0392         capabilities->d->canChangeCopyRequiresWriterPermissionRestriction =
0393             capabilitiesMap[Drives::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction].toBool();
0394         capabilities->d->canChangeDomainUsersOnlyRestriction = capabilitiesMap[Drives::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction].toBool();
0395         capabilities->d->canChangeDriveBackground = capabilitiesMap[Drives::Capabilities::Fields::CanChangeDriveBackground].toBool();
0396         capabilities->d->canChangeDriveMembersOnlyRestriction = capabilitiesMap[Drives::Capabilities::Fields::CanChangeDriveMembersOnlyRestriction].toBool();
0397         capabilities->d->canComment = capabilitiesMap[Drives::Capabilities::Fields::CanComment].toBool();
0398         capabilities->d->canCopy = capabilitiesMap[Drives::Capabilities::Fields::CanCopy].toBool();
0399         capabilities->d->canDeleteChildren = capabilitiesMap[Drives::Capabilities::Fields::CanDeleteChildren].toBool();
0400         capabilities->d->canDeleteDrive = capabilitiesMap[Drives::Capabilities::Fields::CanDeleteDrive].toBool();
0401         capabilities->d->canDownload = capabilitiesMap[Drives::Capabilities::Fields::CanDownload].toBool();
0402         capabilities->d->canEdit = capabilitiesMap[Drives::Capabilities::Fields::CanEdit].toBool();
0403         capabilities->d->canListChildren = capabilitiesMap[Drives::Capabilities::Fields::CanListChildren].toBool();
0404         capabilities->d->canManageMembers = capabilitiesMap[Drives::Capabilities::Fields::CanManageMembers].toBool();
0405         capabilities->d->canReadRevisions = capabilitiesMap[Drives::Capabilities::Fields::CanReadRevisions].toBool();
0406         capabilities->d->canRename = capabilitiesMap[Drives::Capabilities::Fields::CanRename].toBool();
0407         capabilities->d->canRenameDrive = capabilitiesMap[Drives::Capabilities::Fields::CanRenameDrive].toBool();
0408         capabilities->d->canShare = capabilitiesMap[Drives::Capabilities::Fields::CanShare].toBool();
0409         capabilities->d->canTrashChildren = capabilitiesMap[Drives::Capabilities::Fields::CanTrashChildren].toBool();
0410         drives->d->capabilities = capabilities;
0411     }
0412
0413     if (map.contains(Drives::Fields::Restrictions)) {
0414         const QVariantMap restrictionsMap = map[Drives::Fields::Restrictions].toMap();
0415         auto restrictions = RestrictionsPtr::create();
0416         restrictions->d->adminManagedRestrictions = restrictionsMap[Drives::Restrictions::Fields::AdminManagedRestrictions].toBool();
0417         restrictions->d->copyRequiresWriterPermission = restrictionsMap[Drives::Restrictions::Fields::CopyRequiresWriterPermission].toBool();
0418         restrictions->d->domainUsersOnly = restrictionsMap[Drives::Restrictions::Fields::DomainUsersOnly].toBool();
0419         restrictions->d->driveMembersOnly = restrictionsMap[Drives::Restrictions::Fields::DriveMembersOnly].toBool();
0420         drives->d->restrictions = restrictions;
0421     }
0422
0423     return drives;
0424 }
0425
0426 const QString Drives::Restrictions::Fields::AdminManagedRestrictions = QStringLiteral("adminManagedRestrictions");
0427 const QString Drives::Restrictions::Fields::CopyRequiresWriterPermission = QStringLiteral("copyRequiresWriterPermission");
0428 const QString Drives::Restrictions::Fields::DomainUsersOnly = QStringLiteral("domainUsersOnly");
0429 const QString Drives::Restrictions::Fields::DriveMembersOnly = QStringLiteral("driveMembersOnly");
0430
0431 const QString Drives::Capabilities::Fields::CanAddChildren = QStringLiteral("canAddChildren");
0432 const QString Drives::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction =
0433     QStringLiteral("canChangeCopyRequiresWriterPermissionRestriction");
0434 const QString Drives::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction = QStringLiteral("canChangeDomainUsersOnlyRestriction");
0435 const QString Drives::Capabilities::Fields::CanChangeDriveBackground = QStringLiteral("canChangeDriveBackground");
0436 const QString Drives::Capabilities::Fields::CanChangeDriveMembersOnlyRestriction = QStringLiteral("canChangeDriveMembersOnlyRestriction");
0437 const QString Drives::Capabilities::Fields::CanComment = QStringLiteral("canComment");
0438 const QString Drives::Capabilities::Fields::CanCopy = QStringLiteral("canCopy");
0439 const QString Drives::Capabilities::Fields::CanDeleteChildren = QStringLiteral("canDeleteChildren");
0440 const QString Drives::Capabilities::Fields::CanDeleteDrive = QStringLiteral("canDeleteDrive");
0441 const QString Drives::Capabilities::Fields::CanDownload = QStringLiteral("canDownload");
0442 const QString Drives::Capabilities::Fields::CanEdit = QStringLiteral("canEdit");
0443 const QString Drives::Capabilities::Fields::CanListChildren = QStringLiteral("canListChildren");
0444 const QString Drives::Capabilities::Fields::CanManageMembers = QStringLiteral("canManageMembers");
0445 const QString Drives::Capabilities::Fields::CanReadRevisions = QStringLiteral("canReadRevisions");
0446 const QString Drives::Capabilities::Fields::CanRename = QStringLiteral("canRename");
0447 const QString Drives::Capabilities::Fields::CanRenameDrive = QStringLiteral("canRenameDrive");
0448 const QString Drives::Capabilities::Fields::CanShare = QStringLiteral("canShare");
0449 const QString Drives::Capabilities::Fields::CanTrashChildren = QStringLiteral("canTrashChildren");
0450
0451 const QString Drives::BackgroundImageFile::Fields::Id = QStringLiteral("id");
0452 const QString Drives::BackgroundImageFile::Fields::XCoordinate = QStringLiteral("xCoordinate");
0453 const QString Drives::BackgroundImageFile::Fields::YCoordinate = QStringLiteral("yCoordinate");
0454 const QString Drives::BackgroundImageFile::Fields::Width = QStringLiteral("width");
0455
0456 const QString Drives::Fields::Items = QStringLiteral("items");
0457 const QString Drives::Fields::KindDrive = QStringLiteral("kind");
0458 const QString Drives::Fields::PageToken = QStringLiteral("pageToken");
0459 const QString Drives::Fields::NextPageToken = QStringLiteral("nextPageToken");
0460 const QString Drives::Fields::Id = QStringLiteral("id");
0461 const QString Drives::Fields::Kind = QStringLiteral("kind");
0462 const QString Drives::Fields::Name = QStringLiteral("name");
0463 const QString Drives::Fields::ThemeId = QStringLiteral("themeId");
0464 const QString Drives::Fields::ColorRgb = QStringLiteral("colorRgb");
0465 const QString Drives::Fields::BackgroundImageFile = QStringLiteral("backgroundImageFile");
0466 const QString Drives::Fields::BackgroundImageLink = QStringLiteral("backgroundImageLink");
0467 const QString Drives::Fields::Capabilities = QStringLiteral("capabilities");
0468 const QString Drives::Fields::CreatedDate = QStringLiteral("createdDate");
0469 const QString Drives::Fields::Hidden = QStringLiteral("hidden");
0470 const QString Drives::Fields::Restrictions = QStringLiteral("restrictions");
0471
0472 Drives::Drives()
0473     : KGAPI2::Object()
0474     , d(new Private)
0475 {
0476 }
0477
0478 Drives::Drives(const Drives &other)
0479     : KGAPI2::Object(other)
0480     , d(new Private(*(other.d)))
0481 {
0482 }
0483
0484 Drives::~Drives() = default;
0485
0486 bool Drives::operator==(const Drives &other) const
0487 {
0488     if (!Object::operator==(other)) {
0489         return false;
0490     }
0491     GAPI_COMPARE(id);
0492     GAPI_COMPARE(name);
0493     GAPI_COMPARE(themeId);
0494     GAPI_COMPARE(colorRgb);
0495     GAPI_COMPARE_SHAREDPTRS(backgroundImageFile);
0496     GAPI_COMPARE(backgroundImageLink);
0497     GAPI_COMPARE_SHAREDPTRS(capabilities);
0498     GAPI_COMPARE(createdDate);
0499     GAPI_COMPARE(hidden);
0500     GAPI_COMPARE_SHAREDPTRS(restrictions);
0501     return true;
0502 }
0503
0504 QString Drives::id() const
0505 {
0506     return d->id;
0507 }
0508
0509 void Drives::setId(const QString &id) const
0510 {
0511     d->id = id;
0512 }
0513
0514 QString Drives::name() const
0515 {
0516     return d->name;
0517 }
0518
0519 void Drives::setName(const QString &name) const
0520 {
0521     d->name = name;
0522 }
0523
0524 QString Drives::themeId() const
0525 {
0526     return d->themeId;
0527 }
0528
0529 void Drives::setThemeId(const QString &themeId) const
0530 {
0531     d->themeId = themeId;
0532 }
0533
0534 QString Drives::colorRgb() const
0535 {
0536     return d->colorRgb;
0537 }
0538
0539 void Drives::setColorRgb(const QString &colorRgb) const
0540 {
0541     d->colorRgb = colorRgb;
0542 }
0543
0544 Drives::BackgroundImageFilePtr Drives::backgroundImageFile() const
0545 {
0546     return d->backgroundImageFile;
0547 }
0548
0549 void Drives::setBackgroundImageFile(const Drives::BackgroundImageFilePtr &backgroundImageFile) const
0550 {
0551     d->backgroundImageFile = backgroundImageFile;
0552 }
0553
0554 QString Drives::backgroundImageLink() const
0555 {
0556     return d->backgroundImageLink;
0557 }
0558
0559 Drives::CapabilitiesPtr Drives::capabilities() const
0560 {
0561     return d->capabilities;
0562 }
0563
0564 QDateTime Drives::createdDate() const
0565 {
0566     return d->createdDate;
0567 }
0568
0569 bool Drives::hidden() const
0570 {
0571     return d->hidden;
0572 }
0573
0574 void Drives::setRestrictions(const Drives::RestrictionsPtr &restrictions) const
0575 {
0576     d->restrictions = restrictions;
0577 }
0578
0579 Drives::RestrictionsPtr Drives::restrictions() const
0580 {
0581     return d->restrictions;
0582 }
0583
0584 DrivesPtr Drives::fromJSON(const QByteArray &jsonData)
0585 {
0586     QJsonDocument document = QJsonDocument::fromJson(jsonData);
0587     if (document.isNull()) {
0588         return DrivesPtr();
0589     }
0590
0591     const QVariant data = document.toVariant();
0592     return Private::fromJSON(data.toMap());
0593 }
0594
0595 DrivesList Drives::fromJSONFeed(const QByteArray &jsonData, FeedData &feedData)
0596 {
0597     QJsonDocument document = QJsonDocument::fromJson(jsonData);
0598     if (document.isNull()) {
0599         return DrivesList();
0600     }
0601
0602     const QVariant data = document.toVariant();
0603     const QVariantMap map = data.toMap();
0604     if (!map.contains(Drives::Fields::Kind) || map[Drives::Fields::Kind].toString() != ApiKindList) {
0605         return DrivesList();
0606     }
0607
0608     if (map.contains(Drives::Fields::NextPageToken)) {
0609         feedData.nextPageUrl = DriveService::fetchDrivesUrl();
0610         QUrlQuery query(feedData.nextPageUrl);
0611         query.addQueryItem(Drives::Fields::PageToken, map.value(Drives::Fields::NextPageToken).toString());
0612         feedData.nextPageUrl.setQuery(query);
0613     }
0614
0615     DrivesList list;
0616     const QVariantList items = map[Drives::Fields::Items].toList();
0617     for (const QVariant &item : items) {
0618         const DrivesPtr drives = Private::fromJSON(item.toMap());
0619
0620         if (!drives.isNull()) {
0621             list << drives;
0622         }
0623     }
0624
0625     return list;
0626 }
0627
0628 QByteArray Drives::toJSON(const DrivesPtr &drives)
0629 {
0630     QVariantMap drivesMap;
0631     drivesMap[Drives::Fields::Kind] = ApiKind;
0632     if (!drives->id().isEmpty()) {
0633         drivesMap[Drives::Fields::Id] = drives->id();
0634     }
0635     if (!drives->name().isEmpty()) {
0636         drivesMap[Drives::Fields::Name] = drives->name();
0637     }
0638     if (!drives->themeId().isEmpty()) {
0639         drivesMap[Drives::Fields::ThemeId] = drives->themeId();
0640     }
0641     if (!drives->colorRgb().isEmpty()) {
0642         drivesMap[Drives::Fields::ColorRgb] = drives->colorRgb();
0643     }
0644     if (!drives->backgroundImageLink().isEmpty()) {
0645         drivesMap[Drives::Fields::BackgroundImageLink] = drives->backgroundImageLink();
0646     }
0647     if (drives->createdDate().isValid()) {
0648         drivesMap[Drives::Fields::CreatedDate] = drives->createdDate();
0649     }
0650     drivesMap[Drives::Fields::Hidden] = drives->hidden();
0651
0652     if (drives->restrictions()) {
0653         QVariantMap restrictionsMap;
0654         restrictionsMap[Drives::Restrictions::Fields::AdminManagedRestrictions] = drives->restrictions()->adminManagedRestrictions();
0655         restrictionsMap[Drives::Restrictions::Fields::CopyRequiresWriterPermission] = drives->restrictions()->copyRequiresWriterPermission();
0656         restrictionsMap[Drives::Restrictions::Fields::DomainUsersOnly] = drives->restrictions()->domainUsersOnly();
0657         restrictionsMap[Drives::Restrictions::Fields::DriveMembersOnly] = drives->restrictions()->driveMembersOnly();
0658         drivesMap[Drives::Fields::Restrictions] = restrictionsMap;
0659     }
0660
0661     if (drives->backgroundImageFile()) {
0662         QVariantMap backgroundImageFileMap;
0663         backgroundImageFileMap[Drives::BackgroundImageFile::Fields::Id] = drives->backgroundImageFile()->id();
0664         backgroundImageFileMap[Drives::BackgroundImageFile::Fields::XCoordinate] = drives->backgroundImageFile()->xCoordinate();
0665         backgroundImageFileMap[Drives::BackgroundImageFile::Fields::YCoordinate] = drives->backgroundImageFile()->yCoordinate();
0666         backgroundImageFileMap[Drives::BackgroundImageFile::Fields::Width] = drives->backgroundImageFile()->width();
0667         drivesMap[Drives::Fields::BackgroundImageFile] = backgroundImageFileMap;
0668     }
0669
0670     if (drives->capabilities()) {
0671         QVariantMap capabilitiesMap;
0672         capabilitiesMap[Drives::Capabilities::Fields::CanAddChildren] = drives->capabilities()->canAddChildren();
0673         capabilitiesMap[Drives::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction] =
0674             drives->capabilities()->canChangeCopyRequiresWriterPermissionRestriction();
0675         capabilitiesMap[Drives::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction] = drives->capabilities()->canChangeDomainUsersOnlyRestriction();
0676         capabilitiesMap[Drives::Capabilities::Fields::CanChangeDriveBackground] = drives->capabilities()->canChangeDriveBackground();
0677         capabilitiesMap[Drives::Capabilities::Fields::CanChangeDriveMembersOnlyRestriction] = drives->capabilities()->canChangeDriveMembersOnlyRestriction();
0678         capabilitiesMap[Drives::Capabilities::Fields::CanComment] = drives->capabilities()->canComment();
0679         capabilitiesMap[Drives::Capabilities::Fields::CanCopy] = drives->capabilities()->canCopy();
0680         capabilitiesMap[Drives::Capabilities::Fields::CanDeleteChildren] = drives->capabilities()->canDeleteChildren();
0681         capabilitiesMap[Drives::Capabilities::Fields::CanDeleteDrive] = drives->capabilities()->canDeleteDrive();
0682         capabilitiesMap[Drives::Capabilities::Fields::CanDownload] = drives->capabilities()->canDownload();
0683         capabilitiesMap[Drives::Capabilities::Fields::CanEdit] = drives->capabilities()->canEdit();
0684         capabilitiesMap[Drives::Capabilities::Fields::CanListChildren] = drives->capabilities()->canListChildren();
0685         capabilitiesMap[Drives::Capabilities::Fields::CanManageMembers] = drives->capabilities()->canManageMembers();
0686         capabilitiesMap[Drives::Capabilities::Fields::CanReadRevisions] = drives->capabilities()->canReadRevisions();
0687         capabilitiesMap[Drives::Capabilities::Fields::CanRename] = drives->capabilities()->canRename();
0688         capabilitiesMap[Drives::Capabilities::Fields::CanRenameDrive] = drives->capabilities()->canRenameDrive();
0689         capabilitiesMap[Drives::Capabilities::Fields::CanShare] = drives->capabilities()->canShare();
0690         capabilitiesMap[Drives::Capabilities::Fields::CanTrashChildren] = drives->capabilities()->canTrashChildren();
0691         drivesMap[Drives::Fields::Capabilities] = capabilitiesMap;
0692     }
0693
0694     QJsonDocument document = QJsonDocument::fromVariant(drivesMap);
0695     return document.toJson(QJsonDocument::Compact);
0696 }