initial commit for improved deck list submission

cockatrice/src/client.h

@@ -13,6 +13,7 @@ class QXmlStreamReader;
 class QXmlStreamWriter;
 
 class ProtocolItem;
+class ProtocolResponse;
 class ChatEvent;
 class GameEvent;
 class Event_ListGames;

common/protocol.cpp

@@ -64,8 +64,11 @@ void ProtocolItem::initializeHash()
 	
 	initializeHashAuto();
 	
+	itemNameHash.insert("cmddeck_upload", Command_DeckUpload::newItem);
+	
 	itemNameHash.insert("resp", ProtocolResponse::newItem);
 	ProtocolResponse::initializeHash();
+	itemNameHash.insert("respdeck_list", Response_DeckList::newItem);
 	
 	itemNameHash.insert("generic_eventlist_games", Event_ListGames::newItem);
 	itemNameHash.insert("generic_eventlist_chat_channels", Event_ListChatChannels::newItem);
@@ -92,13 +95,14 @@ void Command::extractParameters()
 
 void Command::processResponse(ProtocolResponse *response)
 {
+	emit finished(response);
 	emit finished(response->getResponseCode());
 }
 
 QHash<QString, ResponseCode> ProtocolResponse::responseHash;
 
-ProtocolResponse::ProtocolResponse(int _cmdId, ResponseCode _responseCode)
-	: ProtocolItem(QString()), cmdId(_cmdId), responseCode(_responseCode)
+ProtocolResponse::ProtocolResponse(int _cmdId, ResponseCode _responseCode, const QString &_itemName)
+	: ProtocolItem(_itemName), cmdId(_cmdId), responseCode(_responseCode)
 {
 	setParameter("cmd_id", cmdId);
 	setParameter("response_code", responseHash.key(responseCode));
@@ -125,6 +129,81 @@ void ProtocolResponse::initializeHash()
 	responseHash.insert("spectators_not_allowed", RespSpectatorsNotAllowed);
 }
 
