InviteService.hpp

Go to the documentation of this file.

#ifndef _IDENTT_QUERY_INVITE_SERVICE_HPP_
#define _IDENTT_QUERY_INVITE_SERVICE_HPP_

#include <query/QueryBase.hpp>
#include <hrpc/HrpcClient.hpp>
#include <store/InviteService.hpp>
#include <store/AccessKeyService.hpp>

namespace identt {
namespace query {

template <class HttpServerT>
class InviteService : public identt::query::ServiceBase<HttpServerT> {
public:

    InviteService(
        identt::utils::SharedTable::pointer stptr,
        typename std::shared_ptr<HttpServerT> server,
        ::identt::query::HelpQuery::pointer helpquery,
        unsigned int scope)
        : identt::query::ServiceBase<HttpServerT>(IDENTT_SERVICE_SCOPE_HTTP | IDENTT_SERVICE_SCOPE_HTTPS)
    {
        if (!(this->myscope & scope)) return; // scope mismatch

        // Endpoint : POST _matrix/identity/api/v1/store-invite
        helpquery->add({scope,"POST _matrix/identity/api/v1/store-invite", {
                "An  identity  service can store pending invitations to a user’s 3pid, which will",
                "be retrieved and can be either notified on or look up when the 3pid is associated with a Matrix user ID.",
                "following URL encoded POST parameters:",
                " medium (string, required): The literal string email.",
                " address (string, required): The email address or msisdn of the invited user.",
                " room_id (string, required): The Matrix room ID to which the user is  invited.",
                " sender (string, required): The matrix user ID of the inviting user.",
                " accesskey (string, required): if invite_requires_accesskey is set."
                "An arbitrary number of other parameters may also be specified."
            }
        });

        server->resource["/_matrix/identity/api/v1/store-invite$"]["POST"]
        =[this,stptr](typename HttpServerT::RespPtr response, typename HttpServerT::ReqPtr request) {
            IDENTT_PARALLEL_ONE([this,stptr,response,request] {
                try {
                    LOG(INFO) << request->path;
                    std::string err;
                    bool use_json = this->JsonRequest(request);

                    identt::query::StoreInviteDataT inv;
                    if (use_json)
                    {
                        int stat = json2pb( request->content.string() , inv.mutable_invqry() , err);
                        if (stat<0) throw SydentException("Bad Json Format",M_BAD_JSON);
                    } else {
                        throw SydentException("Content-Type json only allowed",M_BAD_JSON);
                    }
                    if (!stptr->is_ready.Get()) throw identt::BadDataException("System Not Ready");

                    // action

                    // if accesskey is shared_secret it is server request, else check
                    if (stptr->invite_requires_key.Get()) {
                        bool is_server_query = false;
                        auto it=request->header.find("Shared-Secret");
                        if (it!=request->header.end()) {
                            is_server_query = (it->second == stptr->shared_secret.Get());
                        }
                        if (!is_server_query ) {
                            ::identt::store::AccessKeyService aservice;
                            aservice.VerifyAccessKeyAction(stptr, inv.mutable_invqry()->accesskey());
                        }
                    }

                    if (stptr->is_master.Get())
                    {
                        identt::store::InviteService storeinvite;
                        storeinvite.StoreInviteAction(stptr,&inv);
                    } else {
                        identt::hrpc::HrpcClient hclient;
                        hclient.SendToMaster(stptr,::identt::hrpc::M_STOREINVITE,&inv);
                    }

                    // aftermath
                    std::string output;
                    pb2json(inv.mutable_invres() , output);
                    this->HttpOKAction(response,request,200,"OK","application/json",output,true);
                } catch (SydentException& e)
                {
                    int ecode = (e.ecode()>=IDENTT_SYDENT_ERROR_MIN && e.ecode()<=IDENTT_SYDENT_ERROR_MAX) ? e.ecode() : M_UNKNOWN;
                    std::string output = err2json(SydentErrors.at(ecode),e.what());
                    this->HttpOKAction(response,request,200,"OK","application/json",output,true);
                } catch (identt::JdException& e)
                {
                    std::string output = err2json(SydentErrors.at(M_UNKNOWN),e.what());
                    this->HttpOKAction(response,request,200,"OK","application/json",output,true);
                } catch (std::exception& e)
                {
                    std::string output = err2json(SydentErrors.at(M_UNKNOWN),e.what());
                    this->HttpOKAction(response,request,200,"OK","application/json",output,true);
                } catch (...)
                {
                    this->HttpErrorAction(response,request,500,"INTERNAL SERVER ERROR");
                }
            });
        };
    }

private:

};
} // namespace query
} // namespace identt

#endif // _IDENTT_QUERY_INVITE_SERVICE_HPP_