plasmoid/plugin/smb4knetworkobject.cpp

0001 /*
0002     This class derives from QObject and encapsulates the network items.
0003     It is for use with QtQuick.
0004
0005     SPDX-FileCopyrightText: 2012-2022 Alexander Reinholdt <alexander.reinholdt@kdemail.net>
0006     SPDX-License-Identifier: GPL-2.0-or-later
0007 */
0008
0009 // application specific includes
0010 #include "smb4knetworkobject.h"
0011 #include "core/smb4kglobal.h"
0012 #include "core/smb4khost.h"
0013 #include "core/smb4kshare.h"
0014 #include "core/smb4kworkgroup.h"
0015
0016 // Qt includes
0017 #include <QDebug>
0018
0019 using namespace Smb4KGlobal;
0020
0021 class Smb4KNetworkObjectPrivate
0022 {
0023 public:
0024     QString workgroup;
0025     QUrl url;
0026     int type;
0027     int parentType;
0028     QString comment;
0029     bool mounted;
0030     QUrl mountpoint;
0031     bool printer;
0032     bool isMaster;
0033     bool inaccessible;
0034 };
0035
0036 Smb4KNetworkObject::Smb4KNetworkObject(Smb4KBasicNetworkItem *networkItem, QObject *parent)
0037     : QObject(parent)
0038     , d(new Smb4KNetworkObjectPrivate)
0039 {
0040     switch (networkItem->type()) {
0041     case Smb4KGlobal::Workgroup: {
0042         Smb4KWorkgroup *workgroup = static_cast<Smb4KWorkgroup *>(networkItem);
0043
0044         if (workgroup) {
0045             d->workgroup = workgroup->workgroupName();
0046             d->url = workgroup->url();
0047             d->mounted = false;
0048             d->inaccessible = false;
0049             d->printer = false;
0050             d->isMaster = false;
0051             setType(Workgroup);
0052         }
0053
0054         break;
0055     }
0056     case Smb4KGlobal::Host: {
0057         Smb4KHost *host = static_cast<Smb4KHost *>(networkItem);
0058
0059         if (host) {
0060             d->workgroup = host->workgroupName();
0061             d->url = host->url();
0062             d->comment = host->comment();
0063             d->mounted = false;
0064             d->inaccessible = false;
0065             d->printer = false;
0066             d->isMaster = host->isMasterBrowser();
0067             setType(Host);
0068         }
0069
0070         break;
0071     }
0072     case Smb4KGlobal::Share: {
0073         Smb4KShare *share = static_cast<Smb4KShare *>(networkItem);
0074
0075         if (share) {
0076             d->workgroup = share->workgroupName();
0077             d->url = share->url();
0078             d->comment = share->comment();
0079             d->mounted = share->isMounted();
0080             d->inaccessible = share->isInaccessible();
0081             d->printer = share->isPrinter();
0082             d->isMaster = false;
0083             d->mountpoint = QUrl::fromLocalFile(share->path());
0084             setType(Share);
0085         }
0086
0087         break;
0088     }
0089     default: {
0090         d->url = networkItem->url();
0091
0092         if (networkItem->url().toString() == QStringLiteral("smb://")) {
0093             d->mounted = false;
0094             d->inaccessible = false;
0095             d->printer = false;
0096             d->isMaster = false;
0097             setType(Network);
0098         } else {
0099             d->mounted = false;
0100             d->inaccessible = false;
0101             d->printer = false;
0102             d->isMaster = false;
0103             setType(Unknown);
0104         }
0105         break;
0106     }
0107     }
0108 }
0109
0110 Smb4KNetworkObject::Smb4KNetworkObject(QObject *parent)
0111     : QObject(parent)
0112     , d(new Smb4KNetworkObjectPrivate)
0113 {
0114     d->url.setUrl(QStringLiteral("smb://"), QUrl::TolerantMode);
0115     d->mounted = false;
0116     d->inaccessible = false;
0117     d->printer = false;
0118     d->isMaster = false;
0119     setType(Network);
0120 }
0121
0122 Smb4KNetworkObject::~Smb4KNetworkObject()
0123 {
0124 }
0125
0126 Smb4KNetworkObject::NetworkItem Smb4KNetworkObject::type() const
0127 {
0128     return static_cast<Smb4KNetworkObject::NetworkItem>(d->type);
0129 }
0130
0131 Smb4KNetworkObject::NetworkItem Smb4KNetworkObject::parentType() const
0132 {
0133     return static_cast<Smb4KNetworkObject::NetworkItem>(d->parentType);
0134 }
0135
0136 void Smb4KNetworkObject::setType(NetworkItem type)
0137 {
0138     if (d->type != type) {
0139         d->type = type;
0140
0141         switch (type) {
0142         case Host: {
0143             d->parentType = Workgroup;
0144             break;
0145         }
0146         case Share: {
0147             d->parentType = Host;
0148             break;
0149         }
0150         default: {
0151             d->parentType = Network;
0152             break;
0153         }
0154         }
0155         Q_EMIT changed();
0156     }
0157 }
0158
0159 QString Smb4KNetworkObject::workgroupName() const
0160 {
0161     return d->workgroup;
0162 }
0163
0164 void Smb4KNetworkObject::setWorkgroupName(const QString &name)
0165 {
0166     if (d->workgroup != name) {
0167         d->workgroup = name;
0168         Q_EMIT changed();
0169     }
0170 }
0171
0172 QString Smb4KNetworkObject::hostName() const
0173 {
0174     return d->url.host().toUpper();
0175 }
0176
0177 bool Smb4KNetworkObject::isMasterBrowser() const
0178 {
0179     return d->isMaster;
0180 }
0181
0182 void Smb4KNetworkObject::setMasterBrowser(bool master)
0183 {
0184     if (type() == Host && d->isMaster != master) {
0185         d->isMaster = master;
0186         Q_EMIT changed();
0187     }
0188 }
0189
0190 QString Smb4KNetworkObject::shareName() const
0191 {
0192     return d->url.path().remove(QStringLiteral("/"));
0193 }
0194
0195 QString Smb4KNetworkObject::name() const
0196 {
0197     QString name;
0198
0199     switch (d->type) {
0200     case Workgroup: {
0201         name = workgroupName();
0202         break;
0203     }
0204     case Host: {
0205         name = hostName();
0206         break;
0207     }
0208     case Share: {
0209         name = shareName();
0210         break;
0211     }
0212     default: {
0213         break;
0214     }
0215     }
0216
0217     return name;
0218 }
0219
0220 QString Smb4KNetworkObject::comment() const
0221 {
0222     return d->comment;
0223 }
0224
0225 void Smb4KNetworkObject::setComment(const QString &comment)
0226 {
0227     if (d->comment != comment) {
0228         d->comment = comment;
0229         Q_EMIT changed();
0230     }
0231 }
0232
0233 QUrl Smb4KNetworkObject::url() const
0234 {
0235     return d->url;
0236 }
0237
0238 QUrl Smb4KNetworkObject::parentUrl() const
0239 {
0240     QUrl moveUp(QStringLiteral(".."));
0241     QUrl parentUrl = d->url;
0242
0243     return parentUrl.resolved(moveUp);
0244 }
0245
0246 void Smb4KNetworkObject::setUrl(const QUrl &url)
0247 {
0248     if (!d->url.matches(url, QUrl::None)) {
0249         d->url = url;
0250         Q_EMIT changed();
0251     }
0252 }
0253
0254 bool Smb4KNetworkObject::isMounted() const
0255 {
0256     return d->mounted;
0257 }
0258
0259 void Smb4KNetworkObject::setMounted(bool mounted)
0260 {
0261     if (d->mounted != mounted) {
0262         d->mounted = mounted;
0263         Q_EMIT changed();
0264     }
0265 }
0266
0267 void Smb4KNetworkObject::update(Smb4KBasicNetworkItem *networkItem)
0268 {
0269     if (d->type == Workgroup && networkItem->type() == Smb4KGlobal::Workgroup) {
0270         Smb4KWorkgroup *workgroup = static_cast<Smb4KWorkgroup *>(networkItem);
0271
0272         if (workgroup) {
0273             // Check that we update with the correct item.
0274             if (QString::compare(workgroupName(), workgroup->workgroupName(), Qt::CaseInsensitive) == 0) {
0275                 d->workgroup = workgroup->workgroupName();
0276                 d->url = workgroup->url();
0277                 d->type = Workgroup;
0278                 d->mounted = false;
0279                 d->inaccessible = false;
0280                 d->printer = false;
0281             }
0282         }
0283     } else if (d->type == Host && networkItem->type() == Smb4KGlobal::Host) {
0284         Smb4KHost *host = static_cast<Smb4KHost *>(networkItem);
0285
0286         if (host) {
0287             // Check that we update with the correct item.
0288             if (QString::compare(workgroupName(), host->workgroupName(), Qt::CaseInsensitive) == 0
0289                 && QString::compare(hostName(), host->hostName(), Qt::CaseInsensitive) == 0) {
0290                 d->workgroup = host->workgroupName();
0291                 d->url = host->url();
0292                 d->comment = host->comment();
0293                 d->type = Host;
0294                 d->mounted = false;
0295                 d->inaccessible = false;
0296                 d->printer = false;
0297             }
0298         }
0299     } else if (d->type == Share && networkItem->type() == Smb4KGlobal::Share) {
0300         Smb4KShare *share = static_cast<Smb4KShare *>(networkItem);
0301
0302         if (share) {
0303             // Check that we update with the correct item.
0304             if (QString::compare(workgroupName(), share->workgroupName(), Qt::CaseInsensitive) == 0
0305                 && QString::compare(hostName(), share->hostName(), Qt::CaseInsensitive) == 0
0306                 && QString::compare(shareName(), share->shareName(), Qt::CaseInsensitive) == 0) {
0307                 d->workgroup = share->workgroupName();
0308                 d->url = share->url();
0309                 d->comment = share->comment();
0310                 d->type = Share;
0311                 d->mounted = share->isMounted();
0312                 d->inaccessible = share->isInaccessible();
0313                 d->printer = share->isPrinter();
0314                 d->mountpoint.setUrl(share->path(), QUrl::TolerantMode);
0315                 d->mountpoint.setScheme(QStringLiteral("file"));
0316             }
0317         }
0318     } else {
0319         d->type = Network;
0320     }
0321
0322     Q_EMIT changed();
0323 }
0324
0325 bool Smb4KNetworkObject::isPrinter() const
0326 {
0327     return d->printer;
0328 }
0329
0330 void Smb4KNetworkObject::setPrinter(bool printer)
0331 {
0332     if (d->printer != printer) {
0333         d->printer = printer;
0334         Q_EMIT changed();
0335     }
0336 }
0337
0338 QUrl Smb4KNetworkObject::mountpoint() const
0339 {
0340     return d->mountpoint;
0341 }
0342
0343 void Smb4KNetworkObject::setMountpoint(const QUrl &mountpoint)
0344 {
0345     if (!d->mountpoint.matches(mountpoint, QUrl::None)) {
0346         d->mountpoint = mountpoint;
0347         Q_EMIT changed();
0348     }
0349 }
0350
0351 bool Smb4KNetworkObject::isInaccessible() const
0352 {
0353     return (d->mounted && d->inaccessible);
0354 }
0355
0356 void Smb4KNetworkObject::setInaccessible(bool inaccessible)
0357 {
0358     if (d->inaccessible != inaccessible) {
0359         d->inaccessible = inaccessible;
0360         Q_EMIT changed();
0361     }
0362 }