- File is now quite useful, though still incomplete.

diff --git a/lib/anidbudpclient/file.cpp b/lib/anidbudpclient/file.cpp
index 9bb07f9ab5e370507222082a9c542aca698666af..92cd821a4156b7ef229155898c9469c9fe7b1c41 100644 (file)
--- a/lib/anidbudpclient/file.cpp
+++ b/lib/anidbudpclient/file.cpp
@@ -1,9 +1,31 @@
 #include "file.h"
 
+#include <QRegExp>
+#include "client.h"
+#include "hash.h"
+
+#include <QDebug>
+
 namespace AniDBUdpClient {
 
 File::File(QObject *parent) : QObject(parent)
 {
+       init();
+}
+
+File::File(const QFileInfo &file, QObject *parent) : QObject(parent)
+{
+       m_file = file;
+       init();
+}
+
+File::~File()
+{
+       if (fileCommand)
+       {
+               delete fileCommand;
+               fileCommand = 0;
+       }
 }
 
 QFileInfo File::file() const
@@ -29,68 +51,299 @@ QByteArray File::ed2k()
        return m_ed2k;
 }
 
+File::ActionState File::hashingState() const
+{
+       return m_hashingState;
+}
+
+File::ActionState File::renamingState() const
+{
+       return m_renamingState;
+}
+
+File::ActionState File::addingState() const
+{
+       return m_addingState;
+}
+
+File::ActionState File::markingState() const
+{
+       return m_markingState;
+}
+
+
 void File::hash()
 {
-       if (m_ed2k.isEmpty())
+       if (m_hashingState != Success)
                actionsQueue.enqueue(Hashing);
+
+       if (notWorking) work();
 }
 
 bool File::rename()
 {
-       if (m_ed2k.isEmpty())
+       if (m_renamingState == Success)
+               return true;
+
+       if (m_hashingState != Success)
                actionsQueue.enqueue(Hashing);
-       return false;
+
+       actionsQueue.enqueue(Renaming);
+
+       if (notWorking) work();
+       return true;
+}
+
+bool File::addToMyList()
+{
+       if (!canContinue(m_addingState))
+               return false;
+       if (m_hashingState != Success)
+               actionsQueue.enqueue(Hashing);
+
+       actionsQueue.enqueue(Adding);
+
+       if (notWorking) work();
+       return true;
 }
 
 bool File::markWatched(bool watched)
 {
+       if (m_markingState != Success)
+               return true;
+
+       if (m_hashingState != Success)
+               actionsQueue.enqueue(Hashing);
+
+       if (notWorking) work();
        return watched;
 }
 
 
 void File::finishHashing(const QFileInfo &file, const QByteArray &hash)
 {
+qDebug() << "finishHashing";
        if (m_file != file)
                return;
        m_ed2k = hash;
-       emit finished(Hashing);
+qDebug() << m_ed2k;
+       updateStatus(Hashing, Success);
+}
+
+void File::finishRenaming(bool success)
+{
+qDebug() << "finishRenaming";
+       if (!success)
+       {
+               updateStatus(Renaming, Failure);
+               return;
+       }
+
+       QString name = fileCommand->value(FileAnimeFlag::RomajiName).toString();
+       if (name.isEmpty())
+               name = fileCommand->value(FileAnimeFlag::EnglishName).toString();
+
+       QString fileName = tr("%1 - %2 - %3 [%4](%5).%6")
+                                          .arg(name)
+                                          .arg(fileCommand->value(FileAnimeFlag::EpNo).toString())
+                                          .arg(fileCommand->value(FileAnimeFlag::EpName).toString())
+                                          .arg(fileCommand->value(FileAnimeFlag::GroupShortName).toString())
+                                          .arg(fileCommand->value(FileFlag::Crc32).toString())
+                                          .arg(fileCommand->value(FileFlag::FileType).toString());
+
+       fileName.replace('"', "'");
+       fileName.replace(QRegExp("[\\/]"), "-");
+       fileName.replace(QRegExp("[\\/:*?\"<>|]"), "");
+qDebug() << fileName;
+
+
+       QFile f(m_file.absoluteFilePath());
+       if (f.rename(m_file.absolutePath() + "/" + fileName))
+       {
+               m_file.setFile(f);
+qDebug() << m_file.absoluteFilePath();
+               updateStatus(Renaming, Success);
+       }
+       else
+       {
+qDebug() << f.errorString();
+               updateStatus(Renaming, Failure);
+       }
+}
+
+void File::finishAdding(bool success)
+{
+       if (!success)
+       {
+               updateStatus(Adding, Failure);
+               return;
+       }
+       updateStatus(Adding, Success);
+}
+
+void File::finishMarking(bool success)
+{
+       Q_UNUSED(success);
 }
 
