MailSmsService.hpp

Go to the documentation of this file.

#ifndef _IDENTT_QUERY_MAILSMS_SERVICE_HPP_
#define _IDENTT_QUERY_MAILSMS_SERVICE_HPP_

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

namespace identt {
namespace query {

template <class HttpServerT>
class MailSmsService :
    public identt::query::ServiceBase<HttpServerT>,
    public identt::store::MailSmsService {
public:

    MailSmsService(
        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 _identt/identity/api/v1/getmailstosend
        helpquery->add({scope,"POST _identt/identity/api/v1/getmailstosend", {
                "params  :  lastid, limit, payload[] ",
                "Needs shared secret in header.",
                "This will fetch the mail/sms that need sending.",
                "If request payload contains items marked done they will be marked deleted",
                "This is to be used only by an internal program"
            }
        });

        server->resource["/_identt/identity/api/v1/getmailstosend$"]["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::mail::MailQueryT mailq;
                    if (use_json)
                    {
                        int stat = json2pb( request->content.string() , &mailq , err);
                        if (stat<0) throw SydentException("Bad Json Format",M_BAD_JSON);
                    } else {
                        form2pb( request->content.string() , &mailq); // throws on error
                    }
                    if (!stptr->is_ready.Get()) throw identt::BadDataException("System Not Ready");

                    // check shared secret
                    auto it=request->header.find("Shared-Secret");
                    if (it==request->header.end())
                        throw identt::BadDataException("No Header Shared Secret");
                    if (it->second != stptr->shared_secret.Get())
                        throw identt::BadDataException("Bad Shared Secret");
                    mailq.set_shared_secret(it->second);

                    ::identt::store::MailSmsService mservice;
                    // action
                    if (stptr->is_master.Get())
                    {
                        mservice.PendingAction(stptr, &mailq);
                    } else {
                        identt::hrpc::HrpcClient hclient;
                        hclient.SendToMaster(stptr,::identt::hrpc::M_PENDING,&mailq);
                    }

                    mailq.clear_shared_secret();

                    // aftermath
                    std::string output;
                    pb2json(&mailq , 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_MAILSMS_SERVICE_HPP_