{{>licenseInfo}}
{{#models}}{{#model}}

#include "{{classname}}.h"

{{#modelNamespaceDeclarations}}
namespace {{this}} {
{{/modelNamespaceDeclarations}}

{{classname}}::{{classname}}()
{
    {{#vars}}
    {{^isInherited}}
    {{#isNotContainer}}
    {{#isPrimitiveType}}
    m_{{name}} = {{{defaultValue}}};
    {{/isPrimitiveType}}
    {{^isPrimitiveType}}
    {{#isString}}
    m_{{name}} = {{{defaultValue}}};
    {{/isString}}
    {{#isDateTime}}
    m_{{name}} = {{{defaultValue}}};
    {{/isDateTime}}
    {{/isPrimitiveType}}
    {{/isNotContainer}}
    {{^required}}
    m_{{name}}IsSet = false;
    {{/required}}
    {{/isInherited}}
    {{/vars}}
}

{{classname}}::~{{classname}}()
{
}

void {{classname}}::validate()
{
    // TODO: implement validation
}

web::json::value {{classname}}::toJson() const
{
    {{#parent}}
    web::json::value val = this->{{{parent}}}::toJson();
    {{/parent}}
    {{^parent}}
    web::json::value val = web::json::value::object();
    {{/parent}}

    {{#vars}}
    {{^isInherited}}
    {{#isPrimitiveType}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^required}}
    if(m_{{name}}IsSet)
    {
        val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
    }
    {{/required}}
    {{#required}}
    val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
    {{/required}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/isPrimitiveType}}
    {{#isListContainer}}
    {
        std::vector<web::json::value> jsonArray;
        for( auto& item : m_{{name}} )
        {
            jsonArray.push_back(ModelBase::toJson(item));
        }
        {{#required}}
        val[U("{{baseName}}")] = web::json::value::array(jsonArray);
        {{/required}}
        {{^required}}
        if(jsonArray.size() > 0)
        {
            val[U("{{baseName}}")] = web::json::value::array(jsonArray);
        }
        {{/required}}
    }
    {{/isListContainer}}
    {{#isMapContainer}}
    {
        std::vector<web::json::value> jsonArray;
        for( auto& item : m_{{name}} )
        {
            web::json::value tmp = web::json::value::object();
            tmp[U("key")] = ModelBase::toJson(item.first);
            tmp[U("value")] = ModelBase::toJson(item.second);
            jsonArray.push_back(tmp);
        }
        {{#required}}
        val[U("{{baseName}}")] = web::json::value::array(jsonArray);
        {{/required}}
        {{^required}}
        if(jsonArray.size() > 0)
        {
            val[U("{{baseName}}")] = web::json::value::array(jsonArray);
        }
        {{/required}}
    }
    {{/isMapContainer}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^isPrimitiveType}}
    {{^required}}
    if(m_{{name}}IsSet)
    {
        val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
    }
    {{/required}}
    {{#required}}
    val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
    {{/required}}
    {{/isPrimitiveType}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/isInherited}}
    {{/vars}}

    return val;
}

void {{classname}}::fromJson(web::json::value& val)
{
    {{#parent}}
    this->{{{parent}}}::fromJson(val);

    {{/parent}}
    {{#vars}}
    {{^isInherited}}
    {{#isPrimitiveType}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^required}}
    if(val.has_field(U("{{baseName}}")))
    {
        {{setter}}(ModelBase::{{baseType}}FromJson(val[U("{{baseName}}")]));
    }
    {{/required}}
    {{#required}}
    {{setter}}(ModelBase::{{baseType}}FromJson(val[U("{{baseName}}")]));
    {{/required}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/isPrimitiveType}}
    {{#isListContainer}}
    {
        m_{{name}}.clear();
        std::vector<web::json::value> jsonArray;
        {{^required}}
        if(val.has_field(U("{{baseName}}")))
        {
        {{/required}}
        for( auto& item : val[U("{{baseName}}")].as_array() )
        {
            {{#items.isPrimitiveType}}
            m_{{name}}.push_back(ModelBase::{{items.baseType}}FromJson(item));
            {{/items.isPrimitiveType}}
            {{^items.isPrimitiveType}}
            {{#items.isString}}
            m_{{name}}.push_back(ModelBase::stringFromJson(item));
            {{/items.isString}}
            {{^items.isString}}
            {{#items.isDateTime}}
            m_{{name}}.push_back(ModelBase::dateFromJson(item));
            {{/items.isDateTime}}
            {{^items.isDateTime}}
            if(item.is_null())
            {
                m_{{name}}.push_back( {{{items.datatype}}}(nullptr) );
            }
            else
            {
                {{{items.datatype}}} newItem({{{items.defaultValue}}});
                newItem->fromJson(item);
                m_{{name}}.push_back( newItem );
            }
            {{/items.isDateTime}}
            {{/items.isString}}
            {{/items.isPrimitiveType}}
        }
        {{^required}}
        }
        {{/required}}
    }
    {{/isListContainer}}
    {{#isMapContainer}}
    {
        m_{{name}}.clear();
        std::vector<web::json::value> jsonArray;
        {{^required}}
        if(val.has_field(U("{{baseName}}")))
        {
        {{/required}}
        for( auto& item : val[U("{{baseName}}")].as_array() )
        {  
            utility::string_t key;
            if(item.has_field(U("key")))
            {
                key = ModelBase::stringFromJson(item[U("key")]);
            }
            {{#items.isPrimitiveType}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::{{items.baseType}}FromJson(item[U("value")])));
            {{/items.isPrimitiveType}}
            {{^items.isPrimitiveType}}
            {{#items.isString}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::stringFromJson(item[U("value")])));
            {{/items.isString}}
            {{^items.isString}}
            {{#items.isDateTime}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::dateFromJson(item[U("value")])));
            {{/items.isDateTime}}
            {{^items.isDateTime}}
            if(item.is_null())
            {
                m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, {{{items.datatype}}}(nullptr) ));
            }
            else
            {
                {{{items.datatype}}} newItem({{{items.defaultValue}}});
                newItem->fromJson(item[U("value")]);
                m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, newItem ));
            }
            {{/items.isDateTime}}
            {{/items.isString}}
            {{/items.isPrimitiveType}}
        }
        {{^required}}
        }
        {{/required}}
    }
    {{/isMapContainer}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^isPrimitiveType}}
    {{^required}}
    if(val.has_field(U("{{baseName}}")))
    {
        {{#isString}}
        {{setter}}(ModelBase::stringFromJson(val[U("{{baseName}}")]));
        {{/isString}}
        {{^isString}}
        {{#isDateTime}}
        {{setter}}(ModelBase::dateFromJson(val[U("{{baseName}}")]));
        {{/isDateTime}}
        {{^isDateTime}}
        if(!val[U("{{baseName}}")].is_null())
        {
            {{{datatype}}} newItem({{{defaultValue}}});
            newItem->fromJson(val[U("{{baseName}}")]);
            {{setter}}( newItem );
        }
        {{/isDateTime}}
        {{/isString}}
    }
    {{/required}}
    {{#required}}
    {{#isString}}
    {{setter}}(ModelBase::stringFromJson(val[U("{{baseName}}")]));
    {{/isString}}
    {{^isString}}
    {{#isDateTime}}
    {{setter}}
    (ModelBase::dateFromJson(val[U("{{baseName}}")]));
    {{/isDateTime}}
    {{^isDateTime}}
    {{#vendorExtensions.x-codegen-file}}
    {{setter}}(ModelBase::fileFromJson(val[U("{{baseName}}")]));
    {{/vendorExtensions.x-codegen-file}}
    {{^vendorExtensions.x-codegen-file}}
    {{{datatype}}} new{{name}}({{{defaultValue}}});
    new{{name}}->fromJson(val[U("{{baseName}}")]);
    {{setter}}( new{{name}} );
    {{/vendorExtensions.x-codegen-file}}
    {{/isDateTime}}
    {{/isString}}
    {{/required}}
    {{/isPrimitiveType}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/isInherited}}
    {{/vars}}
}

void {{classname}}::toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix) const
{
    utility::string_t namePrefix = prefix;
    if(namePrefix.size() > 0 && namePrefix[namePrefix.size() - 1] != U('.'))
    {
        namePrefix += U(".");
    }

    {{#vars}}
    {{#isPrimitiveType}}
    {{^isMapContainer}}
    {{^isListContainer}}
    {{^required}}
    if(m_{{name}}IsSet)
    {
        multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
    }
    {{/required}}
    {{#required}}
    multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
    {{/required}}
    {{/isListContainer}}
    {{/isMapContainer}}
    {{/isPrimitiveType}}
    {{#isListContainer}}
    {
        std::vector<web::json::value> jsonArray;
        for( auto& item : m_{{name}} )
        {
            jsonArray.push_back(ModelBase::toJson(item));
        }
        {{#required}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
        {{/required}}{{^required}}
        if(jsonArray.size() > 0)
        {
            multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
        }
        {{/required}}
    }
    {{/isListContainer}}
    {{#isMapContainer}}
    {
        std::vector<web::json::value> jsonArray;
        for( auto& item : m_{{name}} )
        {
            web::json::value tmp = web::json::value::object();
            tmp[U("key")] = ModelBase::toJson(item.first);
            tmp[U("value")] = ModelBase::toJson(item.second);
            jsonArray.push_back(tmp);
        }
        {{#required}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
        {{/required}}{{^required}}
        if(jsonArray.size() > 0)
        {
            multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
        }
        {{/required}}
    }
    {{/isMapContainer}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^isPrimitiveType}}
    {{^required}}
    if(m_{{name}}IsSet)
    {
        {{#isString}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
        {{/isString}}{{^isString}}{{#isDateTime}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
        {{/isDateTime}}{{^isDateTime}}if (m_{{name}}.get())
        {
            m_{{name}}->toMultipart(multipart, U("{{baseName}}."));
        }
        {{/isDateTime}}{{/isString}}
    }
    {{/required}}
    {{#required}}
    {{#isString}}
    multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
    {{/isString}}
    {{^isString}}
    {{#isDateTime}}
    multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
    {{/isDateTime}}
    {{^isDateTime}}
    {{#vendorExtensions.x-codegen-file}}
    multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
    {{/vendorExtensions.x-codegen-file}}
    {{^vendorExtensions.x-codegen-file}}
    m_{{name}}->toMultipart(multipart, U("{{baseName}}."));
    {{/vendorExtensions.x-codegen-file}}
    {{/isDateTime}}
    {{/isString}}
    {{/required}}
    {{/isPrimitiveType}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/vars}}
}

void {{classname}}::fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix)
{
    utility::string_t namePrefix = prefix;
    if(namePrefix.size() > 0 && namePrefix[namePrefix.size() - 1] != U('.'))
    {
        namePrefix += U(".");
    }

    {{#vars}}
    {{#isPrimitiveType}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^required}}
    if(multipart->hasContent(U("{{baseName}}")))
    {
        {{setter}}(ModelBase::{{baseType}}FromHttpContent(multipart->getContent(U("{{baseName}}"))));
    }
    {{/required}}
    {{#required}}
    {{setter}}(ModelBase::{{baseType}}FromHttpContent(multipart->getContent(U("{{baseName}}"))));
    {{/required}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/isPrimitiveType}}
    {{#isListContainer}}
    {
        m_{{name}}.clear();
        {{^required}}
        if(multipart->hasContent(U("{{baseName}}")))
        {
        {{/required}}

        web::json::value jsonArray = web::json::value::parse(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
        for( auto& item : jsonArray.as_array() )
        {
            {{#isPrimitiveType}}
            m_{{name}}.push_back(ModelBase::{{items.baseType}}FromJson(item));
            {{/isPrimitiveType}}
            {{^isPrimitiveType}}
            {{#items.isString}}
            m_{{name}}.push_back(ModelBase::stringFromJson(item));
            {{/items.isString}}
            {{^items.isString}}
            {{#items.isDateTime}}
            m_{{name}}.push_back(ModelBase::dateFromJson(item));
            {{/items.isDateTime}}
            {{^items.isDateTime}}
            if(item.is_null())
            {
                m_{{name}}.push_back( {{{items.datatype}}}(nullptr) );
            }
            else
            {
                {{{items.datatype}}} newItem({{{items.defaultValue}}});
                newItem->fromJson(item);
                m_{{name}}.push_back( newItem );
            }
            {{/items.isDateTime}}
            {{/items.isString}}
            {{/isPrimitiveType}}
        }
        {{^required}}
        }
        {{/required}}
    }
    {{/isListContainer}}
    {{#isMapContainer}}
    {
        m_{{name}}.clear();
        {{^required}}
        if(multipart->hasContent(U("{{baseName}}")))
        {
        {{/required}}

        web::json::value jsonArray = web::json::value::parse(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
        for( auto& item : jsonArray.as_array() )
        {
            utility::string_t key;
            if(item.has_field(U("key")))
            {
                key = ModelBase::stringFromJson(item[U("key")]);
            }
            {{#items.isPrimitiveType}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::{{items.baseType}}FromJson(item[U("value")])));
            {{/items.isPrimitiveType}}
            {{^items.isPrimitiveType}}
            {{#items.isString}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::stringFromJson(item[U("value")])));
            {{/items.isString}}
            {{^items.isString}}
            {{#items.isDateTime}}
            m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::dateFromJson(item[U("value")])));
            {{/items.isDateTime}}
            {{^items.isDateTime}}
            if(item.is_null())
            {
                m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, {{{items.datatype}}}(nullptr) ));
            }
            else
            {
                {{{items.datatype}}} newItem({{{items.defaultValue}}});
                newItem->fromJson(item[U("value")]);
                m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, newItem ));
            }
            {{/items.isDateTime}}
            {{/items.isString}}
            {{/items.isPrimitiveType}}
        }
        {{^required}}
        }
        {{/required}}
    }
    {{/isMapContainer}}
    {{^isListContainer}}
    {{^isMapContainer}}
    {{^isPrimitiveType}}
    {{^required}}
    if(multipart->hasContent(U("{{baseName}}")))
    {
        {{#isString}}
        {{setter}}(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
        {{/isString}}
        {{^isString}}
        {{#isDateTime}}
        {{setter}}(ModelBase::dateFromHttpContent(multipart->getContent(U("{{baseName}}"))));
        {{/isDateTime}}
        {{^isDateTime}}
        if(multipart->hasContent(U("{{baseName}}")))
        {
            {{{datatype}}} newItem({{{defaultValue}}});
            newItem->fromMultiPart(multipart, U("{{baseName}}."));
            {{setter}}( newItem );
        }
        {{/isDateTime}}
        {{/isString}}
    }
    {{/required}}
    {{#required}}
    {{#isString}}
    {{setter}}(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
    {{/isString}}
    {{^isString}}
    {{#isDateTime}}
    {{setter}}(ModelBase::dateFromHttpContent(multipart->getContent(U("{{baseName}}"))));
    {{/isDateTime}}
    {{^isDateTime}}
    {{#vendorExtensions.x-codegen-file}}
    {{setter}}(multipart->getContent(U("{{baseName}}")));
    {{/vendorExtensions.x-codegen-file}}
    {{^vendorExtensions.x-codegen-file}}
    {{{datatype}}} new{{name}}({{{defaultValue}}});
    new{{name}}->fromMultiPart(multipart, U("{{baseName}}."));
    {{setter}}( new{{name}} );
    {{/vendorExtensions.x-codegen-file}}
    {{/isDateTime}}
    {{/isString}}
    {{/required}}
    {{/isPrimitiveType}}
    {{/isMapContainer}}
    {{/isListContainer}}
    {{/vars}}
}

{{#vars}}
{{^isInherited}}
{{^isNotContainer}}
{{{datatype}}}& {{classname}}::{{getter}}()
{
    return m_{{name}};
}

void {{classname}}::{{setter}}({{{datatype}}} value)
{
    m_{{name}} = value;
    {{^required}}m_{{name}}IsSet = true;{{/required}}
}
{{/isNotContainer}}
{{#isNotContainer}}
{{{datatype}}} {{classname}}::{{getter}}() const
{
    return m_{{name}};
}


void {{classname}}::{{setter}}({{{datatype}}} value)
{
    m_{{name}} = value;
    {{^required}}m_{{name}}IsSet = true;{{/required}}
}
{{/isNotContainer}}
{{^required}}
bool {{classname}}::{{baseName}}IsSet() const
{
    return m_{{name}}IsSet;
}

void {{classname}}::unset{{name}}()
{
    m_{{name}}IsSet = false;
}

{{/required}}
{{/isInherited}}
{{/vars}}
{{#modelNamespaceDeclarations}}
}
{{/modelNamespaceDeclarations}}

{{/model}}
{{/models}}