-void File::finishRenaming()
+void File::work()
 {
+qDebug() << "work";
+qDebug() << actionsQueue;
+
+       notWorking = false;
+
+       if (actionsQueue.isEmpty())
+       {
+               emit statusUpdate(All, Finished);
+               notWorking = true;
+               return;
+       }
 
+       Action a = actionsQueue.dequeue();
+
+qDebug() << "Next work:" << a;
+
+       switch (a)
+       {
+               case Hashing:
+                       startHashing();
+               break;
+               case Renaming:
+                       startRenaming();
+               break;
+               case Adding:
+                       startAdding();
+               break;
+               case MarkingWatched:
+                       startMarking();
+               break;
+               default:
+               break;
+       }
 }
 
-void File::finishMarking()
+void File::workOnFinished(Action action, ActionState actionState)
 {
+       Q_UNUSED(action);
 
+       switch (actionState)
+       {
+               case Success:
+               case Failure:
+                       work();
+               default:
+               break;
+       }
 }
 
 void File::startHashing()
 {
+qDebug() << "startHashing";
 
+       if (!m_ed2k.isEmpty())
+       {
+               work();
+               return;
+       }
+       Hash::instance()->hashFile(m_file);
+       updateStatus(Hashing, InProgress);
 }
 
 void File::startRenaming()
 {
+qDebug() << "startRenaming";
 
+       if (!canContinue(m_renamingState))
+       {
+               work();
+               return;
+       }
+
+       if (fileCommand)
+               delete fileCommand;
+
+       fileCommand = new FileCommand(m_ed2k,
+                                                                 size(),
+                                                                 FileFlag::Crc32
+                                                                 | FileFlag::FileType
+                                                                 | FileFlag::Lid,
+                                                                 FileAnimeFlag::EnglishName
+                                                                 | FileAnimeFlag::RomajiName
+                                                                 | FileAnimeFlag::KanjiName
+                                                                 | FileAnimeFlag::EpNo
+                                                                 | FileAnimeFlag::EpName
+                                                                 | FileAnimeFlag::GroupShortName,
+                                                                 this);
+
+       connect(fileCommand, SIGNAL(replyReady(bool)), this, SLOT(finishRenaming(bool)));
+       Client::instance()->send(fileCommand);
+       updateStatus(Renaming, InProgress);
+}
+
+void File::startAdding()
+{
+       if (!canContinue(m_addingState))
+       {
+               work();
+               return;
+       }
+
+       if (addCommand)
+               delete addCommand;
+
+       addCommand = new MyListAddCommand(m_ed2k, size(), false);
+       addCommand->setState(StateOnHdd);
+
+       connect(addCommand, SIGNAL(replyReady(bool)), this, SLOT(finishAdding(bool)));
+
+       Client::instance()->send(addCommand);
+       updateStatus(Adding, InProgress);
 }
 
 void File::startMarking()
 {
+       if (!canContinue(m_markingState))
+       {
+               work();
+               return;
+       }
+}
 
+void File::init()
+{
+
+       fileCommand = 0;
+       addCommand = 0;
+       m_hashingState = m_renamingState = m_addingState = m_markingState = NotStarted;
+       notWorking = true;
+
+       connect(this, SIGNAL(statusUpdate(Action,ActionState)), this, SLOT(workOnFinished(Action,ActionState)));
+       connect(Hash::instance(), SIGNAL(fileHashed(QFileInfo,QByteArray)), this, SLOT(finishHashing(QFileInfo,QByteArray)));
 }
 
