[C++] [Restbed] Reworked Resource class names (#6017)

* - Added Restbed Generator

* - Added Json processing functions to model
- Removed unnused code from restbed codegen class
- Added response header processing to api template

* Changed it to respect alphabetical order

* Made the string joining java 7 compatible

* Added samples

* Started work on restbed improvment

* - Updated samples
- Reworked Resource class names
- Added vendor extension for new formatted resource class names

* fix indention
This commit is contained in:
stkrwork 2017-07-10 18:37:08 +02:00 committed by wing328
parent d522236cec
commit f2f303b2e8
9 changed files with 163 additions and 155 deletions

View File

@ -234,16 +234,24 @@ public class RestbedCodegen extends AbstractCppCodegen {
String path = new String(op.path);
String[] items = path.split("/", -1);
List<String> splitPath = new ArrayList<String>();
String resourceNameCamelCase = "";
op.path = "";
for (String item: items) {
if (item.matches("^\\{(.*)\\}$")) {
item = item.substring(0, item.length()-1);
item += ": .*}";
}
splitPath.add(item);
if (item.length() > 1) {
if (item.matches("^\\{(.*)\\}$")) {
String tmpResourceName = item.substring(1, item.length()-1);
resourceNameCamelCase += Character.toUpperCase(tmpResourceName.charAt(0)) + tmpResourceName.substring(1);
item = item.substring(0, item.length()-1);
item += ": .*}";
} else {
resourceNameCamelCase += Character.toUpperCase(item.charAt(0)) + item.substring(1);
}
} else if (item.length() == 1) {
resourceNameCamelCase += Character.toUpperCase(item.charAt(0));
}
op.path += item + "/";
}
op.vendorExtensions.put("x-codegen-resourceName", resourceNameCamelCase);
boolean foundInNewList = false;
for (CodegenOperation op1 : newOpList) {
if (!foundInNewList) {

View File

@ -40,11 +40,11 @@ public:
/// <remarks>
/// {{notes}}
/// </remarks>
class {{declspec}} {{classname}}{{operationIdCamelCase}}Resource: public restbed::Resource
class {{declspec}} {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource: public restbed::Resource
{
public:
{{classname}}{{operationIdCamelCase}}Resource();
virtual ~{{classname}}{{operationIdCamelCase}}Resource();
{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource();
virtual ~{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource();
void {{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session);
{{#vendorExtensions.x-codegen-otherMethods}}
void {{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session);

View File

@ -16,8 +16,8 @@ using namespace {{modelNamespace}};
{{classname}}::{{classname}}() {
{{#operation}}
std::shared_ptr<{{classname}}{{operationIdCamelCase}}Resource> sp{{classname}}{{operationIdCamelCase}}Resource = std::make_shared<{{classname}}{{operationIdCamelCase}}Resource>();
this->publish(sp{{classname}}{{operationIdCamelCase}}Resource);
std::shared_ptr<{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource> sp{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource = std::make_shared<{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource>();
this->publish(sp{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource);
{{/operation}}
}
@ -37,24 +37,24 @@ void {{classname}}::stopService() {
}
{{#operation}}
{{classname}}{{operationIdCamelCase}}Resource::{{classname}}{{operationIdCamelCase}}Resource()
{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource()
{
this->set_path("{{path}}");
this->set_method_handler("{{httpMethod}}",
std::bind(&{{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler, this,
std::bind(&{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler, this,
std::placeholders::_1));
{{#vendorExtensions.x-codegen-otherMethods}}
this->set_method_handler("{{httpMethod}}",
std::bind(&{{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler, this,
std::bind(&{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler, this,
std::placeholders::_1));
{{/vendorExtensions.x-codegen-otherMethods}}
}
{{classname}}{{operationIdCamelCase}}Resource::~{{classname}}{{operationIdCamelCase}}Resource()
{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::~{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource()
{
}
void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
void {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
{{#hasBodyParam}}
@ -122,7 +122,7 @@ void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handle
}
{{#vendorExtensions.x-codegen-otherMethods}}
void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
void {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
{{#hasBodyParam}}

View File

@ -26,20 +26,20 @@ namespace api {
using namespace io::swagger::server::model;
PetApi::PetApi() {
std::shared_ptr<PetApiAddPetResource> spPetApiAddPetResource = std::make_shared<PetApiAddPetResource>();
this->publish(spPetApiAddPetResource);
std::shared_ptr<PetApiPetResource> spPetApiPetResource = std::make_shared<PetApiPetResource>();
this->publish(spPetApiPetResource);
std::shared_ptr<PetApiDeletePetResource> spPetApiDeletePetResource = std::make_shared<PetApiDeletePetResource>();
this->publish(spPetApiDeletePetResource);
std::shared_ptr<PetApiPetPetIdResource> spPetApiPetPetIdResource = std::make_shared<PetApiPetPetIdResource>();
this->publish(spPetApiPetPetIdResource);
std::shared_ptr<PetApiFindPetsByStatusResource> spPetApiFindPetsByStatusResource = std::make_shared<PetApiFindPetsByStatusResource>();
this->publish(spPetApiFindPetsByStatusResource);
std::shared_ptr<PetApiPetFindByStatusResource> spPetApiPetFindByStatusResource = std::make_shared<PetApiPetFindByStatusResource>();
this->publish(spPetApiPetFindByStatusResource);
std::shared_ptr<PetApiFindPetsByTagsResource> spPetApiFindPetsByTagsResource = std::make_shared<PetApiFindPetsByTagsResource>();
this->publish(spPetApiFindPetsByTagsResource);
std::shared_ptr<PetApiPetFindByTagsResource> spPetApiPetFindByTagsResource = std::make_shared<PetApiPetFindByTagsResource>();
this->publish(spPetApiPetFindByTagsResource);
std::shared_ptr<PetApiUploadFileResource> spPetApiUploadFileResource = std::make_shared<PetApiUploadFileResource>();
this->publish(spPetApiUploadFileResource);
std::shared_ptr<PetApiPetPetIdUploadImageResource> spPetApiPetPetIdUploadImageResource = std::make_shared<PetApiPetPetIdUploadImageResource>();
this->publish(spPetApiPetPetIdUploadImageResource);
}
@ -57,22 +57,22 @@ void PetApi::stopService() {
this->stop();
}
PetApiAddPetResource::PetApiAddPetResource()
PetApiPetResource::PetApiPetResource()
{
this->set_path("/pet/");
this->set_method_handler("POST",
std::bind(&PetApiAddPetResource::POST_method_handler, this,
std::bind(&PetApiPetResource::POST_method_handler, this,
std::placeholders::_1));
this->set_method_handler("PUT",
std::bind(&PetApiAddPetResource::PUT_method_handler, this,
std::bind(&PetApiPetResource::PUT_method_handler, this,
std::placeholders::_1));
}
PetApiAddPetResource::~PetApiAddPetResource()
PetApiPetResource::~PetApiPetResource()
{
}
void PetApiAddPetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -105,7 +105,7 @@ void PetApiAddPetResource::POST_method_handler(const std::shared_ptr<restbed::Se
});
}
void PetApiAddPetResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -144,25 +144,25 @@ void PetApiAddPetResource::PUT_method_handler(const std::shared_ptr<restbed::Ses
}
PetApiDeletePetResource::PetApiDeletePetResource()
PetApiPetPetIdResource::PetApiPetPetIdResource()
{
this->set_path("/pet/{petId: .*}/");
this->set_method_handler("DELETE",
std::bind(&PetApiDeletePetResource::DELETE_method_handler, this,
std::bind(&PetApiPetPetIdResource::DELETE_method_handler, this,
std::placeholders::_1));
this->set_method_handler("GET",
std::bind(&PetApiDeletePetResource::GET_method_handler, this,
std::bind(&PetApiPetPetIdResource::GET_method_handler, this,
std::placeholders::_1));
this->set_method_handler("POST",
std::bind(&PetApiDeletePetResource::POST_method_handler, this,
std::bind(&PetApiPetPetIdResource::POST_method_handler, this,
std::placeholders::_1));
}
PetApiDeletePetResource::~PetApiDeletePetResource()
PetApiPetPetIdResource::~PetApiPetPetIdResource()
{
}
void PetApiDeletePetResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetPetIdResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -187,7 +187,7 @@ void PetApiDeletePetResource::DELETE_method_handler(const std::shared_ptr<restbe
}
void PetApiDeletePetResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetPetIdResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -218,7 +218,7 @@ void PetApiDeletePetResource::GET_method_handler(const std::shared_ptr<restbed::
}
}
void PetApiDeletePetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetPetIdResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -242,19 +242,19 @@ void PetApiDeletePetResource::POST_method_handler(const std::shared_ptr<restbed:
}
PetApiFindPetsByStatusResource::PetApiFindPetsByStatusResource()
PetApiPetFindByStatusResource::PetApiPetFindByStatusResource()
{
this->set_path("/pet/findByStatus/");
this->set_method_handler("GET",
std::bind(&PetApiFindPetsByStatusResource::GET_method_handler, this,
std::bind(&PetApiPetFindByStatusResource::GET_method_handler, this,
std::placeholders::_1));
}
PetApiFindPetsByStatusResource::~PetApiFindPetsByStatusResource()
PetApiPetFindByStatusResource::~PetApiPetFindByStatusResource()
{
}
void PetApiFindPetsByStatusResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetFindByStatusResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -282,19 +282,19 @@ void PetApiFindPetsByStatusResource::GET_method_handler(const std::shared_ptr<re
PetApiFindPetsByTagsResource::PetApiFindPetsByTagsResource()
PetApiPetFindByTagsResource::PetApiPetFindByTagsResource()
{
this->set_path("/pet/findByTags/");
this->set_method_handler("GET",
std::bind(&PetApiFindPetsByTagsResource::GET_method_handler, this,
std::bind(&PetApiPetFindByTagsResource::GET_method_handler, this,
std::placeholders::_1));
}
PetApiFindPetsByTagsResource::~PetApiFindPetsByTagsResource()
PetApiPetFindByTagsResource::~PetApiPetFindByTagsResource()
{
}
void PetApiFindPetsByTagsResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetFindByTagsResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -322,19 +322,19 @@ void PetApiFindPetsByTagsResource::GET_method_handler(const std::shared_ptr<rest
PetApiUploadFileResource::PetApiUploadFileResource()
PetApiPetPetIdUploadImageResource::PetApiPetPetIdUploadImageResource()
{
this->set_path("/pet/{petId: .*}/uploadImage/");
this->set_method_handler("POST",
std::bind(&PetApiUploadFileResource::POST_method_handler, this,
std::bind(&PetApiPetPetIdUploadImageResource::POST_method_handler, this,
std::placeholders::_1));
}
PetApiUploadFileResource::~PetApiUploadFileResource()
PetApiPetPetIdUploadImageResource::~PetApiPetPetIdUploadImageResource()
{
}
void PetApiUploadFileResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void PetApiPetPetIdUploadImageResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();

View File

@ -52,11 +52,11 @@ public:
/// <remarks>
///
/// </remarks>
class PetApiAddPetResource: public restbed::Resource
class PetApiPetResource: public restbed::Resource
{
public:
PetApiAddPetResource();
virtual ~PetApiAddPetResource();
PetApiPetResource();
virtual ~PetApiPetResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
void PUT_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -67,11 +67,11 @@ public:
/// <remarks>
///
/// </remarks>
class PetApiDeletePetResource: public restbed::Resource
class PetApiPetPetIdResource: public restbed::Resource
{
public:
PetApiDeletePetResource();
virtual ~PetApiDeletePetResource();
PetApiPetPetIdResource();
virtual ~PetApiPetPetIdResource();
void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
@ -83,11 +83,11 @@ public:
/// <remarks>
/// Multiple status values can be provided with comma separated strings
/// </remarks>
class PetApiFindPetsByStatusResource: public restbed::Resource
class PetApiPetFindByStatusResource: public restbed::Resource
{
public:
PetApiFindPetsByStatusResource();
virtual ~PetApiFindPetsByStatusResource();
PetApiPetFindByStatusResource();
virtual ~PetApiPetFindByStatusResource();
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -97,11 +97,11 @@ public:
/// <remarks>
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
/// </remarks>
class PetApiFindPetsByTagsResource: public restbed::Resource
class PetApiPetFindByTagsResource: public restbed::Resource
{
public:
PetApiFindPetsByTagsResource();
virtual ~PetApiFindPetsByTagsResource();
PetApiPetFindByTagsResource();
virtual ~PetApiPetFindByTagsResource();
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -111,11 +111,11 @@ public:
/// <remarks>
///
/// </remarks>
class PetApiUploadFileResource: public restbed::Resource
class PetApiPetPetIdUploadImageResource: public restbed::Resource
{
public:
PetApiUploadFileResource();
virtual ~PetApiUploadFileResource();
PetApiPetPetIdUploadImageResource();
virtual ~PetApiPetPetIdUploadImageResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
};

View File

@ -26,14 +26,14 @@ namespace api {
using namespace io::swagger::server::model;
StoreApi::StoreApi() {
std::shared_ptr<StoreApiDeleteOrderResource> spStoreApiDeleteOrderResource = std::make_shared<StoreApiDeleteOrderResource>();
this->publish(spStoreApiDeleteOrderResource);
std::shared_ptr<StoreApiStoreOrderOrderIdResource> spStoreApiStoreOrderOrderIdResource = std::make_shared<StoreApiStoreOrderOrderIdResource>();
this->publish(spStoreApiStoreOrderOrderIdResource);
std::shared_ptr<StoreApiGetInventoryResource> spStoreApiGetInventoryResource = std::make_shared<StoreApiGetInventoryResource>();
this->publish(spStoreApiGetInventoryResource);
std::shared_ptr<StoreApiStoreInventoryResource> spStoreApiStoreInventoryResource = std::make_shared<StoreApiStoreInventoryResource>();
this->publish(spStoreApiStoreInventoryResource);
std::shared_ptr<StoreApiPlaceOrderResource> spStoreApiPlaceOrderResource = std::make_shared<StoreApiPlaceOrderResource>();
this->publish(spStoreApiPlaceOrderResource);
std::shared_ptr<StoreApiStoreOrderResource> spStoreApiStoreOrderResource = std::make_shared<StoreApiStoreOrderResource>();
this->publish(spStoreApiStoreOrderResource);
}
@ -51,22 +51,22 @@ void StoreApi::stopService() {
this->stop();
}
StoreApiDeleteOrderResource::StoreApiDeleteOrderResource()
StoreApiStoreOrderOrderIdResource::StoreApiStoreOrderOrderIdResource()
{
this->set_path("/store/order/{orderId: .*}/");
this->set_method_handler("DELETE",
std::bind(&StoreApiDeleteOrderResource::DELETE_method_handler, this,
std::bind(&StoreApiStoreOrderOrderIdResource::DELETE_method_handler, this,
std::placeholders::_1));
this->set_method_handler("GET",
std::bind(&StoreApiDeleteOrderResource::GET_method_handler, this,
std::bind(&StoreApiStoreOrderOrderIdResource::GET_method_handler, this,
std::placeholders::_1));
}
StoreApiDeleteOrderResource::~StoreApiDeleteOrderResource()
StoreApiStoreOrderOrderIdResource::~StoreApiStoreOrderOrderIdResource()
{
}
void StoreApiDeleteOrderResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
void StoreApiStoreOrderOrderIdResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -93,7 +93,7 @@ void StoreApiDeleteOrderResource::DELETE_method_handler(const std::shared_ptr<re
}
void StoreApiDeleteOrderResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void StoreApiStoreOrderOrderIdResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -126,19 +126,19 @@ void StoreApiDeleteOrderResource::GET_method_handler(const std::shared_ptr<restb
}
StoreApiGetInventoryResource::StoreApiGetInventoryResource()
StoreApiStoreInventoryResource::StoreApiStoreInventoryResource()
{
this->set_path("/store/inventory/");
this->set_method_handler("GET",
std::bind(&StoreApiGetInventoryResource::GET_method_handler, this,
std::bind(&StoreApiStoreInventoryResource::GET_method_handler, this,
std::placeholders::_1));
}
StoreApiGetInventoryResource::~StoreApiGetInventoryResource()
StoreApiStoreInventoryResource::~StoreApiStoreInventoryResource()
{
}
void StoreApiGetInventoryResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void StoreApiStoreInventoryResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -161,19 +161,19 @@ void StoreApiGetInventoryResource::GET_method_handler(const std::shared_ptr<rest
StoreApiPlaceOrderResource::StoreApiPlaceOrderResource()
StoreApiStoreOrderResource::StoreApiStoreOrderResource()
{
this->set_path("/store/order/");
this->set_method_handler("POST",
std::bind(&StoreApiPlaceOrderResource::POST_method_handler, this,
std::bind(&StoreApiStoreOrderResource::POST_method_handler, this,
std::placeholders::_1));
}
StoreApiPlaceOrderResource::~StoreApiPlaceOrderResource()
StoreApiStoreOrderResource::~StoreApiStoreOrderResource()
{
}
void StoreApiPlaceOrderResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void StoreApiStoreOrderResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them

View File

@ -52,11 +52,11 @@ public:
/// <remarks>
/// For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
/// </remarks>
class StoreApiDeleteOrderResource: public restbed::Resource
class StoreApiStoreOrderOrderIdResource: public restbed::Resource
{
public:
StoreApiDeleteOrderResource();
virtual ~StoreApiDeleteOrderResource();
StoreApiStoreOrderOrderIdResource();
virtual ~StoreApiStoreOrderOrderIdResource();
void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -67,11 +67,11 @@ public:
/// <remarks>
/// Returns a map of status codes to quantities
/// </remarks>
class StoreApiGetInventoryResource: public restbed::Resource
class StoreApiStoreInventoryResource: public restbed::Resource
{
public:
StoreApiGetInventoryResource();
virtual ~StoreApiGetInventoryResource();
StoreApiStoreInventoryResource();
virtual ~StoreApiStoreInventoryResource();
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -81,11 +81,11 @@ public:
/// <remarks>
///
/// </remarks>
class StoreApiPlaceOrderResource: public restbed::Resource
class StoreApiStoreOrderResource: public restbed::Resource
{
public:
StoreApiPlaceOrderResource();
virtual ~StoreApiPlaceOrderResource();
StoreApiStoreOrderResource();
virtual ~StoreApiStoreOrderResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
};

View File

@ -26,23 +26,23 @@ namespace api {
using namespace io::swagger::server::model;
UserApi::UserApi() {
std::shared_ptr<UserApiCreateUserResource> spUserApiCreateUserResource = std::make_shared<UserApiCreateUserResource>();
this->publish(spUserApiCreateUserResource);
std::shared_ptr<UserApiUserResource> spUserApiUserResource = std::make_shared<UserApiUserResource>();
this->publish(spUserApiUserResource);
std::shared_ptr<UserApiCreateUsersWithArrayInputResource> spUserApiCreateUsersWithArrayInputResource = std::make_shared<UserApiCreateUsersWithArrayInputResource>();
this->publish(spUserApiCreateUsersWithArrayInputResource);
std::shared_ptr<UserApiUserCreateWithArrayResource> spUserApiUserCreateWithArrayResource = std::make_shared<UserApiUserCreateWithArrayResource>();
this->publish(spUserApiUserCreateWithArrayResource);
std::shared_ptr<UserApiCreateUsersWithListInputResource> spUserApiCreateUsersWithListInputResource = std::make_shared<UserApiCreateUsersWithListInputResource>();
this->publish(spUserApiCreateUsersWithListInputResource);
std::shared_ptr<UserApiUserCreateWithListResource> spUserApiUserCreateWithListResource = std::make_shared<UserApiUserCreateWithListResource>();
this->publish(spUserApiUserCreateWithListResource);
std::shared_ptr<UserApiDeleteUserResource> spUserApiDeleteUserResource = std::make_shared<UserApiDeleteUserResource>();
this->publish(spUserApiDeleteUserResource);
std::shared_ptr<UserApiUserUsernameResource> spUserApiUserUsernameResource = std::make_shared<UserApiUserUsernameResource>();
this->publish(spUserApiUserUsernameResource);
std::shared_ptr<UserApiLoginUserResource> spUserApiLoginUserResource = std::make_shared<UserApiLoginUserResource>();
this->publish(spUserApiLoginUserResource);
std::shared_ptr<UserApiUserLoginResource> spUserApiUserLoginResource = std::make_shared<UserApiUserLoginResource>();
this->publish(spUserApiUserLoginResource);
std::shared_ptr<UserApiLogoutUserResource> spUserApiLogoutUserResource = std::make_shared<UserApiLogoutUserResource>();
this->publish(spUserApiLogoutUserResource);
std::shared_ptr<UserApiUserLogoutResource> spUserApiUserLogoutResource = std::make_shared<UserApiUserLogoutResource>();
this->publish(spUserApiUserLogoutResource);
}
@ -60,19 +60,19 @@ void UserApi::stopService() {
this->stop();
}
UserApiCreateUserResource::UserApiCreateUserResource()
UserApiUserResource::UserApiUserResource()
{
this->set_path("/user/");
this->set_method_handler("POST",
std::bind(&UserApiCreateUserResource::POST_method_handler, this,
std::bind(&UserApiUserResource::POST_method_handler, this,
std::placeholders::_1));
}
UserApiCreateUserResource::~UserApiCreateUserResource()
UserApiUserResource::~UserApiUserResource()
{
}
void UserApiCreateUserResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -107,19 +107,19 @@ void UserApiCreateUserResource::POST_method_handler(const std::shared_ptr<restbe
UserApiCreateUsersWithArrayInputResource::UserApiCreateUsersWithArrayInputResource()
UserApiUserCreateWithArrayResource::UserApiUserCreateWithArrayResource()
{
this->set_path("/user/createWithArray/");
this->set_method_handler("POST",
std::bind(&UserApiCreateUsersWithArrayInputResource::POST_method_handler, this,
std::bind(&UserApiUserCreateWithArrayResource::POST_method_handler, this,
std::placeholders::_1));
}
UserApiCreateUsersWithArrayInputResource::~UserApiCreateUsersWithArrayInputResource()
UserApiUserCreateWithArrayResource::~UserApiUserCreateWithArrayResource()
{
}
void UserApiCreateUsersWithArrayInputResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserCreateWithArrayResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -154,19 +154,19 @@ void UserApiCreateUsersWithArrayInputResource::POST_method_handler(const std::sh
UserApiCreateUsersWithListInputResource::UserApiCreateUsersWithListInputResource()
UserApiUserCreateWithListResource::UserApiUserCreateWithListResource()
{
this->set_path("/user/createWithList/");
this->set_method_handler("POST",
std::bind(&UserApiCreateUsersWithListInputResource::POST_method_handler, this,
std::bind(&UserApiUserCreateWithListResource::POST_method_handler, this,
std::placeholders::_1));
}
UserApiCreateUsersWithListInputResource::~UserApiCreateUsersWithListInputResource()
UserApiUserCreateWithListResource::~UserApiUserCreateWithListResource()
{
}
void UserApiCreateUsersWithListInputResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserCreateWithListResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -201,25 +201,25 @@ void UserApiCreateUsersWithListInputResource::POST_method_handler(const std::sha
UserApiDeleteUserResource::UserApiDeleteUserResource()
UserApiUserUsernameResource::UserApiUserUsernameResource()
{
this->set_path("/user/{username: .*}/");
this->set_method_handler("DELETE",
std::bind(&UserApiDeleteUserResource::DELETE_method_handler, this,
std::bind(&UserApiUserUsernameResource::DELETE_method_handler, this,
std::placeholders::_1));
this->set_method_handler("GET",
std::bind(&UserApiDeleteUserResource::GET_method_handler, this,
std::bind(&UserApiUserUsernameResource::GET_method_handler, this,
std::placeholders::_1));
this->set_method_handler("PUT",
std::bind(&UserApiDeleteUserResource::PUT_method_handler, this,
std::bind(&UserApiUserUsernameResource::PUT_method_handler, this,
std::placeholders::_1));
}
UserApiDeleteUserResource::~UserApiDeleteUserResource()
UserApiUserUsernameResource::~UserApiUserUsernameResource()
{
}
void UserApiDeleteUserResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserUsernameResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -246,7 +246,7 @@ void UserApiDeleteUserResource::DELETE_method_handler(const std::shared_ptr<rest
}
void UserApiDeleteUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserUsernameResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -277,7 +277,7 @@ void UserApiDeleteUserResource::GET_method_handler(const std::shared_ptr<restbed
}
}
void UserApiDeleteUserResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserUsernameResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
// Body params are present, therefore we have to fetch them
@ -314,19 +314,19 @@ void UserApiDeleteUserResource::PUT_method_handler(const std::shared_ptr<restbed
}
UserApiLoginUserResource::UserApiLoginUserResource()
UserApiUserLoginResource::UserApiUserLoginResource()
{
this->set_path("/user/login/");
this->set_method_handler("GET",
std::bind(&UserApiLoginUserResource::GET_method_handler, this,
std::bind(&UserApiUserLoginResource::GET_method_handler, this,
std::placeholders::_1));
}
UserApiLoginUserResource::~UserApiLoginUserResource()
UserApiUserLoginResource::~UserApiUserLoginResource()
{
}
void UserApiLoginUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserLoginResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();
@ -360,19 +360,19 @@ void UserApiLoginUserResource::GET_method_handler(const std::shared_ptr<restbed:
UserApiLogoutUserResource::UserApiLogoutUserResource()
UserApiUserLogoutResource::UserApiUserLogoutResource()
{
this->set_path("/user/logout/");
this->set_method_handler("GET",
std::bind(&UserApiLogoutUserResource::GET_method_handler, this,
std::bind(&UserApiUserLogoutResource::GET_method_handler, this,
std::placeholders::_1));
}
UserApiLogoutUserResource::~UserApiLogoutUserResource()
UserApiUserLogoutResource::~UserApiUserLogoutResource()
{
}
void UserApiLogoutUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
void UserApiUserLogoutResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
const auto request = session->get_request();

View File

@ -52,11 +52,11 @@ public:
/// <remarks>
/// This can only be done by the logged in user.
/// </remarks>
class UserApiCreateUserResource: public restbed::Resource
class UserApiUserResource: public restbed::Resource
{
public:
UserApiCreateUserResource();
virtual ~UserApiCreateUserResource();
UserApiUserResource();
virtual ~UserApiUserResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -66,11 +66,11 @@ public:
/// <remarks>
///
/// </remarks>
class UserApiCreateUsersWithArrayInputResource: public restbed::Resource
class UserApiUserCreateWithArrayResource: public restbed::Resource
{
public:
UserApiCreateUsersWithArrayInputResource();
virtual ~UserApiCreateUsersWithArrayInputResource();
UserApiUserCreateWithArrayResource();
virtual ~UserApiUserCreateWithArrayResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -80,11 +80,11 @@ public:
/// <remarks>
///
/// </remarks>
class UserApiCreateUsersWithListInputResource: public restbed::Resource
class UserApiUserCreateWithListResource: public restbed::Resource
{
public:
UserApiCreateUsersWithListInputResource();
virtual ~UserApiCreateUsersWithListInputResource();
UserApiUserCreateWithListResource();
virtual ~UserApiUserCreateWithListResource();
void POST_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -94,11 +94,11 @@ public:
/// <remarks>
/// This can only be done by the logged in user.
/// </remarks>
class UserApiDeleteUserResource: public restbed::Resource
class UserApiUserUsernameResource: public restbed::Resource
{
public:
UserApiDeleteUserResource();
virtual ~UserApiDeleteUserResource();
UserApiUserUsernameResource();
virtual ~UserApiUserUsernameResource();
void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
void PUT_method_handler(const std::shared_ptr<restbed::Session> session);
@ -110,11 +110,11 @@ public:
/// <remarks>
///
/// </remarks>
class UserApiLoginUserResource: public restbed::Resource
class UserApiUserLoginResource: public restbed::Resource
{
public:
UserApiLoginUserResource();
virtual ~UserApiLoginUserResource();
UserApiUserLoginResource();
virtual ~UserApiUserLoginResource();
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};
@ -124,11 +124,11 @@ public:
/// <remarks>
///
/// </remarks>
class UserApiLogoutUserResource: public restbed::Resource
class UserApiUserLogoutResource: public restbed::Resource
{
public:
UserApiLogoutUserResource();
virtual ~UserApiLogoutUserResource();
UserApiUserLogoutResource();
virtual ~UserApiUserLogoutResource();
void GET_method_handler(const std::shared_ptr<restbed::Session> session);
};