/// POST: conversacion
RequestResult Request_POST_Conversacion(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
RequestResult ret;
auto qdict = parseQueryParams(qparams);
if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"])) {
ret.code = 401;
ret.data = "{\"error\": \"token invalido\" }";
}else{
const auto& r_user = qdict["r_user"];
const auto& t_user = uriparams;
auto js = JSONParse(body);
const auto& msg = js.get("mensaje", "").asString();
if(msg.length() == 0) {
ret.code = 401;
ret.data = "{ \"error\": \"mensaje invalido\" }";
}else if(!db->usuarioExists(t_user)){
ret.code = 401;
ret.data = "{ \"error\": \"usuario de destino invalido\" }";
}else if(!db->postearMensaje(r_user, t_user, msg)) {
ret.code = 500;
ret.data = "{ \"error\": \"error al postear mensaje\" }";
}else{
// Todo ok
ret.code = 201;
}
}
return ret;
}
JSCryptoKeySerializationJWK::JSCryptoKeySerializationJWK(ExecState* exec, const String& jsonString)
: m_exec(exec)
{
JSValue jsonValue = JSONParse(exec, jsonString);
if (exec->hadException())
return;
if (!jsonValue || !jsonValue.isObject()) {
throwTypeError(exec, "Invalid JWK serialization");
return;
}
m_json.set(m_exec->vm(), asObject(jsonValue));
}
JSValue JSXMLHttpRequest::response(ExecState* exec) const
{
switch (impl().responseTypeCode()) {
case XMLHttpRequest::ResponseTypeDefault:
case XMLHttpRequest::ResponseTypeText:
return responseText(exec);
case XMLHttpRequest::ResponseTypeJSON:
{
// FIXME: Use CachedAttribute for other types as well.
if (m_response && impl().responseCacheIsValid())
return m_response.get();
if (!impl().doneWithoutErrors())
return jsNull();
JSValue value = JSONParse(exec, impl().responseTextIgnoringResponseType());
if (!value)
value = jsNull();
JSXMLHttpRequest* jsRequest = const_cast<JSXMLHttpRequest*>(this);
jsRequest->m_response.set(exec->vm(), jsRequest, value);
impl().didCacheResponseJSON();
return value;
}
case XMLHttpRequest::ResponseTypeDocument:
{
ExceptionCode ec = 0;
Document* document = impl().responseXML(ec);
if (ec) {
setDOMException(exec, ec);
return jsUndefined();
}
return toJS(exec, globalObject(), document);
}
case XMLHttpRequest::ResponseTypeBlob:
return toJS(exec, globalObject(), impl().responseBlob());
case XMLHttpRequest::ResponseTypeArrayBuffer:
return toJS(exec, globalObject(), impl().responseArrayBuffer());
}
return jsUndefined();
}
JSValue JSXMLHttpRequest::retrieveResponse(ExecState& state)
{
auto type = wrapped().responseType();
switch (type) {
case XMLHttpRequest::ResponseType::EmptyString:
case XMLHttpRequest::ResponseType::Text:
return responseText(state);
default:
break;
}
if (!wrapped().doneWithoutErrors())
return jsNull();
JSValue value;
switch (type) {
case XMLHttpRequest::ResponseType::EmptyString:
case XMLHttpRequest::ResponseType::Text:
ASSERT_NOT_REACHED();
return jsUndefined();
case XMLHttpRequest::ResponseType::Json:
value = JSONParse(&state, wrapped().responseTextIgnoringResponseType());
if (!value)
value = jsNull();
break;
case XMLHttpRequest::ResponseType::Document: {
ExceptionCode ec = 0;
auto document = wrapped().responseXML(ec);
ASSERT(!ec);
value = toJS(&state, globalObject(), document);
break;
}
case XMLHttpRequest::ResponseType::Blob:
value = toJSNewlyCreated(&state, globalObject(), wrapped().createResponseBlob());
break;
case XMLHttpRequest::ResponseType::Arraybuffer:
value = toJS(&state, globalObject(), wrapped().createResponseArrayBuffer());
break;
}
wrapped().didCacheResponse();
return value;
}
JSValue JSXMLHttpRequest::response(ExecState& state) const
{
// FIXME: Use CachedAttribute for other types than JSON as well.
if (m_response && wrapped().responseCacheIsValid())
return m_response.get();
if (!wrapped().doneWithoutErrors() && wrapped().responseTypeCode() > XMLHttpRequest::ResponseTypeText)
return jsNull();
switch (wrapped().responseTypeCode()) {
case XMLHttpRequest::ResponseTypeDefault:
case XMLHttpRequest::ResponseTypeText:
return responseText(state);
case XMLHttpRequest::ResponseTypeJSON:
{
JSValue value = JSONParse(&state, wrapped().responseTextIgnoringResponseType());
if (!value)
value = jsNull();
m_response.set(state.vm(), this, value);
wrapped().didCacheResponseJSON();
return value;
}
case XMLHttpRequest::ResponseTypeDocument:
{
ExceptionCode ec = 0;
Document* document = wrapped().responseXML(ec);
if (ec) {
setDOMException(&state, ec);
return jsUndefined();
}
return toJS(&state, globalObject(), document);
}
case XMLHttpRequest::ResponseTypeBlob:
return toJS(&state, globalObject(), wrapped().responseBlob());
case XMLHttpRequest::ResponseTypeArrayBuffer:
return toJS(&state, globalObject(), wrapped().responseArrayBuffer());
}
return jsUndefined();
}
static std::error_code loadEncodedRules(ExecState& exec, const String& rules, Vector<ContentExtensionRule>& ruleList)
{
VM& vm = exec.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
// FIXME: JSONParse should require callbacks instead of an ExecState.
const JSValue decodedRules = JSONParse(&exec, rules);
if (scope.exception() || !decodedRules)
return ContentExtensionError::JSONInvalid;
if (!decodedRules.isObject())
return ContentExtensionError::JSONTopLevelStructureNotAnObject;
const JSObject* topLevelObject = decodedRules.toObject(&exec);
if (!topLevelObject || scope.exception())
return ContentExtensionError::JSONTopLevelStructureNotAnObject;
if (!isJSArray(topLevelObject))
return ContentExtensionError::JSONTopLevelStructureNotAnArray;
const JSArray* topLevelArray = jsCast<const JSArray*>(topLevelObject);
Vector<ContentExtensionRule> localRuleList;
unsigned length = topLevelArray->length();
const unsigned maxRuleCount = 50000;
if (length > maxRuleCount)
return ContentExtensionError::JSONTooManyRules;
for (unsigned i = 0; i < length; ++i) {
const JSValue value = topLevelArray->getIndex(&exec, i);
if (scope.exception() || !value)
return ContentExtensionError::JSONInvalidObjectInTopLevelArray;
const JSObject* ruleObject = value.toObject(&exec);
if (!ruleObject || scope.exception())
return ContentExtensionError::JSONInvalidRule;
auto error = loadRule(exec, *ruleObject, localRuleList);
if (error)
return error;
}
ruleList = WTFMove(localRuleList);
return { };
}
/// POST: /usuario
RequestResult Request_POST_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
RequestResult ret;
Usuario user;
// Parseamos el JSON para cargar los datos posteados
auto js = JSONParse(body);
user.load(js);
// Cargamos el usuario del uri
user.id = uriparams;
std::string err_str;
if(db->createUsuario(user, err_str)) {
ret.code = 201;
}else{
log.msg(LOG_TYPE::INFO, std::string("Error creando usuario `") + user.id + "`");
ret.code = 401;
ret.data = std::string("{ \"error\": \"") + err_str + "\" }";
}
return ret;
}
// Define all requests here
/// POST: /login
RequestResult Request_POST_Login(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
RequestResult ret;
// Parse and check credentials
auto js = JSONParse(body);
const std::string usr_id = js.get("id", "").asString();
const std::string pwd = js.get("password", "").asString();
Usuario usr;
if(db->loadUsuario(usr_id, usr) && usr.password == pwd) {
usr.last_action = std::time(nullptr);
usr.token = genToken();
db->saveUsuario(usr);
ret.data = std::string("{ \"token\": \"") + usr.token + usr.nombre + "\" }";
ret.code = 201;
}else{
ret.data = "{ \"error\": \"Usuario o clave invalidos\" }";
ret.code = 401;
}
return ret;
}
/// PUT: /usuario
RequestResult Request_PUT_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
RequestResult ret;
auto qdict = parseQueryParams(qparams);
Usuario usr;
// Debe pasar la clave tambien
if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"])) {
ret.code = 401;
ret.data = "{\"error\": \"token invalido\" }";
return ret;
}
if(uriparams != qdict["r_user"]) {
ret.code = 401;
ret.data = "{\"error\": \"permiso denegado\" }";
return ret;
}
if(!db->loadUsuario(uriparams, usr)) {
ret.code = 500;
ret.data = "{\"error\": \"error cargando usuario\" }";
return ret;
}
if(qdict["password"] != usr.password) {
ret.code = 401;
ret.data = "{\"error\": \"password invalido\" }";
return ret;
}
// Editamos los valores que nos pasaron (si los pasaron)
auto js = JSONParse(body);
usr.load(js);
// Guardamos el usuario
if(!db->saveUsuario(usr)) {
// TODO: desdoblar en los distintos
ret.code = 401;
ret.data = "{ \"error\": \"atributos invalidos\" }";
}else{
ret.code = 201;
}
return ret;
}
