diff --git a/bin/qt5-petstore.sh b/bin/qt5-petstore.sh new file mode 100755 index 00000000000..d79dd513ded --- /dev/null +++ b/bin/qt5-petstore.sh @@ -0,0 +1,31 @@ +#!/bin/sh + +SCRIPT="$0" + +while [ -h "$SCRIPT" ] ; do + ls=`ls -ld "$SCRIPT"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + SCRIPT="$link" + else + SCRIPT=`dirname "$SCRIPT"`/"$link" + fi +done + +if [ ! -d "${APP_DIR}" ]; then + APP_DIR=`dirname "$SCRIPT"`/.. + APP_DIR=`cd "${APP_DIR}"; pwd` +fi + +executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar" + +if [ ! -f "$executable" ] +then + mvn clean package +fi + +# if you've executed sbt assembly previously it will use that instead. +export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties" +ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l qt5cpp -o samples/client/petstore/qt5cpp" + +java $JAVA_OPTS -jar $executable $ags diff --git a/samples/client/petstore/qt5cpp/client/SWGCategory.cpp b/samples/client/petstore/qt5cpp/client/SWGCategory.cpp new file mode 100644 index 00000000000..9a5aaa14af7 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGCategory.cpp @@ -0,0 +1,105 @@ + +#include "SWGCategory.h" + +#include "SWGHelpers.h" + +#include +#include +#include +#include + +namespace Swagger { + + +SWGCategory::SWGCategory(QString* json) { + init(); + this->fromJson(*json); +} + +SWGCategory::SWGCategory() { + init(); +} + +SWGCategory::~SWGCategory() { + this->cleanup(); +} + +void +SWGCategory::init() { + id = 0L; + name = new QString(""); + +} + +void +SWGCategory::cleanup() { + + if(name != NULL) { + delete name; + } + +} + +SWGCategory* +SWGCategory::fromJson(QString &json) { + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonObject jsonObject = doc.object(); + this->fromJsonObject(jsonObject); + return this; +} + +void +SWGCategory::fromJsonObject(QJsonObject &pJson) { + setValue(&id, pJson["id"], "qint64", ""); + setValue(&name, pJson["name"], "QString", "QString"); + +} + +QString +SWGCategory::asJson () +{ + QJsonObject* obj = this->asJsonObject(); + + QJsonDocument doc(*obj); + QByteArray bytes = doc.toJson(); + return QString(bytes); +} + +QJsonObject* +SWGCategory::asJsonObject() { + QJsonObject* obj = new QJsonObject(); + obj->insert("id", QJsonValue(id)); + + + toJsonValue(QString("name"), name, obj, QString("QString")); + + + + + + return obj; +} + +qint64 +SWGCategory::getId() { + return id; +} +void +SWGCategory::setId(qint64 id) { + this->id = id; +} + +QString* +SWGCategory::getName() { + return name; +} +void +SWGCategory::setName(QString* name) { + this->name = name; +} + + + +} /* namespace Swagger */ + diff --git a/samples/client/petstore/qt5cpp/client/SWGCategory.h b/samples/client/petstore/qt5cpp/client/SWGCategory.h new file mode 100644 index 00000000000..b1d5b65538f --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGCategory.h @@ -0,0 +1,47 @@ +/* + * SWGCategory.h + * + * + */ + +#ifndef SWGCategory_H_ +#define SWGCategory_H_ + +#include + + +#include + +#include "SWGObject.h" + + +namespace Swagger { + +class SWGCategory: public SWGObject { +public: + SWGCategory(); + SWGCategory(QString* json); + virtual ~SWGCategory(); + void init(); + void cleanup(); + + QString asJson (); + QJsonObject* asJsonObject(); + void fromJsonObject(QJsonObject &json); + SWGCategory* fromJson(QString &jsonString); + + qint64 getId(); + void setId(qint64 id); + QString* getName(); + void setName(QString* name); + + +private: + qint64 id; + QString* name; + +}; + +} /* namespace Swagger */ + +#endif /* SWGCategory_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGHelpers.cpp b/samples/client/petstore/qt5cpp/client/SWGHelpers.cpp new file mode 100644 index 00000000000..01e205a0773 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGHelpers.cpp @@ -0,0 +1,161 @@ +#include "SWGHelpers.h" +#include "SWGModelFactory.h" +#include "SWGObject.h" +#import +#import +#import + +namespace Swagger { + +void +setValue(void* value, QJsonValue obj, QString type, QString complexType) { + if(value == NULL) { + // can't set value with a null pointer + return; + } + if(QStringLiteral("bool").compare(type) == 0) { + bool * val = static_cast(value); + *val = obj.toBool(); + } + else if(QStringLiteral("qint32").compare(type) == 0) { + qint32 *val = static_cast(value); + *val = obj.toInt(); + } + else if(QStringLiteral("qint64").compare(type) == 0) { + qint64 *val = static_cast(value); + *val = obj.toVariant().toLongLong(); + } + else if (QStringLiteral("QString").compare(type) == 0) { + QString **val = static_cast(value); + + if(val != NULL) { + if(!obj.isNull()) { + // create a new value and return + delete *val; + *val = new QString(obj.toString()); + return; + } + else { + // set target to NULL + delete *val; + *val = NULL; + } + } + else { + qDebug() << "Can't set value because the target pointer is NULL"; + } + } + else if(type.startsWith("SWG") && obj.isObject()) { + // complex type + QJsonObject jsonObj = obj.toObject(); + SWGObject * so = (SWGObject*)Swagger::create(type); + if(so != NULL) { + so->fromJsonObject(jsonObj); + SWGObject **val = static_cast(value); + delete *val; + *val = so; + } + } + else if(type.startsWith("QList") && QString("").compare(complexType) != 0 && obj.isArray()) { + // list of values + QList* output = new QList(); + QJsonArray arr = obj.toArray(); + foreach (const QJsonValue & jval, arr) { + if(complexType.startsWith("SWG")) { + // it's an object + SWGObject * val = (SWGObject*)create(complexType); + QJsonObject t = jval.toObject(); + + val->fromJsonObject(t); + output->append(val); + } + else { + // primitives + if(QStringLiteral("qint32").compare(complexType) == 0) { + qint32 val; + setValue(&val, jval, QStringLiteral("qint32"), QStringLiteral("")); + output->append((void*)&val); + } + else if(QStringLiteral("qint64").compare(complexType) == 0) { + qint64 val; + setValue(&val, jval, QStringLiteral("qint64"), QStringLiteral("")); + output->append((void*)&val); + } + else if(QStringLiteral("bool").compare(complexType) == 0) { + bool val; + setValue(&val, jval, QStringLiteral("bool"), QStringLiteral("")); + output->append((void*)&val); + } + } + } + QList **val = static_cast**>(value); + delete *val; + *val = output; + } +} + +void +toJsonValue(QString name, void* value, QJsonObject* output, QString type) { + if(value == NULL) { + return; + } + if(type.startsWith("SWG")) { + SWGObject *swgObject = reinterpret_cast(value); + if(swgObject != NULL) { + QJsonObject* o = (*swgObject).asJsonObject(); + if(name != NULL) { + output->insert(name, *o); + delete o; + } + else { + output->empty(); + foreach(QString key, o->keys()) { + output->insert(key, o->value(key)); + } + } + } + } + else if(QStringLiteral("QString").compare(type) == 0) { + QString* str = static_cast(value); + output->insert(name, QJsonValue(*str)); + } + else if(QStringLiteral("qint32").compare(type) == 0) { + qint32* str = static_cast(value); + output->insert(name, QJsonValue(*str)); + } + else if(QStringLiteral("qint64").compare(type) == 0) { + qint64* str = static_cast(value); + output->insert(name, QJsonValue(*str)); + } + else if(QStringLiteral("bool").compare(type) == 0) { + bool* str = static_cast(value); + output->insert(name, QJsonValue(*str)); + } +} + +void +toJsonArray(QList* value, QJsonArray* output, QString innerName, QString innerType) { + foreach(void* obj, *value) { + QJsonObject element; + + toJsonValue(NULL, obj, &element, innerType); + output->append(element); + } +} + +QString +stringValue(QString* value) { + QString* str = static_cast(value); + return QString(*str); +} + +QString +stringValue(qint32 value) { + return QString::number(value); +} + +QString +stringValue(bool value) { + return QString(value ? "true" : "false"); +} +} /* namespace Swagger */ diff --git a/samples/client/petstore/qt5cpp/client/SWGHelpers.h b/samples/client/petstore/qt5cpp/client/SWGHelpers.h new file mode 100644 index 00000000000..988e6480da8 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGHelpers.h @@ -0,0 +1,16 @@ +#ifndef SWGHELPERS_H +#define SWGHELPERS_H + +#include + +namespace Swagger { + void setValue(void* value, QJsonValue obj, QString type, QString complexType); + void toJsonArray(QList* value, QJsonArray* output, QString innerName, QString innerType); + void toJsonValue(QString name, void* value, QJsonObject* output, QString type); + bool isCompatibleJsonValue(QString type); + QString stringValue(QString* value); + QString stringValue(qint32 value); + QString stringValue(bool value); +} + +#endif // SWGHELPERS_H diff --git a/samples/client/petstore/qt5cpp/client/SWGHttpRequest.cpp b/samples/client/petstore/qt5cpp/client/SWGHttpRequest.cpp new file mode 100644 index 00000000000..fed94e8dddb --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGHttpRequest.cpp @@ -0,0 +1,297 @@ +#include "SWGHttpRequest.h" +#include +#include +#include +#include + + +HttpRequestInput::HttpRequestInput() { + initialize(); +} + +HttpRequestInput::HttpRequestInput(QString v_url_str, QString v_http_method) { + initialize(); + url_str = v_url_str; + http_method = v_http_method; +} + +void HttpRequestInput::initialize() { + var_layout = NOT_SET; + url_str = ""; + http_method = "GET"; +} + +void HttpRequestInput::add_var(QString key, QString value) { + vars[key] = value; +} + +void HttpRequestInput::add_file(QString variable_name, QString local_filename, QString request_filename, QString mime_type) { + HttpRequestInputFileElement file; + file.variable_name = variable_name; + file.local_filename = local_filename; + file.request_filename = request_filename; + file.mime_type = mime_type; + files.append(file); +} + + +HttpRequestWorker::HttpRequestWorker(QObject *parent) + : QObject(parent), manager(NULL) +{ + qsrand(QDateTime::currentDateTime().toTime_t()); + + manager = new QNetworkAccessManager(this); + connect(manager, SIGNAL(finished(QNetworkReply*)), this, SLOT(on_manager_finished(QNetworkReply*))); +} + +HttpRequestWorker::~HttpRequestWorker() { +} + +QString HttpRequestWorker::http_attribute_encode(QString attribute_name, QString input) { + // result structure follows RFC 5987 + bool need_utf_encoding = false; + QString result = ""; + QByteArray input_c = input.toLocal8Bit(); + char c; + for (int i = 0; i < input_c.length(); i++) { + c = input_c.at(i); + if (c == '\\' || c == '/' || c == '\0' || c < ' ' || c > '~') { + // ignore and request utf-8 version + need_utf_encoding = true; + } + else if (c == '"') { + result += "\\\""; + } + else { + result += c; + } + } + + if (result.length() == 0) { + need_utf_encoding = true; + } + + if (!need_utf_encoding) { + // return simple version + return QString("%1=\"%2\"").arg(attribute_name, result); + } + + QString result_utf8 = ""; + for (int i = 0; i < input_c.length(); i++) { + c = input_c.at(i); + if ( + (c >= '0' && c <= '9') + || (c >= 'A' && c <= 'Z') + || (c >= 'a' && c <= 'z') + ) { + result_utf8 += c; + } + else { + result_utf8 += "%" + QString::number(static_cast(input_c.at(i)), 16).toUpper(); + } + } + + // return enhanced version with UTF-8 support + return QString("%1=\"%2\"; %1*=utf-8''%3").arg(attribute_name, result, result_utf8); +} + +void HttpRequestWorker::execute(HttpRequestInput *input) { + + // reset variables + + QByteArray request_content = ""; + response = ""; + error_type = QNetworkReply::NoError; + error_str = ""; + + + // decide on the variable layout + + if (input->files.length() > 0) { + input->var_layout = MULTIPART; + } + if (input->var_layout == NOT_SET) { + input->var_layout = input->http_method == "GET" || input->http_method == "HEAD" ? ADDRESS : URL_ENCODED; + } + + + // prepare request content + + QString boundary = ""; + + if (input->var_layout == ADDRESS || input->var_layout == URL_ENCODED) { + // variable layout is ADDRESS or URL_ENCODED + + if (input->vars.count() > 0) { + bool first = true; + foreach (QString key, input->vars.keys()) { + if (!first) { + request_content.append("&"); + } + first = false; + + request_content.append(QUrl::toPercentEncoding(key)); + request_content.append("="); + request_content.append(QUrl::toPercentEncoding(input->vars.value(key))); + } + + if (input->var_layout == ADDRESS) { + input->url_str += "?" + request_content; + request_content = ""; + } + } + } + else { + // variable layout is MULTIPART + + boundary = "__-----------------------" + + QString::number(QDateTime::currentDateTime().toTime_t()) + + QString::number(qrand()); + QString boundary_delimiter = "--"; + QString new_line = "\r\n"; + + // add variables + foreach (QString key, input->vars.keys()) { + // add boundary + request_content.append(boundary_delimiter); + request_content.append(boundary); + request_content.append(new_line); + + // add header + request_content.append("Content-Disposition: form-data; "); + request_content.append(http_attribute_encode("name", key)); + request_content.append(new_line); + request_content.append("Content-Type: text/plain"); + request_content.append(new_line); + + // add header to body splitter + request_content.append(new_line); + + // add variable content + request_content.append(input->vars.value(key)); + request_content.append(new_line); + } + + // add files + for (QList::iterator file_info = input->files.begin(); file_info != input->files.end(); file_info++) { + QFileInfo fi(file_info->local_filename); + + // ensure necessary variables are available + if ( + file_info->local_filename == NULL || file_info->local_filename.isEmpty() + || file_info->variable_name == NULL || file_info->variable_name.isEmpty() + || !fi.exists() || !fi.isFile() || !fi.isReadable() + ) { + // silent abort for the current file + continue; + } + + QFile file(file_info->local_filename); + if (!file.open(QIODevice::ReadOnly)) { + // silent abort for the current file + continue; + } + + // ensure filename for the request + if (file_info->request_filename == NULL || file_info->request_filename.isEmpty()) { + file_info->request_filename = fi.fileName(); + if (file_info->request_filename.isEmpty()) { + file_info->request_filename = "file"; + } + } + + // add boundary + request_content.append(boundary_delimiter); + request_content.append(boundary); + request_content.append(new_line); + + // add header + request_content.append(QString("Content-Disposition: form-data; %1; %2").arg( + http_attribute_encode("name", file_info->variable_name), + http_attribute_encode("filename", file_info->request_filename) + )); + request_content.append(new_line); + + if (file_info->mime_type != NULL && !file_info->mime_type.isEmpty()) { + request_content.append("Content-Type: "); + request_content.append(file_info->mime_type); + request_content.append(new_line); + } + + request_content.append("Content-Transfer-Encoding: binary"); + request_content.append(new_line); + + // add header to body splitter + request_content.append(new_line); + + // add file content + request_content.append(file.readAll()); + request_content.append(new_line); + + file.close(); + } + + // add end of body + request_content.append(boundary_delimiter); + request_content.append(boundary); + request_content.append(boundary_delimiter); + } + + if(input->request_body.size() > 0) { + qDebug() << "got a request body"; + request_content.clear(); + request_content.append(input->request_body); + } + // prepare connection + + QNetworkRequest request = QNetworkRequest(QUrl(input->url_str)); + request.setRawHeader("User-Agent", "Swagger-Client"); + foreach(QString key, input->headers.keys()) { + request.setRawHeader(key.toStdString().c_str(), input->headers.value(key).toStdString().c_str()); + } + + if (request_content.size() > 0) { + request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); + } + else if (input->var_layout == URL_ENCODED) { + request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded"); + } + else if (input->var_layout == MULTIPART) { + request.setHeader(QNetworkRequest::ContentTypeHeader, "multipart/form-data; boundary=" + boundary); + } + + if (input->http_method == "GET") { + manager->get(request); + } + else if (input->http_method == "POST") { + manager->post(request, request_content); + } + else if (input->http_method == "PUT") { + manager->put(request, request_content); + } + else if (input->http_method == "HEAD") { + manager->head(request); + } + else if (input->http_method == "DELETE") { + manager->deleteResource(request); + } + else { + QBuffer buff(&request_content); + manager->sendCustomRequest(request, input->http_method.toLatin1(), &buff); + } + +} + +void HttpRequestWorker::on_manager_finished(QNetworkReply *reply) { + error_type = reply->error(); + if (error_type == QNetworkReply::NoError) { + response = reply->readAll(); + } + else { + error_str = reply->errorString(); + } + + reply->deleteLater(); + + emit on_execution_finished(this); +} diff --git a/samples/client/petstore/qt5cpp/client/SWGHttpRequest.h b/samples/client/petstore/qt5cpp/client/SWGHttpRequest.h new file mode 100644 index 00000000000..260ccb20679 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGHttpRequest.h @@ -0,0 +1,76 @@ +/** + * Based on http://www.creativepulse.gr/en/blog/2014/restful-api-requests-using-qt-cpp-for-linux-mac-osx-ms-windows + * By Alex Stylianos + * + **/ + +#ifndef HTTPREQUESTWORKER_H +#define HTTPREQUESTWORKER_H + +#include +#include +#include +#include +#include + + +enum HttpRequestVarLayout {NOT_SET, ADDRESS, URL_ENCODED, MULTIPART}; + + +class HttpRequestInputFileElement { + +public: + QString variable_name; + QString local_filename; + QString request_filename; + QString mime_type; + +}; + + +class HttpRequestInput { + +public: + QString url_str; + QString http_method; + HttpRequestVarLayout var_layout; + QMap vars; + QMap headers; + QList files; + QByteArray request_body; + + HttpRequestInput(); + HttpRequestInput(QString v_url_str, QString v_http_method); + void initialize(); + void add_var(QString key, QString value); + void add_file(QString variable_name, QString local_filename, QString request_filename, QString mime_type); + +}; + + +class HttpRequestWorker : public QObject { + Q_OBJECT + +public: + QByteArray response; + QNetworkReply::NetworkError error_type; + QString error_str; + + explicit HttpRequestWorker(QObject *parent = 0); + virtual ~HttpRequestWorker(); + + QString http_attribute_encode(QString attribute_name, QString input); + void execute(HttpRequestInput *input); + +signals: + void on_execution_finished(HttpRequestWorker *worker); + +private: + QNetworkAccessManager *manager; + +private slots: + void on_manager_finished(QNetworkReply *reply); + +}; + +#endif // HTTPREQUESTWORKER_H diff --git a/samples/client/petstore/qt5cpp/client/SWGModelFactory.h b/samples/client/petstore/qt5cpp/client/SWGModelFactory.h new file mode 100644 index 00000000000..3eaf51ab0a9 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGModelFactory.h @@ -0,0 +1,34 @@ +#ifndef ModelFactory_H_ +#define ModelFactory_H_ + + +#include "SWGUser.h" +#include "SWGCategory.h" +#include "SWGPet.h" +#include "SWGTag.h" +#include "SWGOrder.h" + +namespace Swagger { + void* + create(QString type) { + if(QString("SWGUser").compare(type) == 0) { + return new SWGUser(); + } + if(QString("SWGCategory").compare(type) == 0) { + return new SWGCategory(); + } + if(QString("SWGPet").compare(type) == 0) { + return new SWGPet(); + } + if(QString("SWGTag").compare(type) == 0) { + return new SWGTag(); + } + if(QString("SWGOrder").compare(type) == 0) { + return new SWGOrder(); + } + + return NULL; + } +} /* namespace Swagger */ + +#endif /* ModelFactory_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGObject.h b/samples/client/petstore/qt5cpp/client/SWGObject.h new file mode 100644 index 00000000000..6cb5c042772 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGObject.h @@ -0,0 +1,24 @@ +#ifndef _SWG_OBJECT_H_ +#define _SWG_OBJECT_H_ + +#include + +class SWGObject { + public: + virtual QJsonObject* asJsonObject() { + return NULL; + } + virtual ~SWGObject() {} + virtual SWGObject* fromJson(QString &jsonString) { + Q_UNUSED(jsonString); + return NULL; + } + virtual void fromJsonObject(QJsonObject &json) { + Q_UNUSED(json); + } + virtual QString asJson() { + return QString(""); + } +}; + +#endif /* _SWG_OBJECT_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGOrder.cpp b/samples/client/petstore/qt5cpp/client/SWGOrder.cpp new file mode 100644 index 00000000000..3e34f2669c7 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGOrder.cpp @@ -0,0 +1,164 @@ + +#include "SWGOrder.h" + +#include "SWGHelpers.h" + +#include +#include +#include +#include + +namespace Swagger { + + +SWGOrder::SWGOrder(QString* json) { + init(); + this->fromJson(*json); +} + +SWGOrder::SWGOrder() { + init(); +} + +SWGOrder::~SWGOrder() { + this->cleanup(); +} + +void +SWGOrder::init() { + id = 0L; + petId = 0L; + quantity = 0; + shipDate = NULL; + status = new QString(""); + complete = false; + +} + +void +SWGOrder::cleanup() { + + + + if(shipDate != NULL) { + delete shipDate; + } + if(status != NULL) { + delete status; + } + + +} + +SWGOrder* +SWGOrder::fromJson(QString &json) { + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonObject jsonObject = doc.object(); + this->fromJsonObject(jsonObject); + return this; +} + +void +SWGOrder::fromJsonObject(QJsonObject &pJson) { + setValue(&id, pJson["id"], "qint64", ""); + setValue(&petId, pJson["petId"], "qint64", ""); + setValue(&quantity, pJson["quantity"], "qint32", ""); + setValue(&shipDate, pJson["shipDate"], "QDateTime", "QDateTime"); + setValue(&status, pJson["status"], "QString", "QString"); + setValue(&complete, pJson["complete"], "bool", ""); + +} + +QString +SWGOrder::asJson () +{ + QJsonObject* obj = this->asJsonObject(); + + QJsonDocument doc(*obj); + QByteArray bytes = doc.toJson(); + return QString(bytes); +} + +QJsonObject* +SWGOrder::asJsonObject() { + QJsonObject* obj = new QJsonObject(); + obj->insert("id", QJsonValue(id)); + obj->insert("petId", QJsonValue(petId)); + obj->insert("quantity", QJsonValue(quantity)); + + + toJsonValue(QString("shipDate"), shipDate, obj, QString("QDateTime")); + + + + + + toJsonValue(QString("status"), status, obj, QString("QString")); + + + + obj->insert("complete", QJsonValue(complete)); + + + return obj; +} + +qint64 +SWGOrder::getId() { + return id; +} +void +SWGOrder::setId(qint64 id) { + this->id = id; +} + +qint64 +SWGOrder::getPetId() { + return petId; +} +void +SWGOrder::setPetId(qint64 petId) { + this->petId = petId; +} + +qint32 +SWGOrder::getQuantity() { + return quantity; +} +void +SWGOrder::setQuantity(qint32 quantity) { + this->quantity = quantity; +} + +QDateTime* +SWGOrder::getShipDate() { + return shipDate; +} +void +SWGOrder::setShipDate(QDateTime* shipDate) { + this->shipDate = shipDate; +} + +QString* +SWGOrder::getStatus() { + return status; +} +void +SWGOrder::setStatus(QString* status) { + this->status = status; +} + +bool +SWGOrder::getComplete() { + return complete; +} +void +SWGOrder::setComplete(bool complete) { + this->complete = complete; +} + + + +} /* namespace Swagger */ + diff --git a/samples/client/petstore/qt5cpp/client/SWGOrder.h b/samples/client/petstore/qt5cpp/client/SWGOrder.h new file mode 100644 index 00000000000..d17713afe78 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGOrder.h @@ -0,0 +1,60 @@ +/* + * SWGOrder.h + * + * + */ + +#ifndef SWGOrder_H_ +#define SWGOrder_H_ + +#include + + +#include "QDateTime.h" +#include + +#include "SWGObject.h" + + +namespace Swagger { + +class SWGOrder: public SWGObject { +public: + SWGOrder(); + SWGOrder(QString* json); + virtual ~SWGOrder(); + void init(); + void cleanup(); + + QString asJson (); + QJsonObject* asJsonObject(); + void fromJsonObject(QJsonObject &json); + SWGOrder* fromJson(QString &jsonString); + + qint64 getId(); + void setId(qint64 id); + qint64 getPetId(); + void setPetId(qint64 petId); + qint32 getQuantity(); + void setQuantity(qint32 quantity); + QDateTime* getShipDate(); + void setShipDate(QDateTime* shipDate); + QString* getStatus(); + void setStatus(QString* status); + bool getComplete(); + void setComplete(bool complete); + + +private: + qint64 id; + qint64 petId; + qint32 quantity; + QDateTime* shipDate; + QString* status; + bool complete; + +}; + +} /* namespace Swagger */ + +#endif /* SWGOrder_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGPet.cpp b/samples/client/petstore/qt5cpp/client/SWGPet.cpp new file mode 100644 index 00000000000..d0e5b8280e2 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGPet.cpp @@ -0,0 +1,199 @@ + +#include "SWGPet.h" + +#include "SWGHelpers.h" + +#include +#include +#include +#include + +namespace Swagger { + + +SWGPet::SWGPet(QString* json) { + init(); + this->fromJson(*json); +} + +SWGPet::SWGPet() { + init(); +} + +SWGPet::~SWGPet() { + this->cleanup(); +} + +void +SWGPet::init() { + id = 0L; + category = new SWGCategory(); + name = new QString(""); + photoUrls = new QList(); + tags = new QList(); + status = new QString(""); + +} + +void +SWGPet::cleanup() { + + if(category != NULL) { + delete category; + } + if(name != NULL) { + delete name; + } + if(photoUrls != NULL) { + QList* arr = photoUrls; + foreach(QString* o, *arr) { + delete o; + } + delete photoUrls; + } + if(tags != NULL) { + QList* arr = tags; + foreach(SWGTag* o, *arr) { + delete o; + } + delete tags; + } + if(status != NULL) { + delete status; + } + +} + +SWGPet* +SWGPet::fromJson(QString &json) { + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonObject jsonObject = doc.object(); + this->fromJsonObject(jsonObject); + return this; +} + +void +SWGPet::fromJsonObject(QJsonObject &pJson) { + setValue(&id, pJson["id"], "qint64", ""); + setValue(&category, pJson["category"], "SWGCategory", "SWGCategory"); + setValue(&name, pJson["name"], "QString", "QString"); + setValue(&photoUrls, pJson["photoUrls"], "QList", "QString"); + setValue(&tags, pJson["tags"], "QList", "SWGTag"); + setValue(&status, pJson["status"], "QString", "QString"); + +} + +QString +SWGPet::asJson () +{ + QJsonObject* obj = this->asJsonObject(); + + QJsonDocument doc(*obj); + QByteArray bytes = doc.toJson(); + return QString(bytes); +} + +QJsonObject* +SWGPet::asJsonObject() { + QJsonObject* obj = new QJsonObject(); + obj->insert("id", QJsonValue(id)); + + + toJsonValue(QString("category"), category, obj, QString("SWGCategory")); + + + + + + toJsonValue(QString("name"), name, obj, QString("QString")); + + + + + + QList* photoUrlsList = photoUrls; + QJsonArray photoUrlsJsonArray; + toJsonArray((QList*)photoUrls, &photoUrlsJsonArray, "photoUrls", "QString"); + + obj->insert("photoUrls", photoUrlsJsonArray); + + + + + QList* tagsList = tags; + QJsonArray tagsJsonArray; + toJsonArray((QList*)tags, &tagsJsonArray, "tags", "SWGTag"); + + obj->insert("tags", tagsJsonArray); + + + + + toJsonValue(QString("status"), status, obj, QString("QString")); + + + + + + return obj; +} + +qint64 +SWGPet::getId() { + return id; +} +void +SWGPet::setId(qint64 id) { + this->id = id; +} + +SWGCategory* +SWGPet::getCategory() { + return category; +} +void +SWGPet::setCategory(SWGCategory* category) { + this->category = category; +} + +QString* +SWGPet::getName() { + return name; +} +void +SWGPet::setName(QString* name) { + this->name = name; +} + +QList* +SWGPet::getPhotoUrls() { + return photoUrls; +} +void +SWGPet::setPhotoUrls(QList* photoUrls) { + this->photoUrls = photoUrls; +} + +QList* +SWGPet::getTags() { + return tags; +} +void +SWGPet::setTags(QList* tags) { + this->tags = tags; +} + +QString* +SWGPet::getStatus() { + return status; +} +void +SWGPet::setStatus(QString* status) { + this->status = status; +} + + + +} /* namespace Swagger */ + diff --git a/samples/client/petstore/qt5cpp/client/SWGPet.h b/samples/client/petstore/qt5cpp/client/SWGPet.h new file mode 100644 index 00000000000..e9cb4d08233 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGPet.h @@ -0,0 +1,62 @@ +/* + * SWGPet.h + * + * + */ + +#ifndef SWGPet_H_ +#define SWGPet_H_ + +#include + + +#include "SWGTag.h" +#include +#include "SWGCategory.h" +#include + +#include "SWGObject.h" + + +namespace Swagger { + +class SWGPet: public SWGObject { +public: + SWGPet(); + SWGPet(QString* json); + virtual ~SWGPet(); + void init(); + void cleanup(); + + QString asJson (); + QJsonObject* asJsonObject(); + void fromJsonObject(QJsonObject &json); + SWGPet* fromJson(QString &jsonString); + + qint64 getId(); + void setId(qint64 id); + SWGCategory* getCategory(); + void setCategory(SWGCategory* category); + QString* getName(); + void setName(QString* name); + QList* getPhotoUrls(); + void setPhotoUrls(QList* photoUrls); + QList* getTags(); + void setTags(QList* tags); + QString* getStatus(); + void setStatus(QString* status); + + +private: + qint64 id; + SWGCategory* category; + QString* name; + QList* photoUrls; + QList* tags; + QString* status; + +}; + +} /* namespace Swagger */ + +#endif /* SWGPet_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGPetApi.cpp b/samples/client/petstore/qt5cpp/client/SWGPetApi.cpp new file mode 100644 index 00000000000..312791e4b0f --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGPetApi.cpp @@ -0,0 +1,455 @@ +#include "SWGPetApi.h" +#include "SWGHelpers.h" + +#include +#include + +namespace Swagger { +SWGPetApi::SWGPetApi() {} + +SWGPetApi::~SWGPetApi() {} + +SWGPetApi::SWGPetApi(QString host, QString basePath) { + this->host = host; + this->basePath = basePath; +} + +void +SWGPetApi::updatePet(SWGPet body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "PUT"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::updatePetCallback); + + worker->execute(&input); +} + +void +SWGPetApi::updatePetCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit updatePetSignal(); +} +void +SWGPetApi::addPet(SWGPet body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::addPetCallback); + + worker->execute(&input); +} + +void +SWGPetApi::addPetCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit addPetSignal(); +} +void +SWGPetApi::findPetsByStatus(QList<QString*>* status) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/findByStatus"); + + + + if(fullPath.compare("?") > 0) fullPath.append("?"); + else fullPath.append("&"); + fullPath.append(QUrl::toPercentEncoding("status")) + .append("=") + .append(QUrl::toPercentEncoding(stringValue(status))); + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::findPetsByStatusCallback); + + worker->execute(&input); +} + +void +SWGPetApi::findPetsByStatusCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: QList* + + + + QList* output = new QList(); + QString json(worker->response); + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonArray jsonArray = doc.array(); + + foreach(QJsonValue obj, jsonArray) { + SWGPet* o = new SWGPet(); + QJsonObject jv = obj.toObject(); + QJsonObject * ptr = (QJsonObject*)&jv; + o->fromJsonObject(*ptr); + output->append(o); + } + + + // void toJsonArray(QList* value, QJsonArray* output, QString innerName, QString innerType); + + + + + worker->deleteLater(); + + emit findPetsByStatusSignal(output); + +} +void +SWGPetApi::findPetsByTags(QList<QString*>* tags) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/findByTags"); + + + + if(fullPath.compare("?") > 0) fullPath.append("?"); + else fullPath.append("&"); + fullPath.append(QUrl::toPercentEncoding("tags")) + .append("=") + .append(QUrl::toPercentEncoding(stringValue(tags))); + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::findPetsByTagsCallback); + + worker->execute(&input); +} + +void +SWGPetApi::findPetsByTagsCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: QList* + + + + QList* output = new QList(); + QString json(worker->response); + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonArray jsonArray = doc.array(); + + foreach(QJsonValue obj, jsonArray) { + SWGPet* o = new SWGPet(); + QJsonObject jv = obj.toObject(); + QJsonObject * ptr = (QJsonObject*)&jv; + o->fromJsonObject(*ptr); + output->append(o); + } + + + // void toJsonArray(QList* value, QJsonArray* output, QString innerName, QString innerType); + + + + + worker->deleteLater(); + + emit findPetsByTagsSignal(output); + +} +void +SWGPetApi::getPetById(qint64 petId) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/{petId}"); + + + QString petIdPathParam("{"); petIdPathParam.append("petId").append("}"); + fullPath.replace(petIdPathParam, stringValue(petId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::getPetByIdCallback); + + worker->execute(&input); +} + +void +SWGPetApi::getPetByIdCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: SWGPet* + + + + + + QString json(worker->response); + SWGPet* output = new SWGPet(&json); + + + + + worker->deleteLater(); + + emit getPetByIdSignal(output); + +} +void +SWGPetApi::updatePetWithForm(QString* petId, QString* name, QString* status) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/{petId}"); + + + QString petIdPathParam("{"); petIdPathParam.append("petId").append("}"); + fullPath.replace(petIdPathParam, stringValue(petId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::updatePetWithFormCallback); + + worker->execute(&input); +} + +void +SWGPetApi::updatePetWithFormCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit updatePetWithFormSignal(); +} +void +SWGPetApi::deletePet(QString* api_key, qint64 petId) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/{petId}"); + + + QString petIdPathParam("{"); petIdPathParam.append("petId").append("}"); + fullPath.replace(petIdPathParam, stringValue(petId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "DELETE"); + + + + + input.headers + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::deletePetCallback); + + worker->execute(&input); +} + +void +SWGPetApi::deletePetCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit deletePetSignal(); +} +void +SWGPetApi::uploadFile(qint64 petId, QString* additionalMetadata, SWGFile* file) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/pet/{petId}/uploadImage"); + + + QString petIdPathParam("{"); petIdPathParam.append("petId").append("}"); + fullPath.replace(petIdPathParam, stringValue(petId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGPetApi::uploadFileCallback); + + worker->execute(&input); +} + +void +SWGPetApi::uploadFileCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit uploadFileSignal(); +} +} /* namespace Swagger */ diff --git a/samples/client/petstore/qt5cpp/client/SWGPetApi.h b/samples/client/petstore/qt5cpp/client/SWGPetApi.h new file mode 100644 index 00000000000..41aac089a4f --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGPetApi.h @@ -0,0 +1,56 @@ +#ifndef _SWG_SWGPetApi_H_ +#define _SWG_SWGPetApi_H_ + +#include "SWGHttpRequest.h" + +#include "SWGPet.h" +#include +#include "SWGFile.h" + +#include + +namespace Swagger { + +class SWGPetApi: public QObject { + Q_OBJECT + +public: + SWGPetApi(); + SWGPetApi(QString host, QString basePath); + ~SWGPetApi(); + + QString host; + QString basePath; + + void updatePet(SWGPet body); + void addPet(SWGPet body); + void findPetsByStatus(QList<QString*>* status); + void findPetsByTags(QList<QString*>* tags); + void getPetById(qint64 petId); + void updatePetWithForm(QString* petId, QString* name, QString* status); + void deletePet(QString* api_key, qint64 petId); + void uploadFile(qint64 petId, QString* additionalMetadata, SWGFile* file); + +private: + void updatePetCallback (HttpRequestWorker * worker); + void addPetCallback (HttpRequestWorker * worker); + void findPetsByStatusCallback (HttpRequestWorker * worker); + void findPetsByTagsCallback (HttpRequestWorker * worker); + void getPetByIdCallback (HttpRequestWorker * worker); + void updatePetWithFormCallback (HttpRequestWorker * worker); + void deletePetCallback (HttpRequestWorker * worker); + void uploadFileCallback (HttpRequestWorker * worker); + +signals: + void updatePetSignal(); + void addPetSignal(); + void findPetsByStatusSignal(QList* summary); + void findPetsByTagsSignal(QList* summary); + void getPetByIdSignal(SWGPet* summary); + void updatePetWithFormSignal(); + void deletePetSignal(); + void uploadFileSignal(); + +}; +} +#endif \ No newline at end of file diff --git a/samples/client/petstore/qt5cpp/client/SWGStoreApi.cpp b/samples/client/petstore/qt5cpp/client/SWGStoreApi.cpp new file mode 100644 index 00000000000..a973c7c99fd --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGStoreApi.cpp @@ -0,0 +1,230 @@ +#include "SWGStoreApi.h" +#include "SWGHelpers.h" + +#include +#include + +namespace Swagger { +SWGStoreApi::SWGStoreApi() {} + +SWGStoreApi::~SWGStoreApi() {} + +SWGStoreApi::SWGStoreApi(QString host, QString basePath) { + this->host = host; + this->basePath = basePath; +} + +void +SWGStoreApi::getInventory() { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/store/inventory"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGStoreApi::getInventoryCallback); + + worker->execute(&input); +} + +void +SWGStoreApi::getInventoryCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: QMap* + + + + + + QString json(worker->response); + QMap<String, qint32>* output = new QMap(&json); + + + + + worker->deleteLater(); + + emit getInventorySignal(output); + +} +void +SWGStoreApi::placeOrder(SWGOrder body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/store/order"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGStoreApi::placeOrderCallback); + + worker->execute(&input); +} + +void +SWGStoreApi::placeOrderCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: SWGOrder* + + + + + + QString json(worker->response); + SWGOrder* output = new SWGOrder(&json); + + + + + worker->deleteLater(); + + emit placeOrderSignal(output); + +} +void +SWGStoreApi::getOrderById(QString* orderId) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/store/order/{orderId}"); + + + QString orderIdPathParam("{"); orderIdPathParam.append("orderId").append("}"); + fullPath.replace(orderIdPathParam, stringValue(orderId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGStoreApi::getOrderByIdCallback); + + worker->execute(&input); +} + +void +SWGStoreApi::getOrderByIdCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: SWGOrder* + + + + + + QString json(worker->response); + SWGOrder* output = new SWGOrder(&json); + + + + + worker->deleteLater(); + + emit getOrderByIdSignal(output); + +} +void +SWGStoreApi::deleteOrder(QString* orderId) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/store/order/{orderId}"); + + + QString orderIdPathParam("{"); orderIdPathParam.append("orderId").append("}"); + fullPath.replace(orderIdPathParam, stringValue(orderId)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "DELETE"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGStoreApi::deleteOrderCallback); + + worker->execute(&input); +} + +void +SWGStoreApi::deleteOrderCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit deleteOrderSignal(); +} +} /* namespace Swagger */ diff --git a/samples/client/petstore/qt5cpp/client/SWGStoreApi.h b/samples/client/petstore/qt5cpp/client/SWGStoreApi.h new file mode 100644 index 00000000000..6b7755c7d5e --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGStoreApi.h @@ -0,0 +1,44 @@ +#ifndef _SWG_SWGStoreApi_H_ +#define _SWG_SWGStoreApi_H_ + +#include "SWGHttpRequest.h" + +#include "QMap.h" +#include "SWGOrder.h" +#include + +#include + +namespace Swagger { + +class SWGStoreApi: public QObject { + Q_OBJECT + +public: + SWGStoreApi(); + SWGStoreApi(QString host, QString basePath); + ~SWGStoreApi(); + + QString host; + QString basePath; + + void getInventory(); + void placeOrder(SWGOrder body); + void getOrderById(QString* orderId); + void deleteOrder(QString* orderId); + +private: + void getInventoryCallback (HttpRequestWorker * worker); + void placeOrderCallback (HttpRequestWorker * worker); + void getOrderByIdCallback (HttpRequestWorker * worker); + void deleteOrderCallback (HttpRequestWorker * worker); + +signals: + void getInventorySignal(QMap* summary); + void placeOrderSignal(SWGOrder* summary); + void getOrderByIdSignal(SWGOrder* summary); + void deleteOrderSignal(); + +}; +} +#endif \ No newline at end of file diff --git a/samples/client/petstore/qt5cpp/client/SWGTag.cpp b/samples/client/petstore/qt5cpp/client/SWGTag.cpp new file mode 100644 index 00000000000..bb4404de8df --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGTag.cpp @@ -0,0 +1,105 @@ + +#include "SWGTag.h" + +#include "SWGHelpers.h" + +#include +#include +#include +#include + +namespace Swagger { + + +SWGTag::SWGTag(QString* json) { + init(); + this->fromJson(*json); +} + +SWGTag::SWGTag() { + init(); +} + +SWGTag::~SWGTag() { + this->cleanup(); +} + +void +SWGTag::init() { + id = 0L; + name = new QString(""); + +} + +void +SWGTag::cleanup() { + + if(name != NULL) { + delete name; + } + +} + +SWGTag* +SWGTag::fromJson(QString &json) { + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonObject jsonObject = doc.object(); + this->fromJsonObject(jsonObject); + return this; +} + +void +SWGTag::fromJsonObject(QJsonObject &pJson) { + setValue(&id, pJson["id"], "qint64", ""); + setValue(&name, pJson["name"], "QString", "QString"); + +} + +QString +SWGTag::asJson () +{ + QJsonObject* obj = this->asJsonObject(); + + QJsonDocument doc(*obj); + QByteArray bytes = doc.toJson(); + return QString(bytes); +} + +QJsonObject* +SWGTag::asJsonObject() { + QJsonObject* obj = new QJsonObject(); + obj->insert("id", QJsonValue(id)); + + + toJsonValue(QString("name"), name, obj, QString("QString")); + + + + + + return obj; +} + +qint64 +SWGTag::getId() { + return id; +} +void +SWGTag::setId(qint64 id) { + this->id = id; +} + +QString* +SWGTag::getName() { + return name; +} +void +SWGTag::setName(QString* name) { + this->name = name; +} + + + +} /* namespace Swagger */ + diff --git a/samples/client/petstore/qt5cpp/client/SWGTag.h b/samples/client/petstore/qt5cpp/client/SWGTag.h new file mode 100644 index 00000000000..067b200675b --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGTag.h @@ -0,0 +1,47 @@ +/* + * SWGTag.h + * + * + */ + +#ifndef SWGTag_H_ +#define SWGTag_H_ + +#include + + +#include + +#include "SWGObject.h" + + +namespace Swagger { + +class SWGTag: public SWGObject { +public: + SWGTag(); + SWGTag(QString* json); + virtual ~SWGTag(); + void init(); + void cleanup(); + + QString asJson (); + QJsonObject* asJsonObject(); + void fromJsonObject(QJsonObject &json); + SWGTag* fromJson(QString &jsonString); + + qint64 getId(); + void setId(qint64 id); + QString* getName(); + void setName(QString* name); + + +private: + qint64 id; + QString* name; + +}; + +} /* namespace Swagger */ + +#endif /* SWGTag_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGUser.cpp b/samples/client/petstore/qt5cpp/client/SWGUser.cpp new file mode 100644 index 00000000000..f0d58c7e97b --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGUser.cpp @@ -0,0 +1,218 @@ + +#include "SWGUser.h" + +#include "SWGHelpers.h" + +#include +#include +#include +#include + +namespace Swagger { + + +SWGUser::SWGUser(QString* json) { + init(); + this->fromJson(*json); +} + +SWGUser::SWGUser() { + init(); +} + +SWGUser::~SWGUser() { + this->cleanup(); +} + +void +SWGUser::init() { + id = 0L; + username = new QString(""); + firstName = new QString(""); + lastName = new QString(""); + email = new QString(""); + password = new QString(""); + phone = new QString(""); + userStatus = 0; + +} + +void +SWGUser::cleanup() { + + if(username != NULL) { + delete username; + } + if(firstName != NULL) { + delete firstName; + } + if(lastName != NULL) { + delete lastName; + } + if(email != NULL) { + delete email; + } + if(password != NULL) { + delete password; + } + if(phone != NULL) { + delete phone; + } + + +} + +SWGUser* +SWGUser::fromJson(QString &json) { + QByteArray array (json.toStdString().c_str()); + QJsonDocument doc = QJsonDocument::fromJson(array); + QJsonObject jsonObject = doc.object(); + this->fromJsonObject(jsonObject); + return this; +} + +void +SWGUser::fromJsonObject(QJsonObject &pJson) { + setValue(&id, pJson["id"], "qint64", ""); + setValue(&username, pJson["username"], "QString", "QString"); + setValue(&firstName, pJson["firstName"], "QString", "QString"); + setValue(&lastName, pJson["lastName"], "QString", "QString"); + setValue(&email, pJson["email"], "QString", "QString"); + setValue(&password, pJson["password"], "QString", "QString"); + setValue(&phone, pJson["phone"], "QString", "QString"); + setValue(&userStatus, pJson["userStatus"], "qint32", ""); + +} + +QString +SWGUser::asJson () +{ + QJsonObject* obj = this->asJsonObject(); + + QJsonDocument doc(*obj); + QByteArray bytes = doc.toJson(); + return QString(bytes); +} + +QJsonObject* +SWGUser::asJsonObject() { + QJsonObject* obj = new QJsonObject(); + obj->insert("id", QJsonValue(id)); + + + toJsonValue(QString("username"), username, obj, QString("QString")); + + + + + + toJsonValue(QString("firstName"), firstName, obj, QString("QString")); + + + + + + toJsonValue(QString("lastName"), lastName, obj, QString("QString")); + + + + + + toJsonValue(QString("email"), email, obj, QString("QString")); + + + + + + toJsonValue(QString("password"), password, obj, QString("QString")); + + + + + + toJsonValue(QString("phone"), phone, obj, QString("QString")); + + + + obj->insert("userStatus", QJsonValue(userStatus)); + + + return obj; +} + +qint64 +SWGUser::getId() { + return id; +} +void +SWGUser::setId(qint64 id) { + this->id = id; +} + +QString* +SWGUser::getUsername() { + return username; +} +void +SWGUser::setUsername(QString* username) { + this->username = username; +} + +QString* +SWGUser::getFirstName() { + return firstName; +} +void +SWGUser::setFirstName(QString* firstName) { + this->firstName = firstName; +} + +QString* +SWGUser::getLastName() { + return lastName; +} +void +SWGUser::setLastName(QString* lastName) { + this->lastName = lastName; +} + +QString* +SWGUser::getEmail() { + return email; +} +void +SWGUser::setEmail(QString* email) { + this->email = email; +} + +QString* +SWGUser::getPassword() { + return password; +} +void +SWGUser::setPassword(QString* password) { + this->password = password; +} + +QString* +SWGUser::getPhone() { + return phone; +} +void +SWGUser::setPhone(QString* phone) { + this->phone = phone; +} + +qint32 +SWGUser::getUserStatus() { + return userStatus; +} +void +SWGUser::setUserStatus(qint32 userStatus) { + this->userStatus = userStatus; +} + + + +} /* namespace Swagger */ + diff --git a/samples/client/petstore/qt5cpp/client/SWGUser.h b/samples/client/petstore/qt5cpp/client/SWGUser.h new file mode 100644 index 00000000000..eaa0e496c39 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGUser.h @@ -0,0 +1,65 @@ +/* + * SWGUser.h + * + * + */ + +#ifndef SWGUser_H_ +#define SWGUser_H_ + +#include + + +#include + +#include "SWGObject.h" + + +namespace Swagger { + +class SWGUser: public SWGObject { +public: + SWGUser(); + SWGUser(QString* json); + virtual ~SWGUser(); + void init(); + void cleanup(); + + QString asJson (); + QJsonObject* asJsonObject(); + void fromJsonObject(QJsonObject &json); + SWGUser* fromJson(QString &jsonString); + + qint64 getId(); + void setId(qint64 id); + QString* getUsername(); + void setUsername(QString* username); + QString* getFirstName(); + void setFirstName(QString* firstName); + QString* getLastName(); + void setLastName(QString* lastName); + QString* getEmail(); + void setEmail(QString* email); + QString* getPassword(); + void setPassword(QString* password); + QString* getPhone(); + void setPhone(QString* phone); + qint32 getUserStatus(); + void setUserStatus(qint32 userStatus); + + +private: + qint64 id; + QString* username; + QString* firstName; + QString* lastName; + QString* email; + QString* password; + QString* phone; + qint32 userStatus; + +}; + +} /* namespace Swagger */ + +#endif /* SWGUser_H_ */ diff --git a/samples/client/petstore/qt5cpp/client/SWGUserApi.cpp b/samples/client/petstore/qt5cpp/client/SWGUserApi.cpp new file mode 100644 index 00000000000..21bba60e7d1 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGUserApi.cpp @@ -0,0 +1,424 @@ +#include "SWGUserApi.h" +#include "SWGHelpers.h" + +#include +#include + +namespace Swagger { +SWGUserApi::SWGUserApi() {} + +SWGUserApi::~SWGUserApi() {} + +SWGUserApi::SWGUserApi(QString host, QString basePath) { + this->host = host; + this->basePath = basePath; +} + +void +SWGUserApi::createUser(SWGUser body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::createUserCallback); + + worker->execute(&input); +} + +void +SWGUserApi::createUserCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit createUserSignal(); +} +void +SWGUserApi::createUsersWithArrayInput(QList<SWGUser*>* body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/createWithArray"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::createUsersWithArrayInputCallback); + + worker->execute(&input); +} + +void +SWGUserApi::createUsersWithArrayInputCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit createUsersWithArrayInputSignal(); +} +void +SWGUserApi::createUsersWithListInput(QList<SWGUser*>* body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/createWithList"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "POST"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::createUsersWithListInputCallback); + + worker->execute(&input); +} + +void +SWGUserApi::createUsersWithListInputCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit createUsersWithListInputSignal(); +} +void +SWGUserApi::loginUser(QString* username, QString* password) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/login"); + + + + if(fullPath.compare("?") > 0) fullPath.append("?"); + else fullPath.append("&"); + fullPath.append(QUrl::toPercentEncoding("username")) + .append("=") + .append(QUrl::toPercentEncoding(stringValue(username))); + if(fullPath.compare("?") > 0) fullPath.append("?"); + else fullPath.append("&"); + fullPath.append(QUrl::toPercentEncoding("password")) + .append("=") + .append(QUrl::toPercentEncoding(stringValue(password))); + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::loginUserCallback); + + worker->execute(&input); +} + +void +SWGUserApi::loginUserCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: QString* + + + + + + QString json(worker->response); + QString* output = new QString(&json); + + + + + worker->deleteLater(); + + emit loginUserSignal(output); + +} +void +SWGUserApi::logoutUser() { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/logout"); + + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::logoutUserCallback); + + worker->execute(&input); +} + +void +SWGUserApi::logoutUserCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit logoutUserSignal(); +} +void +SWGUserApi::getUserByName(QString* username) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/{username}"); + + + QString usernamePathParam("{"); usernamePathParam.append("username").append("}"); + fullPath.replace(usernamePathParam, stringValue(username)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "GET"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::getUserByNameCallback); + + worker->execute(&input); +} + +void +SWGUserApi::getUserByNameCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: SWGUser* + + + + + + QString json(worker->response); + SWGUser* output = new SWGUser(&json); + + + + + worker->deleteLater(); + + emit getUserByNameSignal(output); + +} +void +SWGUserApi::updateUser(QString* username, SWGUser body) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/{username}"); + + + QString usernamePathParam("{"); usernamePathParam.append("username").append("}"); + fullPath.replace(usernamePathParam, stringValue(username)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "PUT"); + + + // body + input.request_body.append(body.asJson()); + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::updateUserCallback); + + worker->execute(&input); +} + +void +SWGUserApi::updateUserCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit updateUserSignal(); +} +void +SWGUserApi::deleteUser(QString* username) { + QString fullPath; + fullPath.append(this->host).append(this->basePath).append("/user/{username}"); + + + QString usernamePathParam("{"); usernamePathParam.append("username").append("}"); + fullPath.replace(usernamePathParam, stringValue(username)); + + + + + // qDebug() << fullPath; + + HttpRequestWorker *worker = new HttpRequestWorker(); + HttpRequestInput input(fullPath, "DELETE"); + + + + + + connect(worker, + &HttpRequestWorker::on_execution_finished, + this, + &SWGUserApi::deleteUserCallback); + + worker->execute(&input); +} + +void +SWGUserApi::deleteUserCallback(HttpRequestWorker * worker) { + QString msg; + if (worker->error_type == QNetworkReply::NoError) { + msg = QString("Success! %1 bytes").arg(worker->response.length()); + } + else { + msg = "Error: " + worker->error_str; + } + + // return type: + + + + worker->deleteLater(); + + + emit deleteUserSignal(); +} +} /* namespace Swagger */ diff --git a/samples/client/petstore/qt5cpp/client/SWGUserApi.h b/samples/client/petstore/qt5cpp/client/SWGUserApi.h new file mode 100644 index 00000000000..cc6ed57bf34 --- /dev/null +++ b/samples/client/petstore/qt5cpp/client/SWGUserApi.h @@ -0,0 +1,56 @@ +#ifndef _SWG_SWGUserApi_H_ +#define _SWG_SWGUserApi_H_ + +#include "SWGHttpRequest.h" + +#include "SWGUser.h" +#include +#include + +#include + +namespace Swagger { + +class SWGUserApi: public QObject { + Q_OBJECT + +public: + SWGUserApi(); + SWGUserApi(QString host, QString basePath); + ~SWGUserApi(); + + QString host; + QString basePath; + + void createUser(SWGUser body); + void createUsersWithArrayInput(QList<SWGUser*>* body); + void createUsersWithListInput(QList<SWGUser*>* body); + void loginUser(QString* username, QString* password); + void logoutUser(); + void getUserByName(QString* username); + void updateUser(QString* username, SWGUser body); + void deleteUser(QString* username); + +private: + void createUserCallback (HttpRequestWorker * worker); + void createUsersWithArrayInputCallback (HttpRequestWorker * worker); + void createUsersWithListInputCallback (HttpRequestWorker * worker); + void loginUserCallback (HttpRequestWorker * worker); + void logoutUserCallback (HttpRequestWorker * worker); + void getUserByNameCallback (HttpRequestWorker * worker); + void updateUserCallback (HttpRequestWorker * worker); + void deleteUserCallback (HttpRequestWorker * worker); + +signals: + void createUserSignal(); + void createUsersWithArrayInputSignal(); + void createUsersWithListInputSignal(); + void loginUserSignal(QString* summary); + void logoutUserSignal(); + void getUserByNameSignal(SWGUser* summary); + void updateUserSignal(); + void deleteUserSignal(); + +}; +} +#endif \ No newline at end of file