+bool Response_DeckList::File::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isEndElement())
+		return true;
+	else
+		return false;
+}
+
+void Response_DeckList::File::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeStartElement("file");
+	xml->writeAttribute("name", name);
+	xml->writeAttribute("id", QString::number(id));
+	xml->writeEndElement();
+}
+
+Response_DeckList::Directory::~Directory()
+{
+	for (int i = 0; i < size(); ++i)
+		delete at(i);
+}
+
+bool Response_DeckList::Directory::readElement(QXmlStreamReader *xml)
+{
+	if (currentItem) {
+		if (currentItem->readElement(xml))
+			currentItem = 0;
+		return true;
+	}
+	if (xml->isStartElement() && (xml->name() == "directory")) {
+		currentItem = new Directory(xml->attributes().value("name").toString());
+		append(currentItem);
+	} else if (xml->isStartElement() && (xml->name() == "file")) {
+		currentItem = new File(xml->attributes().value("name").toString(), xml->attributes().value("id").toString().toInt());
+		append(currentItem);
+	} else
+		return false;
+	return true;
+}
+
+void Response_DeckList::Directory::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeStartElement("directory");
+	xml->writeAttribute("name", name);
+	for (int i = 0; i < size(); ++i)
+		at(i)->writeElement(xml);
+	xml->writeEndElement();
+}
+
+Response_DeckList::Response_DeckList(int _cmdId, ResponseCode _responseCode, Directory *_root)
+	: ProtocolResponse(_cmdId, _responseCode, "deck_list"), root(_root)
+{
+}
+
+Response_DeckList::~Response_DeckList()
+{
+	delete root;
+}
+
+bool Response_DeckList::readElement(QXmlStreamReader *xml)
+{
+	if (!root) {
+		if (xml->isStartElement() && (xml->name() == "directory"))
+			root = new Directory;
+		return false;
+	}
+	
+	return root->readElement(xml);
+}
+
+void Response_DeckList::writeElement(QXmlStreamWriter *xml)
+{
+	root->writeElement(xml);
+}
+
 GenericEvent::GenericEvent(const QString &_eventName)
 	: ProtocolItem(_eventName)
 {

common/protocol.h

@@ -16,9 +16,11 @@ class QXmlStreamAttributes;
 class ProtocolResponse;
 
 enum ItemId {
-	ItemId_Event_ListChatChannels = ItemId_Other + 1,
-	ItemId_Event_ChatListPlayers = ItemId_Other + 2,
-	ItemId_Event_ListGames = ItemId_Other + 3
+	ItemId_Command_DeckUpload = ItemId_Other + 1,
+	ItemId_Event_ListChatChannels = ItemId_Other + 2,
+	ItemId_Event_ChatListPlayers = ItemId_Other + 3,
+	ItemId_Event_ListGames = ItemId_Other + 4,
+	ItemId_Response_DeckList = ItemId_Other + 5
 };
 
 class ProtocolItem : public QObject {
@@ -51,9 +53,14 @@ public:
 	void write(QXmlStreamWriter *xml);
 };
 
+// ----------------
+// --- COMMANDS ---
+// ----------------
+
 class Command : public ProtocolItem {
 	Q_OBJECT
 signals:
+	void finished(ProtocolResponse *response);
 	void finished(ResponseCode response);
 private:
 	int cmdId;
@@ -114,6 +121,18 @@ public:
 	int getGameId() const { return gameId; }
 };
 
+class Command_DeckUpload : public Command {
+	Q_OBJECT
+public:
+	Command_DeckUpload(int _cmdId = -1) : Command("deck_upload", _cmdId) { }
+	static ProtocolItem *newItem() { return new Command_DeckUpload; }
+	int getItemId() const { return ItemId_Command_DeckUpload; }
+};
+
+// -----------------
+// --- RESPONSES ---
+// -----------------
+
 class ProtocolResponse : public ProtocolItem {
 	Q_OBJECT
 private:
@@ -124,7 +143,7 @@ protected:
 	QString getItemType() const { return "resp"; }
 	void extractParameters();
 public:
-	ProtocolResponse(int _cmdId = -1, ResponseCode _responseCode = RespOk);
+	ProtocolResponse(int _cmdId = -1, ResponseCode _responseCode = RespOk, const QString &_itemName = QString());
 	int getItemId() const { return ItemId_Other; }
 	static void initializeHash();
 	static ProtocolItem *newItem() { return new ProtocolResponse; }
@@ -132,6 +151,52 @@ public:
 	ResponseCode getResponseCode() const { return responseCode; }
 };
 
+class Response_DeckList : public ProtocolResponse {
+	Q_OBJECT
+public:
+	class TreeItem {
+	protected:
+		QString name;
+		int id;
+	public:
+		TreeItem(const QString &_name, int _id) : name(_name), id(_id) { }
+		QString getName() const { return name; }
+		int getId() const { return id; }
+		virtual bool readElement(QXmlStreamReader *xml) = 0;
+		virtual void writeElement(QXmlStreamWriter *xml) = 0;
+	};
+	class File : public TreeItem {
+	public:
+		File(const QString &_name, int _id) : TreeItem(_name, _id) { }
+		bool readElement(QXmlStreamReader *xml);
+		void writeElement(QXmlStreamWriter *xml);
+	};
+	class Directory : public TreeItem, public QList<TreeItem *> {
+	private:
+		TreeItem *currentItem;
+	public:
+		Directory(const QString &_name = QString(), int _id = 0) : TreeItem(_name, _id), currentItem(0) { }
+		~Directory();
+		bool readElement(QXmlStreamReader *xml);
+		void writeElement(QXmlStreamWriter *xml);
+	};
+private:
+	Directory *root;
+protected:
+	bool readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	Response_DeckList(int _cmdId = -1, ResponseCode _responseCode = RespOk, Directory *_root = 0);
+	~Response_DeckList();
+	int getItemId() const { return ItemId_Response_DeckList; }
+	static ProtocolItem *newItem() { return new Response_DeckList; }
+	Directory *getRoot() const { return root; }
+};
+
+// --------------
+// --- EVENTS ---
+// --------------
+
 class GenericEvent : public ProtocolItem {
 	Q_OBJECT
 protected:

common/protocol_item_ids.h

 enum AutoItemId {
 ItemId_Command_Ping = 1001,
 ItemId_Command_Login = 1002,
-ItemId_Command_ListChatChannels = 1003,
-ItemId_Command_ChatJoinChannel = 1004,
-ItemId_Command_ChatLeaveChannel = 1005,
-ItemId_Command_ChatSay = 1006,
-ItemId_Command_ListGames = 1007,
-ItemId_Command_CreateGame = 1008,
-ItemId_Command_JoinGame = 1009,
-ItemId_Command_LeaveGame = 1010,
-ItemId_Command_Say = 1011,
-ItemId_Command_Shuffle = 1012,
-ItemId_Command_RollDie = 1013,
-ItemId_Command_DrawCards = 1014,
-ItemId_Command_MoveCard = 1015,
-ItemId_Command_CreateToken = 1016,
-ItemId_Command_CreateArrow = 1017,
-ItemId_Command_DeleteArrow = 1018,
-ItemId_Command_SetCardAttr = 1019,
-ItemId_Command_ReadyStart = 1020,
-ItemId_Command_IncCounter = 1021,
-ItemId_Command_AddCounter = 1022,
-ItemId_Command_SetCounter = 1023,
-ItemId_Command_DelCounter = 1024,
-ItemId_Command_NextTurn = 1025,
-ItemId_Command_SetActivePhase = 1026,
-ItemId_Command_DumpZone = 1027,
-ItemId_Command_StopDumpZone = 1028,
-ItemId_Command_DumpAll = 1029,
-ItemId_Command_SubmitDeck = 1030,
-ItemId_Event_Say = 1031,
-ItemId_Event_Join = 1032,
-ItemId_Event_Leave = 1033,
-ItemId_Event_GameClosed = 1034,
-ItemId_Event_ReadyStart = 1035,
-ItemId_Event_SetupZones = 1036,
-ItemId_Event_GameStart = 1037,
-ItemId_Event_Shuffle = 1038,
-ItemId_Event_RollDie = 1039,
-ItemId_Event_MoveCard = 1040,
-ItemId_Event_CreateToken = 1041,
-ItemId_Event_CreateArrow = 1042,
-ItemId_Event_DeleteArrow = 1043,
-ItemId_Event_SetCardAttr = 1044,
-ItemId_Event_AddCounter = 1045,
-ItemId_Event_SetCounter = 1046,
-ItemId_Event_DelCounter = 1047,
-ItemId_Event_SetActivePlayer = 1048,
-ItemId_Event_SetActivePhase = 1049,
-ItemId_Event_DumpZone = 1050,
-ItemId_Event_StopDumpZone = 1051,
-ItemId_Event_ServerMessage = 1052,
-ItemId_Event_GameJoined = 1053,
-ItemId_Event_ChatJoinChannel = 1054,
-ItemId_Event_ChatLeaveChannel = 1055,
-ItemId_Event_ChatSay = 1056,
-ItemId_Other = 1057
+ItemId_Command_DeckList = 1003,
+ItemId_Command_DeckNewDir = 1004,
+ItemId_Command_DeckDelDir = 1005,
+ItemId_Command_DeckNew = 1006,
+ItemId_Command_DeckDel = 1007,
+ItemId_Command_DeckDownload = 1008,
+ItemId_Command_ListChatChannels = 1009,
+ItemId_Command_ChatJoinChannel = 1010,
+ItemId_Command_ChatLeaveChannel = 1011,
+ItemId_Command_ChatSay = 1012,
+ItemId_Command_ListGames = 1013,
+ItemId_Command_CreateGame = 1014,
+ItemId_Command_JoinGame = 1015,
+ItemId_Command_LeaveGame = 1016,
+ItemId_Command_Say = 1017,
+ItemId_Command_Shuffle = 1018,
+ItemId_Command_RollDie = 1019,
+ItemId_Command_DrawCards = 1020,
+ItemId_Command_MoveCard = 1021,
+ItemId_Command_CreateToken = 1022,
+ItemId_Command_CreateArrow = 1023,
+ItemId_Command_DeleteArrow = 1024,
+ItemId_Command_SetCardAttr = 1025,
+ItemId_Command_ReadyStart = 1026,
+ItemId_Command_IncCounter = 1027,
+ItemId_Command_AddCounter = 1028,
+ItemId_Command_SetCounter = 1029,
+ItemId_Command_DelCounter = 1030,
+ItemId_Command_NextTurn = 1031,
+ItemId_Command_SetActivePhase = 1032,
+ItemId_Command_DumpZone = 1033,
+ItemId_Command_StopDumpZone = 1034,
+ItemId_Command_DumpAll = 1035,
+ItemId_Command_SubmitDeck = 1036,
+ItemId_Event_Say = 1037,
+ItemId_Event_Join = 1038,
+ItemId_Event_Leave = 1039,
+ItemId_Event_GameClosed = 1040,
+ItemId_Event_ReadyStart = 1041,
+ItemId_Event_SetupZones = 1042,
+ItemId_Event_GameStart = 1043,
+ItemId_Event_Shuffle = 1044,
+ItemId_Event_RollDie = 1045,
+ItemId_Event_MoveCard = 1046,
+ItemId_Event_CreateToken = 1047,
+ItemId_Event_CreateArrow = 1048,
+ItemId_Event_DeleteArrow = 1049,
+ItemId_Event_SetCardAttr = 1050,
+ItemId_Event_AddCounter = 1051,
+ItemId_Event_SetCounter = 1052,
+ItemId_Event_DelCounter = 1053,
+ItemId_Event_SetActivePlayer = 1054,
+ItemId_Event_SetActivePhase = 1055,
+ItemId_Event_DumpZone = 1056,
+ItemId_Event_StopDumpZone = 1057,
+ItemId_Event_ServerMessage = 1058,
+ItemId_Event_GameJoined = 1059,
+ItemId_Event_ChatJoinChannel = 1060,
+ItemId_Event_ChatLeaveChannel = 1061,
+ItemId_Event_ChatSay = 1062,
+ItemId_Other = 1063
 };

common/protocol_items.cpp

@@ -17,6 +17,66 @@ void Command_Login::extractParameters()
 	username = parameters["username"];
 	password = parameters["password"];
 }
+Command_DeckList::Command_DeckList()
+	: Command("deck_list")
+{
+}
+Command_DeckNewDir::Command_DeckNewDir(const QString &_path, const QString &_name)
+	: Command("deck_new_dir"), path(_path), name(_name)
+{
+	setParameter("path", path);
+	setParameter("name", name);
+}
+void Command_DeckNewDir::extractParameters()
+{
+	Command::extractParameters();
+	path = parameters["path"];
+	name = parameters["name"];
+}
+Command_DeckDelDir::Command_DeckDelDir(const QString &_path, const QString &_name)
+	: Command("deck_del_dir"), path(_path), name(_name)
+{
+	setParameter("path", path);
+	setParameter("name", name);
+}
+void Command_DeckDelDir::extractParameters()
+{
+	Command::extractParameters();
+	path = parameters["path"];
+	name = parameters["name"];
+}
+Command_DeckNew::Command_DeckNew(const QString &_path, int _id)
+	: Command("deck_new"), path(_path), id(_id)
+{
+	setParameter("path", path);
+	setParameter("id", id);
+}
+void Command_DeckNew::extractParameters()
+{
+	Command::extractParameters();
+	path = parameters["path"];
+	id = parameters["id"].toInt();
+}
+Command_DeckDel::Command_DeckDel(int _id)
+	: Command("deck_del"), id(_id)
+{
+	setParameter("id", id);
+}
+void Command_DeckDel::extractParameters()
+{
+	Command::extractParameters();
+	id = parameters["id"].toInt();
+}
+Command_DeckDownload::Command_DeckDownload(int _id)
+	: Command("deck_download"), id(_id)
+{
+	setParameter("id", id);
+}
+void Command_DeckDownload::extractParameters()
+{
+	Command::extractParameters();
+	id = parameters["id"].toInt();
+}
 Command_ListChatChannels::Command_ListChatChannels()
 	: Command("list_chat_channels")
 {
@@ -609,6 +669,12 @@ void ProtocolItem::initializeHashAuto()
 {
 	itemNameHash.insert("cmdping", Command_Ping::newItem);
 	itemNameHash.insert("cmdlogin", Command_Login::newItem);
+	itemNameHash.insert("cmddeck_list", Command_DeckList::newItem);
+	itemNameHash.insert("cmddeck_new_dir", Command_DeckNewDir::newItem);
+	itemNameHash.insert("cmddeck_del_dir", Command_DeckDelDir::newItem);
+	itemNameHash.insert("cmddeck_new", Command_DeckNew::newItem);
+	itemNameHash.insert("cmddeck_del", Command_DeckDel::newItem);
+	itemNameHash.insert("cmddeck_download", Command_DeckDownload::newItem);
 	itemNameHash.insert("cmdlist_chat_channels", Command_ListChatChannels::newItem);
 	itemNameHash.insert("cmdchat_join_channel", Command_ChatJoinChannel::newItem);
 	itemNameHash.insert("cmdchat_leave_channel", Command_ChatLeaveChannel::newItem);

common/protocol_items.dat

 0:ping
 0:login:s,username:s,password
+0:deck_list
+0:deck_new_dir:s,path:s,name
+0:deck_del_dir:s,path:s,name
+0:deck_new:s,path:i,id
+0:deck_del:i,id
+0:deck_download:i,id
 0:list_chat_channels
 0:chat_join_channel:s,channel
 1:chat_leave_channel

common/protocol_items.h

@@ -25,6 +25,80 @@ public:
 protected:
 	void extractParameters();
 };
+class Command_DeckList : public Command {
+	Q_OBJECT
+private:
+public:
+	Command_DeckList();
+	static ProtocolItem *newItem() { return new Command_DeckList; }
+	int getItemId() const { return ItemId_Command_DeckList; }
+};
+class Command_DeckNewDir : public Command {
+	Q_OBJECT
+private:
+	QString path;
+	QString name;
+public:
+	Command_DeckNewDir(const QString &_path = QString(), const QString &_name = QString());
+	QString getPath() const { return path; }
+	QString getName() const { return name; }
+	static ProtocolItem *newItem() { return new Command_DeckNewDir; }
+	int getItemId() const { return ItemId_Command_DeckNewDir; }
+protected:
+	void extractParameters();
+};
+class Command_DeckDelDir : public Command {
+	Q_OBJECT
+private:
+	QString path;
+	QString name;
+public:
+	Command_DeckDelDir(const QString &_path = QString(), const QString &_name = QString());
+	QString getPath() const { return path; }
+	QString getName() const { return name; }
+	static ProtocolItem *newItem() { return new Command_DeckDelDir; }
+	int getItemId() const { return ItemId_Command_DeckDelDir; }
+protected:
+	void extractParameters();
+};
+class Command_DeckNew : public Command {
+	Q_OBJECT
+private:
+	QString path;
+	int id;
+public:
+	Command_DeckNew(const QString &_path = QString(), int _id = -1);
+	QString getPath() const { return path; }
+	int getId() const { return id; }
+	static ProtocolItem *newItem() { return new Command_DeckNew; }
+	int getItemId() const { return ItemId_Command_DeckNew; }
+protected:
+	void extractParameters();
+};
+class Command_DeckDel : public Command {
+	Q_OBJECT
+private:
+	int id;
+public:
+	Command_DeckDel(int _id = -1);
+	int getId() const { return id; }
+	static ProtocolItem *newItem() { return new Command_DeckDel; }
+	int getItemId() const { return ItemId_Command_DeckDel; }
+protected:
+	void extractParameters();
+};
+class Command_DeckDownload : public Command {
+	Q_OBJECT
+private:
+	int id;
+public:
+	Command_DeckDownload(int _id = -1);
+	int getId() const { return id; }
+	static ProtocolItem *newItem() { return new Command_DeckDownload; }
+	int getItemId() const { return ItemId_Command_DeckDownload; }
+protected:
+	void extractParameters();
+};
 class Command_ListChatChannels : public Command {
 	Q_OBJECT
 private:

common/server_protocolhandler.cpp

@@ -84,6 +84,13 @@ void Server_ProtocolHandler::processCommand(Command *command)
 		switch (command->getItemId()) {
 			case ItemId_Command_Ping: response = cmdPing(qobject_cast<Command_Ping *>(command)); break;
 			case ItemId_Command_Login: response = cmdLogin(qobject_cast<Command_Login *>(command)); break;
+			case ItemId_Command_DeckList: response = cmdDeckList(qobject_cast<Command_DeckList *>(command)); break;
+			case ItemId_Command_DeckNewDir: response = cmdDeckNewDir(qobject_cast<Command_DeckNewDir *>(command)); break;
+			case ItemId_Command_DeckDelDir: response = cmdDeckDelDir(qobject_cast<Command_DeckDelDir *>(command)); break;
+			case ItemId_Command_DeckNew: response = cmdDeckNew(qobject_cast<Command_DeckNew *>(command)); break;
+			case ItemId_Command_DeckDel: response = cmdDeckDel(qobject_cast<Command_DeckDel *>(command)); break;
+			case ItemId_Command_DeckUpload: response = cmdDeckUpload(qobject_cast<Command_DeckUpload *>(command)); break;
+			case ItemId_Command_DeckDownload: response = cmdDeckDownload(qobject_cast<Command_DeckDownload *>(command)); break;
 			case ItemId_Command_ListChatChannels: response = cmdListChatChannels(qobject_cast<Command_ListChatChannels *>(command)); break;
 			case ItemId_Command_ChatJoinChannel: response = cmdChatJoinChannel(qobject_cast<Command_ChatJoinChannel *>(command)); break;
 			case ItemId_Command_ListGames: response = cmdListGames(qobject_cast<Command_ListGames *>(command)); break;

common/server_protocolhandler.h

@@ -11,7 +11,7 @@ class Server_Player;
 
 class Server_ProtocolHandler : public QObject {
 	Q_OBJECT
-private:
+protected:
 	Server *server;
 	QMap<int, QPair<Server_Game *, Server_Player *> > games;
 	QMap<QString, Server_ChatChannel *> chatChannels;
@@ -24,10 +24,18 @@ private:
 	bool acceptsGameListChanges;
 	bool acceptsChatChannelListChanges;
 	
+private:
 	QList<ProtocolItem *> itemQueue;
 	
 	ResponseCode cmdPing(Command_Ping *cmd);
 	ResponseCode cmdLogin(Command_Login *cmd);
+	virtual ResponseCode cmdDeckList(Command_DeckList *cmd) = 0;
+	virtual ResponseCode cmdDeckNewDir(Command_DeckNewDir *cmd) = 0;
+	virtual ResponseCode cmdDeckDelDir(Command_DeckDelDir *cmd) = 0;
+	virtual ResponseCode cmdDeckNew(Command_DeckNew *cmd) = 0;
+	virtual ResponseCode cmdDeckDel(Command_DeckDel *cmd) = 0;
+	virtual ResponseCode cmdDeckUpload(Command_DeckUpload *cmd) = 0;
+	virtual ResponseCode cmdDeckDownload(Command_DeckDownload *cmd) = 0;
 	ResponseCode cmdListChatChannels(Command_ListChatChannels *cmd);
 	ResponseCode cmdChatJoinChannel(Command_ChatJoinChannel *cmd);
 	ResponseCode cmdChatLeaveChannel(Command_ChatLeaveChannel *cmd, Server_ChatChannel *channel);

servatrice/src/servatrice.cpp

@@ -87,6 +87,20 @@ bool Servatrice::openDatabase()
 	return true;
 }
 
+void Servatrice::checkSql()
+{
+	if (!QSqlDatabase::database().exec("select 1").isActive())
+		openDatabase();
+}
+
+bool Servatrice::execSqlQuery(QSqlQuery &query)
+{
+	if (query.exec())
+		return true;
+	qCritical(QString("Database error: %1").arg(query.lastError().text()).toLatin1());
+	return false;
+}
+
 void Servatrice::newConnection()
 {
 	QTcpSocket *socket = tcpServer->nextPendingConnection();
@@ -100,16 +114,14 @@ AuthenticationResult Servatrice::checkUserPassword(const QString &user, const QS
 	if (method == "none")
 		return UnknownUser;
 	else if (method == "sql") {
-		if (!QSqlDatabase::database().exec("select 1").isActive())
-			openDatabase();
+		checkSql();
 	
 		QSqlQuery query;
 		query.prepare("select password from players where name = :name");
 		query.bindValue(":name", user);
-		if (!query.exec()) {
-			qCritical(QString("Database error: %1").arg(query.lastError().text()).toLatin1());
+		if (!execSqlQuery(query))
 			return PasswordWrong;
-		}
+		
 		if (query.next()) {
 			if (query.value(0).toString() == password)
 				return PasswordRight;

servatrice/src/servatrice.h

@@ -25,6 +25,7 @@
 
 class QSqlDatabase;
 class QSettings;
+class QSqlQuery;
 
 class Servatrice : public Server
 {
@@ -36,6 +37,8 @@ public:
 	Servatrice(QObject *parent = 0);
 	~Servatrice();
 	bool openDatabase();
+	void checkSql();
+	bool execSqlQuery(QSqlQuery &query);
 	AuthenticationResult checkUserPassword(const QString &user, const QString &password);
 	QString getLoginMessage() const { return loginMessage; }
 private:

servatrice/src/serversocketinterface.cpp

@@ -20,13 +20,14 @@
 
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
+#include <QtSql>
 #include "serversocketinterface.h"
 #include "servatrice.h"
 #include "protocol.h"
 #include "protocol_items.h"
 
-ServerSocketInterface::ServerSocketInterface(Server *_server, QTcpSocket *_socket, QObject *parent)
-	: Server_ProtocolHandler(_server, parent), socket(_socket), currentItem(0)
+ServerSocketInterface::ServerSocketInterface(Servatrice *_server, QTcpSocket *_socket, QObject *parent)
+	: Server_ProtocolHandler(_server, parent), servatrice(_server), socket(_socket), currentItem(0)
 {
 	xmlWriter = new QXmlStreamWriter;
 	xmlWriter->setDevice(socket);
@@ -101,3 +102,92 @@ void ServerSocketInterface::sendProtocolItem(ProtocolItem *item, bool deleteItem
 	if (deleteItem)
 		delete item;
 }
+
+int ServerSocketInterface::getDeckPathId(int basePathId, QStringList path)
+{
+	if (path.isEmpty())
+		return 0;
+	if (path[0].isEmpty())
+		return 0;
+	
+	servatrice->checkSql();
+	
+	QSqlQuery query;
+	query.prepare("select id from decklist_folders where id_parent = :id_parent and name = :name");
+	query.bindValue(":id_parent", basePathId);
+	query.bindValue(":name", path.takeFirst());
+	if (!servatrice->execSqlQuery(query))
+		return -1;
+	if (!query.next())
+		return -1;
+	int id = query.value(0).toInt();
+	if (path.isEmpty())
+		return id;
+	else
+		return getDeckPathId(id, path);
+}
+
+void ServerSocketInterface::deckListHelper(Response_DeckList::Directory *folder)
+{
+	QSqlQuery query;
+	query.prepare("select id, name from decklist_folders where id_parent = :id_parent and user = :user");
+	query.bindValue(":id_parent", folder->getId());
+	query.bindValue(":user", playerName);
+	servatrice->execSqlQuery(query);
+	
+	while (query.next()) {
+		Response_DeckList::Directory *newFolder = new Response_DeckList::Directory(query.value(1).toString(), query.value(0).toInt());
+		folder->append(newFolder);
+		deckListHelper(newFolder);
+	}
+}
+
+ResponseCode ServerSocketInterface::cmdDeckList(Command_DeckList *cmd)
+{
+	Response_DeckList::Directory *root = new Response_DeckList::Directory(QString());
+	
+	servatrice->checkSql();
+	QSqlQuery query;
+	deckListHelper(root);
+	
+	sendProtocolItem(new Response_DeckList(cmd->getCmdId(), RespOk, root));
+	
+	return RespNothing;
+}
+
+ResponseCode ServerSocketInterface::cmdDeckNewDir(Command_DeckNewDir *cmd)
+{
+	int folderId = getDeckPathId(0, cmd->getPath().split("/"));
+	qDebug() << "folderId" << folderId;
+	if (folderId == -1)
+		return RespNameNotFound;
+	
+	QSqlQuery query;
+	query.prepare("insert into decklist_folders (id_parent, user, name) values(:id_parent, :user, :name)");
+	query.bindValue(":id_parent", folderId);
+	query.bindValue(":user", playerName);
+	query.bindValue(":name", cmd->getName());
+	if (!servatrice->execSqlQuery(query))
+		return RespContextError;
+	return RespOk;
+}
+
+ResponseCode ServerSocketInterface::cmdDeckDelDir(Command_DeckDelDir *cmd)
+{
+}
+
+ResponseCode ServerSocketInterface::cmdDeckNew(Command_DeckNew *cmd)
+{
+}
+
+ResponseCode ServerSocketInterface::cmdDeckDel(Command_DeckDel *cmd)
+{
+}
+
+ResponseCode ServerSocketInterface::cmdDeckUpload(Command_DeckUpload *cmd)
+{
+}
+
+ResponseCode ServerSocketInterface::cmdDeckDownload(Command_DeckDownload *cmd)
+{
+}

servatrice/src/serversocketinterface.h

@@ -24,7 +24,7 @@
 #include "server_protocolhandler.h"
 
 class QTcpSocket;
-class Server;
+class Servatrice;
 class QXmlStreamReader;
 class QXmlStreamWriter;
 
@@ -35,12 +35,23 @@ private slots:
 	void readClient();
 	void catchSocketError(QAbstractSocket::SocketError socketError);
 private:
+	Servatrice *servatrice;
 	QTcpSocket *socket;
 	QXmlStreamWriter *xmlWriter;
 	QXmlStreamReader *xmlReader;
 	ProtocolItem *currentItem;
+
+	int getDeckPathId(int basePathId, QStringList path);
+	void deckListHelper(Response_DeckList::Directory *folder);
+	ResponseCode cmdDeckList(Command_DeckList *cmd);
+	ResponseCode cmdDeckNewDir(Command_DeckNewDir *cmd);
+	ResponseCode cmdDeckDelDir(Command_DeckDelDir *cmd);
+	ResponseCode cmdDeckNew(Command_DeckNew *cmd);
+	ResponseCode cmdDeckDel(Command_DeckDel *cmd);
+	ResponseCode cmdDeckUpload(Command_DeckUpload *cmd);
+	ResponseCode cmdDeckDownload(Command_DeckDownload *cmd);
 public:
-	ServerSocketInterface(Server *_server, QTcpSocket *_socket, QObject *parent = 0);
+	ServerSocketInterface(Servatrice *_server, QTcpSocket *_socket, QObject *parent = 0);
 	~ServerSocketInterface();
 
 	void sendProtocolItem(ProtocolItem *item, bool deleteItem = true);