void CPPClientStubGenerator::generateMethod(Procedure &proc)
{
string procsignature = TEMPLATE_CPPCLIENT_SIGMETHOD;
string returntype = CPPHelper::toCppType(proc.GetReturnType());
if (proc.GetProcedureType() == RPC_NOTIFICATION)
returntype = "void";
replaceAll2(procsignature, "<returntype>", returntype);
replaceAll2(procsignature, "<methodname>", CPPHelper::normalizeString(proc.GetProcedureName()));
replaceAll2(procsignature, "<parameters>", CPPHelper::generateParameterDeclarationList(proc));
cg.writeLine(procsignature);
cg.writeLine("{");
cg.increaseIndentation();
cg.writeLine("Json::Value p;");
generateAssignments(proc);
generateProcCall(proc);
cg.decreaseIndentation();
cg.writeLine("}");
}
void CPPClientStubGenerator::generateProcCall(Procedure &proc)
{
string call;
if (proc.GetProcedureType() == RPC_METHOD)
{
call = TEMPLATE_METHODCALL;
cg.writeLine(replaceAll(call, "<name>", proc.GetProcedureName()));
call = TEMPLATE_RETURNCHECK;
replaceAll2(call,"<cast>", CPPHelper::isCppConversion(proc.GetReturnType()));
cg.writeLine(call);
cg.increaseIndentation();
call = TEMPLATE_RETURN;
replaceAll2(call,"<cast>", CPPHelper::toCppConversion(proc.GetReturnType()));
cg.writeLine(call);
cg.decreaseIndentation();
cg.writeLine("else");
cg.increaseIndentation();
cg.writeLine("throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());");
cg.decreaseIndentation();
}
else
{
call = TEMPLATE_NOTIFICATIONCALL;
replaceAll2(call, "<name>", proc.GetProcedureName());
cg.writeLine(call);
}
}
void RpcProtocolServer::ProcessRequest(const Json::Value& request,
Json::Value& response)
{
Procedure* method = (*this->procedures)[request[KEY_REQUEST_METHODNAME].asString()];
Json::Value result;
if (method->GetProcedureType() == RPC_METHOD)
{
server->handleMethodCall(method, request[KEY_REQUEST_PARAMETERS],
result);
response[KEY_REQUEST_VERSION] = JSON_RPC_VERSION;
response[KEY_RESPONSE_RESULT] = result;
response[KEY_REQUEST_ID] = request[KEY_REQUEST_ID];
if (this->authManager != NULL)
{
this->authManager->ProcessAuthentication(
request[KEY_AUTHENTICATION],
response[KEY_AUTHENTICATION]);
}
}
else
{
server->handleNotificationCall(method, request[KEY_REQUEST_PARAMETERS]);
response = Json::Value::null;
}
}
int RpcProtocolServer::ValidateRequest(const Json::Value& request)
{
int error = 0;
Procedure* proc;
if (!(request.isMember(KEY_REQUEST_METHODNAME)
&& request.isMember(KEY_REQUEST_VERSION)
&& request.isMember(KEY_REQUEST_PARAMETERS)))
{
error = Errors::ERROR_RPC_INVALID_REQUEST;
}
else
{
map<string, Procedure*>::iterator it = procedures->find(request[KEY_REQUEST_METHODNAME].asString());
if (it != this->procedures->end())
{
proc = (*this->procedures)[request[KEY_REQUEST_METHODNAME].asString()];
if(request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_NOTIFICATION)
{
error = Errors::ERROR_SERVER_PROCEDURE_IS_NOTIFICATION;
}
else if(!request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_METHOD)
{
error = Errors::ERROR_SERVER_PROCEDURE_IS_METHOD;
}
else if (proc->ValdiateParameters(request[KEY_REQUEST_PARAMETERS]))
{
if (this->authManager != NULL)
{
error = this->authManager->CheckPermission(
request[KEY_AUTHENTICATION],
proc->GetProcedureName());
}
}
else
{
error = Errors::ERROR_RPC_INVALID_PARAMS;
}
}
else
{
error = Errors::ERROR_RPC_METHOD_NOT_FOUND;
}
}
return error;
}
void SpecificationWriter::procedureToJsonValue (const Procedure &procedure, Json::Value &target)
{
target[KEY_SPEC_PROCEDURE_NAME] = procedure.GetProcedureName();
if(procedure.GetProcedureType() == RPC_METHOD)
{
target[KEY_SPEC_RETURN_TYPE] = toJsonLiteral(procedure.GetReturnType());
}
for(parameterNameList_t::const_iterator it = procedure.GetParameters().begin(); it != procedure.GetParameters().end(); ++it)
{
if(procedure.GetParameterDeclarationType() == PARAMS_BY_NAME)
{
target[KEY_SPEC_PROCEDURE_PARAMETERS][it->first] = toJsonLiteral(it->second);
}
else
{
target[KEY_SPEC_PROCEDURE_PARAMETERS].append(toJsonLiteral(it->second));
}
}
}