Ошибка: undefined reference to при наследовании класса

#ifndef MYSERVICE_H
#define MYSERVICE_H
 
#include <Wt/Auth/OAuthService>
 
using namespace Wt;
using namespace Auth;
 
class MyService : public OAuthService
{
    public:
        MyService(const AuthService& baseAuthService);
 
        static bool configured();
        virtual std::string name() const;
        virtual WString description() const;
        virtual int popupWidth() const;
        virtual int popupHeight() const;
        virtual std::string authenticationScope() const;
        virtual std::string redirectEndpoint() const;
        virtual std::string redirectEndpointPath() const;
        virtual std::string authorizationEndpoint() const;
        virtual std::string tokenEndpoint() const;
        virtual std::string clientId() const;
        virtual std::string clientSecret() const;
        virtual Http::Method tokenRequestMethod() const;
        virtual OAuthProcess *createProcess(const std::string& scope) const;
};
 
#endif // MYSERVICE_H

#include "Wt/WApplication"
#include "Wt/Json/Object"
#include "Wt/Json/Parser"
#include "Wt/Http/Client"
 
#include "myservice.h"
 
using namespace Wt;
using namespace Auth;
 
#define ERROR_MSG(e) WString::tr("Wt.Auth.FacebookService." e)
 
namespace
{
    const char *RedirectEndpointProperty = "facebook-oauth2-redirect-endpoint";
    const char *RedirectEndpointPathProperty = "facebook-oauth2-redirect-endpoint-path";
    const char *ClientIdProperty = "facebook-oauth2-app-id";
    const char *ClientSecretProperty = "facebook-oauth2-app-secret";
    const char *AuthUrl = "https://www.facebook.com/dialog/oauth";
    const char *TokenUrl = "https://graph.facebook.com/oauth/access_token";
    const char *EmailScope = "email";
}
 
class MyProcess : public OAuthProcess
{
    public:
    MyProcess(const MyService& auth, const std::string& scope) : OAuthProcess(auth, scope)
    {
 
    }
    virtual void getIdentity(const OAuthAccessToken& token)
    {
        Http::Client *client = new Http::Client(this);
        client->setTimeout(15);
        client->setMaximumResponseSize(10*1024);
        client->done().connect(boost::bind(&MyProcess::handleMe, this, _1, _2));
        client->get("https://graph.facebook.com/me?access_token=" + token.value());
 
        #ifndef WT_TARGET_JAVA
            WApplication::instance()->deferRendering();
        #endif
    }
    private:
        void handleMe(boost::system::error_code err, const Http::Message& response)
        {
            #ifndef WT_TARGET_JAVA
                WApplication::instance()->resumeRendering();
            #endif
                if (!err && response.status() == 200)
                {
                    #ifndef WT_TARGET_JAVA
                        Json::ParseError e;
                        Json::Object me;
                        bool ok = Json::parse(response.body(), me, e);
                    #else
                        Json::Object me;
                        try
                        {
                            me = (Json::Object)Json::Parser().parse(response.body());
                        } catch (Json::ParseError pe) {}
                        bool ok = me.isNull();
                    #endif
 
                    if (!ok)
                    {
                        setError(ERROR_MSG("badjson"));
                        authenticated().emit(Identity::Invalid);
                    } else
                    {
                        std::string id = me.get("id");
                        WT_USTRING userName = me.get("name");
                        std::string email = me.get("email");
                        bool emailVerified = me.get("verified").orIfNull(false);
                        authenticated().emit(Identity(service().name(), id, userName, email, emailVerified));
                    }
                }
                else
                {
                    setError(ERROR_MSG("badresponse"));
                    authenticated().emit(Identity::Invalid);
                }
        }
};
MyService::MyService(const AuthService& baseAuth) : OAuthService(baseAuth)
{
 
}
bool MyService::configured()
{
    try
    {
        configurationProperty(RedirectEndpointProperty);
        configurationProperty(ClientIdProperty);
        configurationProperty(ClientSecretProperty);
        return true;
    } catch (const std::exception& e)
    {
        return false;
    }
}
std::string MyService::name() const
{
    return "facebook";
}
WString MyService::description() const
{
    return "Facebook Account";
}
std::string MyService::authenticationScope() const
{
    return EmailScope;
}
int MyService::popupWidth() const
{
    return 1000;
}
int MyService::popupHeight() const
{
    return 600;
}
std::string MyService::redirectEndpoint() const
{
    return configurationProperty(RedirectEndpointProperty);
}
std::string MyService::redirectEndpointPath() const
{
    try
    {
        return configurationProperty(RedirectEndpointPathProperty);
    } catch (const std::exception& e)
    {
        return OAuthService::redirectEndpointPath();
    }
}
std::string MyService::authorizationEndpoint() const
{
    return AuthUrl;
}
std::string MyService::tokenEndpoint() const
{
    return TokenUrl;
}
std::string MyService::clientId() const
{
    return configurationProperty(ClientIdProperty);
}
std::string MyService::clientSecret() const
{
    return configurationProperty(ClientSecretProperty);
}
Http::Method MyService::tokenRequestMethod() const
{
    return Http::Get;
}
OAuthProcess *MyService::createProcess(const std::string& scope) const
{
    return new MyProcess(*this, scope);
}

#include <Wt/WApplication>
#include <Wt/WContainerWidget>
#include <Wt/WImage>
#include <Wt/WServer>
#include <Wt/WText>
#include <Wt/WBreak>
 
#include <Wt/Auth/AuthService>
#include "myservice.h"
 
using namespace Wt;
using namespace Auth;
 
AuthService authService;
MyService *myService = 0;
 
class OAuthApplication : public WApplication
{
public:
  OAuthApplication(const WEnvironment& env): WApplication(env)
  {
    if ( !myService )
    {
      new WText("This example requires a Google Auth service configuration", root());
      return;
    }
 
    process_ = myService->createProcess( myService->authenticationScope() );
    WImage *ggi = new WImage("css/oauth-google.png", root());
    ggi->clicked().connect(process_,&OAuthProcess::startAuthenticate);
 
    process_->authenticated().connect(this, &OAuthApplication::authenticated);
  }
 
  void authenticated(const Identity& identity)
  {
    root()->clear();
    new WText("Name: " + identity.name(), root());
    new WBreak( root());
    new WText("Email: " + identity.email() , root());
  }
 
private:
  OAuthProcess* process_;
};
 
WApplication *createApplication(const WEnvironment& env)
{
  return new OAuthApplication(env);
}
 
int main(int argc, char **argv)
{
 
  try {
    WServer server(argv[0]);
 
    server.setServerConfiguration(argc, argv, WTHTTP_CONFIGURATION);
    server.addEntryPoint(Application, createApplication);
 
    if (MyService::configured()) {
      myService = new MyService(authService);
    }
 
    if (server.start()) {
      WServer::waitForShutdown();
      server.stop();
    }
  } catch (WServer::Exception& e) {
    std::cerr << e.what() << std::endl;
  } catch (std::exception &e) {
    std::cerr << "exception: " << e.what() << std::endl;
  }
}