-void File::work()
+bool File::canContinue(ActionState state)
 {
-       Action a = actionsQueue.dequeue();
+       return state & OkToContinue;
+}
 
-       switch (a)
+void File::updateStatus(Action action, ActionState actionState)
+{
+       switch (action)
        {
                case Hashing:
-               default:
+                       m_hashingState = actionState;
+               break;
+               case Renaming:
+                       m_renamingState = actionState;
+               break;
+               case Adding:
+                       m_addingState = actionState;
                break;
+               case MarkingWatched:
+                       m_markingState = actionState;
        }
+       emit statusUpdate(action, actionState);
 }
 
 } // namespace AniDBUdpClient

diff --git a/lib/anidbudpclient/file.h b/lib/anidbudpclient/file.h
index 3bade27483ef77b3403294a1566c10fd1a3c2e7f..0949b2177a39c741a670055807dbdce50c3ca9ab 100644 (file)
--- a/lib/anidbudpclient/file.h
+++ b/lib/anidbudpclient/file.h
@@ -7,6 +7,9 @@
 #include <QFileInfo>
 #include <QQueue>
 
+#include "filecommand.h"
+#include "mylistaddcommand.h"
+
 namespace AniDBUdpClient {
 
 class FileCommand;
@@ -21,17 +24,37 @@ class ANIDBUDPCLIENTSHARED_EXPORT File : public QObject
        Q_PROPERTY(qint64 size READ size);
        Q_PROPERTY(QByteArray ed2k READ ed2k);
 
+       Q_PROPERTY(ActionState hashingState READ hashingState);
+       Q_PROPERTY(ActionState renamingState READ renamingState);
+       Q_PROPERTY(ActionState addingState READ addingState);
+       Q_PROPERTY(ActionState markingState READ markingState);
 public:
 
        enum Action {
                Hashing,
                Renaming,
+               Adding,
                MarkingWatched,
 
                All = -1,
        };
 
+       enum ActionState {
+               NotStarted      = 0x00000001,
+               InProgress      = 0x00000002,
+               Success         = 0x00000004,
+               Failure         = 0x00000008,
+
+               Finished        = 0x00000010,
+
+               OkToContinue = NotStarted | Failure,
+       };
+
+       Q_ENUMS(Action ActionState);
+
        File(QObject *parent = 0);
+       File(const QFileInfo &file, QObject *parent = 0);
+       ~File();
 
        QFileInfo file() const;
        void setFile(const QFileInfo &file);
@@ -39,31 +62,57 @@ public:
        qint64 size();
        QByteArray ed2k();
 
+
+       ActionState hashingState() const;
+       ActionState renamingState() const;
+       ActionState addingState() const;
+       ActionState markingState() const;
+
 public slots:
        void hash();
        bool rename();
+       bool addToMyList();
        bool markWatched(bool watched = true);
 
 signals:
-       void finished(Action action);
+       void statusUpdate(Action action, ActionState state);
 
 private slots:
        void finishHashing(const QFileInfo &file, const QByteArray &hash);
-       void finishRenaming();
-       void finishMarking();
+       void finishRenaming(bool success);
+       void finishAdding(bool success);
+       void finishMarking(bool success);
+
+       void work();
+       void workOnFinished(Action action, ActionState actionState);
 
 private:
+
        void startHashing();
        void startRenaming();
+       void startAdding();
        void startMarking();
 
-       void work();
+       void init();
+
+       bool canContinue(ActionState state);
+       void updateStatus(Action action, ActionState actionState);
 
        QQueue<Action> actionsQueue;
 
        QFileInfo m_file;
        QByteArray m_ed2k;
 
+       bool notWorking;
+
+       ActionState m_hashingState;
+       ActionState m_renamingState;
+       ActionState m_addingState;
+       ActionState m_markingState;
+
+       FileCommand *fileCommand;
+       MyListAddCommand *addCommand;
+
 };
 
 } // namespace AniDBUdpClient