void CommentableObjectViewer::onViewObject()
{
shared_ptr<ObjectsIRevisionable> object = getObject();
if(object == nullptr)
return;
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(getDocument()->create(object->getDescriptor()->getTypeName()), getPage(), XMLPortalExporter::emFull));
// Renderizza l'oggetto
renderObject(exporter, object);
// Renderizza i commenti sull'oggetto
renderPosts(exporter);
// Renderizza i tags dell'oggetto
renderTags(exporter);
}
void CommentableObjectViewer::renderPosts(shared_ptr<XMLPortalExporter> exporter)
{
if(getObject() == nullptr || getObject()->allowChild(portalObjectTypePost) == false)
return;
// Calcola il numero totale di posts
uint32 total_posts = getEntity()->getChildsCount(getDatabase(), portalObjectTypePost);
if(total_posts == 0)
return;
// Numero di posts da visualizzare per pagina
uint32 posts_to_show = getSkin()->getPagerItems();
// Inizializza l'offset di estrazione
uint32 offset = conversions::from_utf16<uint32>(getRequest()->getUrlParam(OS_URL_PARAM_OFFSET));
// Corregge l'offset se necessario
adjustOffset(total_posts, posts_to_show, offset);
objects_posts_list posts;
// Estrae le risposte nell'intervallo richiesto
shared_ptr<EntitiesEntities> post_childs = getEntity()->getChilds(getDatabase(), portalObjectTypePost, RangeUint32(offset, posts_to_show));
for(EntitiesEntities::iterator i = post_childs->begin(); i != post_childs->end(); ++i)
{
// Carica la riposta corrente
shared_ptr<EntitiesEntity> post_entity = post_childs->get(getDatabase(), *i);
if(post_entity != nullptr)
{
// Calcola la revisione corrente della risposta
shared_ptr<ObjectsPost> current_post = objects_post_cast(post_entity->getCurrent());
if(current_post != nullptr)
posts.push_back(current_post);
}
}
if(posts.empty() == false)
{
shared_ptr<XMLNode> posts_node = exporter->getNode(OS_PORTAL_OBJECT_POST_GROUPNAME);
for(objects_posts_list::const_iterator i = posts.begin(); i != posts.end(); ++i)
{
shared_ptr<XMLPortalExporter> postExporter(OS_NEW XMLPortalExporter(posts_node->addChild(OS_PORTAL_OBJECT_POST_TYPENAME), exporter->getPage(), exporter->getMode()));
renderPost(postExporter, *i);
}
}
createPager(getSkin(), exporter->getRoot(), total_posts, posts_to_show, offset);
}
void DocumentationViewer::onLoad()
{
ViewerBase::onLoad();
shared_ptr<XMLNode> root = getComponentDocument()->getRoot();
OS_ASSERT(root != nullptr);
shared_ptr<EntitiesEntity> entity = m_entity;
if(entity == nullptr)
entity = getEntity(getDatabase());
/* Defaults
String tocLayout = _S("right");
int32 tocMinTexts = 3;
int32 contentLevel = 1;
int32 subindexLevel = -1;
bool subindexShowTexts = true;
*/
String tocLayout = root->getAttributeString("toc_layout");
int32 tocMinTexts = root->getAttributeInt32("toc_mintexts");
int32 contentLevel = root->getAttributeInt32("content_level");
int32 subindexLevel = root->getAttributeInt32("subindex_level");
bool subindexShowTexts = root->getAttributeBool("subindex_showtexts");
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(getDocument()->create(_S("documentation")), getPage(), XMLPortalExporter::emFull));
exporter->setAttributeString("toc_layout", tocLayout);
exporter->setAttributeInt32("toc_mintexts", tocMinTexts);
exporter->setAttributeInt32("content_level", contentLevel);
exporter->setAttributeInt32("subindex_level", subindexLevel);
exporter->setAttributeBool("subindex_showtexts", subindexShowTexts);
shared_ptr<XMLPortalExporter> contentsExporter = exporter->createChild<XMLPortalExporter>(_S("contents"));
if(entity != nullptr)
_render(entity, contentsExporter, 0, contentLevel, true, true);
shared_ptr<XMLPortalExporter> subindexExporter = exporter->createChild<XMLPortalExporter>(_S("subindex"));
if(entity != nullptr)
_render(entity, subindexExporter, 0, subindexLevel, subindexShowTexts, false);
}
String OMLView::processHtml(shared_ptr<OMLItem> i, shared_ptr<OMLContext> context) const
{
if(context->checkPortalPageAvailable(i) == false)
return String::EMPTY;
shared_ptr<IPortalPage> page = context->getPortalPage();
if(page == nullptr) return String::EMPTY;
mapDefaultParamTo(i, _S("mode"));
String id = i->getHtmlChilds(context);
String mode = i->getParam(_S("mode"));
if(mode.empty())
{
mode = _S("row");
i->setParam(_S("mode"), mode);
}
if( (mode != _S("row")) && (mode != _S("lite")) && (mode != _S("full")) )
{
context->addWarning(String::format(_S("%S doesn't support the mode '%S'.").c_str(), context->getFriendlyName(i).c_str(), mode.c_str()));
return String::EMPTY;
}
shared_ptr<XMLDocument> doc = initDocument(i, context);
XMLPortalExporter::ExportMode exportMode = (mode != _S("row")) ? XMLPortalExporter::emFull : XMLPortalExporter::emLite;
bool withStats = (mode != _S("row"));
shared_ptr<XMLNode> nodeUser = doc->getRoot()->addChild(_S("object"));
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(nodeUser, page, exportMode, withStats));
shared_ptr<ObjectsIObject> object = page->getObject(id.to_ascii());
if(object != nullptr)
{
object->exportXML(exporter);
}
return processDocument(doc, i, context);
}
void ObjectDetail::onLoad()
{
PageBase::onLoad();
// Ottiene l'id dell'utente richiesto
EntityID id = getUrlID().to_ascii();
shared_ptr<XMLDocument> document(OS_NEW XMLDocument());
shared_ptr<XMLNode> nodeRoot = document->create(_S("object"));
shared_ptr<EntitiesEntity> entity = getPortal()->getEntity(getDatabase(), id);
if(entity != nullptr)
{
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(nodeRoot, get_this_ptr<IPortalPage>(), XMLPortalExporter::emFull, true));
entity->exportXML(exporter);
}
String path = getSkin()->getTemplatePath(_S("object_detail.xsl"));
shared_ptr<HtmlXSLControl> pageTemplate(OS_NEW HtmlXSLControl(loadStylesheet(path), document));
// Carica il template di riferimento
getControls()->add(pageTemplate);
}
void IdeTableQuery::onPreRender()
{
ControlBase::onPreRender();
shared_ptr<XMLDocument> document = getDocument();
shared_ptr<XMLNode> node_root = document->create(_S("table_query"));
DataTable result;
if(getPage()->getDatabase()->execute(m_sql,result))
{
shared_ptr<XMLNode> node_header = node_root->addChild(_S("header"));
for(uint32 c = 0; c < result.columns(); c++)
{
String columnTitle = getColumnTitle(c);
if(columnTitle.empty())
columnTitle = result.getColumnName(c);
shared_ptr<XMLNode> node_column = node_header->addChild(_S("column"));
node_column->setAttributeString(_S("name"), columnTitle);
switch(getColumnType(c))
{
case IdeTableQuery::ctString:
{
node_column->setAttributeString(_S("type"), _S("string"));
} break;
case IdeTableQuery::ctScore:
{
node_column->setAttributeString(_S("type"), _S("score"));
} break;
case IdeTableQuery::ctEntityID:
{
node_column->setAttributeString(_S("type"), _S("entity-id"));
} break;
case IdeTableQuery::ctObjectID:
{
node_column->setAttributeString(_S("type"), _S("object-id"));
} break;
case IdeTableQuery::ctUserID:
{
node_column->setAttributeString(_S("type"), _S("user-id"));
} break;
case IdeTableQuery::ctShortDateTime:
{
node_column->setAttributeString(_S("type"), _S("short-datetime"));
} break;
case IdeTableQuery::ctLongDateTime:
{
node_column->setAttributeString(_S("type"), _S("long-datetime"));
} break;
}
}
shared_ptr<XMLNode> node_data = node_root->addChild(_S("data"));
for(uint32 r=0;r<result.rows();r++)
{
shared_ptr<XMLNode> node_data_row = node_data->addChild(_S("row"));
for(uint32 c=0;c<result.columns();c++)
{
shared_ptr<XMLNode> node_data_row_item = node_data_row->addChild(_S("item"));
String value = result.get(r,c);
switch(getColumnType(c))
{
case IdeTableQuery::ctScore:
{
node_data_row_item->setAttributeString(_S("value"), String::format(_S("%1.1f").c_str(), double(result.get(r,c))));
} break;
case IdeTableQuery::ctEntityID:
{
// Sbagliata
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
if(object != nullptr)
{
object->exportXML(exporter);
}
} break;
case IdeTableQuery::ctObjectID:
{
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
if(object != nullptr)
{
object->exportXML(exporter);
}
} break;
case IdeTableQuery::ctUserID:
{
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
if(object != nullptr)
{
object->exportXML(exporter);
}
} break;
case IdeTableQuery::ctShortDateTime:
case IdeTableQuery::ctLongDateTime:
{
DateTime dt;
dt.fromString(value);
node_data_row_item->setAttributeDateTime(_S("value"), dt);
} break;
default:
{
node_data_row_item->setAttributeString(_S("value"), value);
} break;
}
}
}
}
}
void IdeMailBox::renderFolder(MessageFolder folder, shared_ptr<XMLNode> node)
{
getPortal()->getMessenger()->markNewMessagesAsUnread(getPage()->getDatabase(), getSessionAccount());
node->setAttributeString(_S("name"), DataLocalMessage::toString(folder));
// Calcola il numero totale di messaggi nel folder
uint32 total_messages = getPortal()->getMessenger()->getMessagesCount(getPage()->getDatabase(), getSessionAccount(), folder);
// Calcola il numero di messaggi da mostrare
uint32 messages_to_show = getSkin()->getPagerItems();
// Crea il pager dei messaggi se necessario
createPager(getSkin(), node, total_messages, messages_to_show, getOffset());
shared_ptr<XMLNode> node_messages;
DataLocalMessage::DataLocalMessageList messages;
RangeUint32 range(m_offset, messages_to_show);
// Estrae i messaggi nel folder corrente
if(getPortal()->getMessenger()->getMessages(getPage()->getDatabase(), getSessionAccount(), messages, folder, range))
{
for(DataLocalMessage::DataLocalMessageList::const_iterator i = messages.begin(); i != messages.end(); ++i)
{
shared_ptr<DataLocalMessage> local_message = *i;
shared_ptr<ObjectsMessage> message = local_message->decode(getSessionAccount()->getPrivateKey());
if(message != nullptr)
{
if(node_messages == nullptr)
node_messages = node->addChild(_S("messages"));
shared_ptr<XMLPortalExporter> messageExporter(OS_NEW XMLPortalExporter(node_messages->addChild(_S("message")), getPage(), XMLPortalExporter::emLite));
local_message->exportXML(messageExporter, message->subject, String::EMPTY, false);
}
}
}
shared_ptr<XMLNode> node_actions = node->addChild(_S("actions"));
switch(folder)
{
case messageFolderInbox: {
shared_ptr<XMLNode> actionReadAll = node_actions->addChild(_S("action"));
actionReadAll->setAttributeString(_S("name"), _S("readAllMessages"));
actionReadAll->setAttributeString(_S("href"), getEventCommand(EVENT_ONREADALLMESSAGES, conversions::to_utf16(folder)));
}
break;
case messageFolderTrash: {
shared_ptr<XMLNode> actionDeleteAll = node_actions->addChild(_S("action"));
actionDeleteAll->setAttributeString(_S("name"), _S("deleteAllMessages"));
actionDeleteAll->setAttributeString(_S("href"), getEventCommand(EVENT_ONDELETEALLMESSAGES, conversions::to_utf16(folder)));
}
break;
case messageFolderSentItems:
break;
default: OS_ASSERTFALSE();
break;
}
}
void IdeMailBox::renderMessage(const ObjectID &id, shared_ptr<XMLNode> node)
{
shared_ptr<ObjectsMessage> message;
shared_ptr<DataLocalMessage> local_message = getPortal()->getMessenger()->getMessage(getPage()->getDatabase(), getSessionAccount(), id, true);
if(local_message != nullptr)
{
// Decodifica il messaggio
message = local_message->decode(getSessionAccount()->getPrivateKey());
}
if(message == nullptr)
return;
shared_ptr<OMLContext> messageContext = getPage()->parseOmlEx(message->body, false, true, getSecure(), false, omlRenderModeOsiris, String::EMPTY, String::EMPTY);
if(messageContext == nullptr)
return;
shared_ptr<XMLPortalExporter> messageExporter(OS_NEW XMLPortalExporter(node, getPage(), XMLPortalExporter::emFull));
local_message->exportXML(messageExporter, message->subject, messageContext->getOutput(), messageContext->getSecureCheck());
shared_ptr<XMLNode> node_actions = node->addChild(_S("actions"));
shared_ptr<ObjectsUser> author = objects_user_cast(getPage()->getObject(local_message->author));
if(author != nullptr)
{
shared_ptr<XMLNode> action_reply = node_actions->addChild(_S("action"));
action_reply->setAttributeString(_S("name"), _S("reply"));
ordered_map<std::wstring, std::wstring> params;
params.set(OS_URL_PARAM_QUOTE, (_W("re: ") + message->subject).to_wide());
action_reply->setAttributeString(_S("href"), getPortal()->getSendMessageLink(author->id, params));
}
if(local_message->folder == static_cast<uint32>(messageFolderTrash))
{
shared_ptr<XMLNode> action_delete = node_actions->addChild(_S("action"));
action_delete->setAttributeString(_S("name"), _S("restore"));
action_delete->setAttributeString(_S("href"), getEventCommand(EVENT_ONRESTOREMESSAGE, id.toUTF16()));
}
else
{
shared_ptr<XMLNode> action_delete = node_actions->addChild(_S("action"));
action_delete->setAttributeString(_S("name"), _S("delete"));
action_delete->setAttributeString(_S("href"), getEventCommand(EVENT_ONDELETEMESSAGE, id.toUTF16()));
}
if(getSecure())
{
bool unsafe = messageContext->getSecureCheck() == false;
if(unsafe == false)
{
shared_ptr<ObjectsUser> messageAuthor = objects_user_cast(getPage()->getObject(local_message->author));
if(messageAuthor != nullptr)
{
shared_ptr<OMLContext> markContext = getPage()->parseOmlEx(messageAuthor->mark, false, true, getSecure(), false, omlRenderModeOsiris, String::EMPTY, String::EMPTY);
if(markContext != nullptr)
unsafe = markContext->getSecureCheck() == false;
}
}
if(unsafe)
{
shared_ptr<XMLNode> action_delete = node_actions->addChild(_S("action"));
action_delete->setAttributeString(_S("name"), _S("show"));
action_delete->setAttributeString(_S("href"), getPortal()->getPrivateMessageLink(id, false));
}
}
}
