dashboardStore.on('login_changed', function(user) {
if (user) {
riot.route('home');
} else {
riot.route('login');
}
});
hub.init = function(){
hub._parseRoute();
riot.route(hub._doRoute());
riot.route.start();
nextTick(riot.route.exec, 0);
function nextTick(fn){
setTimeout(fn, 0);
}
};
_init(){
if(!window.riot){
window.riot = riot;
}
this._parseRoute();
riot.route(this._doRoute());
riot.route.start(true);
riot.mixin({router: this.router.bind(this)});
}
self._urlify = function(questionPayload) {
var conversationIdComponent = questionPayload.conversationId + "/",
messagePayloadComponent = encodeURIComponent(questionPayload.message) + "/",
messageIdComponent = (questionPayload.messageId ? (questionPayload.messageId) : ""),
referrerComponent = (questionPayload.referrer ? questionPayload.referrer + "/" : "");
var routeTo = conversationIdComponent + messagePayloadComponent + messageIdComponent + referrerComponent;
riot.route(routeTo);
};
function recursiveHints(hints){
if(!hints.length || isBreak){
return;
}
let path = hints[0];
let request = {};
let {route, params} = me._getMetaDataFromRouteMap(path);
if(!route){
return recursiveHints(hints.slice(1));
}
let tag = route.tag;
isFounded = true;
request.params = params;
request.query = req.query;
let ctx = {
request
};
if(route.redirectTo){
isBreak = true;
return riot.route(route.redirectTo);
}
if(route.before){
route.before.apply(tag, [done, request]);
return;
}
done();
function done(){
if(hub.entry.middlewares.length){
return hub._execMiddleware(hub.entry.middlewares, {path, request}, next);
}
next();
function next(){
if(tag.hasOwnProperty('hidden')){
tag.one('ready', ()=>{
hub._routeTo(tag);
recursiveHints(hints.slice(1));
});
tag.trigger('open', ctx);
return;
}
recursiveHints(hints.slice(1));
}
}
}
var pageInit = function() {
riot.mount('login-modal');
riot.mount('header');
riot.mount('password-change');
riot.mount('div#uci-settings', 'input-settings', { sectionName: 'uci' });
riot.route('login');
var sessionUsername = localStorage.getItem('sessionUsername');
var sessionId = localStorage.getItem('sessionID');
var sessionExpiration = localStorage.getItem('sessionExpiration');
if (typeof sessionId === 'string' && typeof sessionExpiration === 'string') {
RiotControl.trigger('saved_session', {
id: sessionId,
expiration: sessionExpiration,
username: sessionUsername
});
}
};
var currentPage = null
var routes = {
home: (id, action) => {
var currentPage = Riot.mount('#view', 'people-index', { people: params.people });
},
people: function(id, action) {
switch (action) {
case 'detail':
var currentPage = Riot.mount('#view', 'people-detail', { person: params.people[id] });
}
}
};
function handler(collection, id, action) {
if (!Riot.mixin('peoplelistObservable')) {
Riot.mixin('peoplelistObservable', new PeoplelistObservable());
}
if (currentPage) {
currentPage.unmount(true)
}
var fn = routes[collection || 'home'];
return fn ? fn(id, action) : console.error('no route found : ', collection, id, action);
}
Riot.route(handler);
Riot.route.exec(handler);
function RoutingStore() {
riot.observable(this);
var self = this;
self._currentConversationId = null;
self._internalQuestionWasAsked = false;
/*
* Guarantees the question payload is valid, and not-malicious
* @param {String} (required)requestedConversationId : The ConversationId of the requested message.
* @param {String} (required)requestedMessageText : The message, or question, which will be sent to the server
* @param {String} (optional)requestedMessageId : The messageId which will try to be matched with a cached response
* @param {String} (optional)requestedFeedback : Feedback, whether we're passing a referral or not
* @returns {Object} URL in this format: {message : messagePayload, messageId :messageId, referrer : referrer}
*/
self._verifyQuestionPayload = function(requestedConversationId, requestedMessageText, requestedMessageId, requestedFeedback) {
var messagePayload = {};
messagePayload.conversationId = requestedConversationId;
messagePayload.message = decodeURIComponent(requestedMessageText);
if (requestedFeedback && requestedFeedback === constants.needHelpFeedbackType) {
messagePayload.referrer = requestedFeedback;
}
if (requestedMessageId) {
messagePayload.messageId = requestedMessageId;
}
return messagePayload;
};
/*
* Guarantees the url is properly formatted
* @param {Object} An object with: (required)conversationId, (required)message, (optional)messageId, (optional)referrer
* @returns {String} URL in this format: /conversationId[/messageId/messagePayload/referrer]
*/
self._urlify = function(questionPayload) {
var conversationIdComponent = questionPayload.conversationId + "/",
messagePayloadComponent = encodeURIComponent(questionPayload.message) + "/",
messageIdComponent = (questionPayload.messageId ? (questionPayload.messageId) : ""),
referrerComponent = (questionPayload.referrer ? questionPayload.referrer + "/" : "");
var routeTo = conversationIdComponent + messagePayloadComponent + messageIdComponent + referrerComponent;
riot.route(routeTo);
};
/*
* Routes to the home page
*/
self._goHome = function() {
riot.route("#");
self.trigger(routingAction.SHOW_HOME_PAGE_BROADCAST);
};
// Establish our main routing callback to handle the url resolution
riot.route(function(requestedConversationId, requestedMessageText, requestedMessageId, requestedFeedback) {
if (!requestedConversationId || !requestedMessageText || (requestedConversationId !== self._currentConversationId)) {
self._goHome();
}
if (requestedConversationId && requestedMessageText) {
// Verify all the payload properties before we potentially send them to a server
var currentMessagePayload = self._verifyQuestionPayload(requestedConversationId,
requestedMessageText,
requestedMessageId,
requestedFeedback);
// Only ask a question to the server if the user navigated here via the address bar
if (requestedFeedback !== constants.needHelpFeedbackType && !self._internalQuestionWasAsked) {
self.trigger(routingAction.ASK_QUESTION_BROADCAST, currentMessagePayload);
}
else if (requestedFeedback === constants.needHelpFeedbackType && !self._internalQuestionWasAsked) {
self.trigger(routingAction.STILL_NEED_HELP_BROADCAST, currentMessagePayload);
}
}
}.bind(self));
/*
* Updates the url with full question data
* @param {Object} An object with: (required)conversationId, (required)message, (optional)messageId, (optional)referrer
*/
self.on(routingAction.ANSWER_RECEIVED, function(questionPayload) {
// This is definitely from the server, so we can trust it's accurate
self._currentConversationId = questionPayload.conversationId;
// Build the routing string and update the browser URL
self._internalQuestionWasAsked = true;
self._urlify(questionPayload);
self._internalQuestionWasAsked = false;
});
/*
* Responds to an action notifying this store that a conversation has been started
* @param {String} The ID of the current conversation we need to route to
*/
self.on(routingAction.REFINEMENT_REQUESTED, function() {
self._internalQuestionWasAsked = true;
riot.route.exec(function(requestedConversationId, requestedMessageText, requestedMessageId) {
riot.route(requestedConversationId + "/" +
requestedMessageText + "/" +
requestedMessageId + "/" +
constants.needHelpFeedbackType);
}.bind(self));
self._internalQuestionWasAsked = false;
});
/*
* A request to show the home page with the current Conversation ID
*/
self.on(routingAction.SHOW_HOME_PAGE, function() {
self._goHome();
});
/*
* Parse the URL for the current messageId
*/
self.on(routingAction.GET_CURRENT_MESSAGEID, function(callback) {
riot.route.exec(function(requestedConversationId, requestedMessageText, requestedMessageId) {
callback(requestedMessageId);
self.trigger(routingAction.GET_CURRENT_MESSAGEID_BROADCAST, requestedMessageId);
}.bind(self));
});
}
self._goHome = function() {
riot.route("#");
self.trigger(routingAction.SHOW_HOME_PAGE_BROADCAST);
};
riot.route.exec(function(requestedConversationId, requestedMessageText, requestedMessageId) {
riot.route(requestedConversationId + "/" +
requestedMessageText + "/" +
requestedMessageId + "/" +
constants.needHelpFeedbackType);
}.bind(self));
return req => {
var me = this;
let isFounded = false;
let isBreak = false;
function recursiveHints(hints){
if(!hints.length || isBreak){
return;
}
let path = hints[0];
let request = {};
let {route, params} = me._getMetaDataFromRouteMap(path);
if(!route){
return recursiveHints(hints.slice(1));
}
let tag = route.tag;
isFounded = true;
request.params = params;
request.query = req.query;
let ctx = {
request
};
if(route.redirectTo){
isBreak = true;
return riot.route(route.redirectTo);
}
if(route.before){
route.before.apply(tag, [done, request]);
return;
}
done();
function done(){
if(hub.entry.middlewares.length){
return hub._execMiddleware(hub.entry.middlewares, {path, request}, next);
}
next();
function next(){
if(tag.hasOwnProperty('hidden')){
tag.one('ready', ()=>{
hub._routeTo(tag);
recursiveHints(hints.slice(1));
});
tag.trigger('open', ctx);
return;
}
recursiveHints(hints.slice(1));
}
}
}
recursiveHints(req.hints);
if(!isFounded){
try{
let url = hub.defaultRoute.path;
let paramsParts = url.match(/_[a-zA-Z0-9:]+/g);
if(paramsParts && paramsParts.length){
paramsParts.map(part=>{
let key = part.slice(2);
let value = hub.defaultRoute.defaultRoute.params
&& hub.defaultRoute.defaultRoute.params[key]
|| "";
url = url.replace(new RegExp('_:' + key + '+'), '_' + value);
});
}
riot.route('/' + url);
}catch(e){
console.warn(e);
console.info('404')
}
}
};
var createStoreWithMiddleware = redux.compose(
redux.applyMiddleware(thunk)
)(redux.createStore);
var reduxStore = createStoreWithMiddleware(reducer);
riot.route(function(collection,id,action){
if(collection == "contact"){
reduxStore.dispatch(layoutActions.createContactPage());
}
if(collection == "news"){
reduxStore.dispatch(layoutActions.createNewsPage());
}
if(collection == "faq"){
reduxStore.dispatch(layoutActions.createFaqPage());
}
if(collection == "products"){
reduxStore.dispatch(layoutActions.createProductsPage());
}
if(collection == "checkout"){
reduxStore.dispatch(layoutActions.createCheckOutPage());
}
if(!collection){
reduxStore.dispatch(layoutActions.createHomePage());
}
});
document.addEventListener('DOMContentLoaded', function(){
riot.compile(function() {
riot.mount('app-sidebar', {store:reduxStore});
riot.mount('app-main', {store:reduxStore});
riot.route.base('/#');
const riot = require('riot');
const RiotControl = require('riotcontrol');
global.jQuery = require('jquery');
var routeStore = require('./stores/route-store');
RiotControl.addStore(routeStore);
require('./tags/app.tag');
require('./tags/main-menu.tag');
require('./tags/about-us.tag');
require('./tags/navbar.tag');
riot.mount('app');
riot.route(function(a, b, c) {
RiotControl.trigger('route:change', {
collection: a,
id: b,
action: c
});
});
return post(this.opts.api, t).then((r) => {
if (!r.error) return route(redirect)
this.error = r.error
this.errors = r.error.errors || {}
this.update()
})
promise.then(function(authData) {
console.log('login', authData);
self.trigger('login_success');
riot.route(route);
}, function(error) {
params = {}
if (qs) {
qs.split('&').forEach(function(v) {
var c = v.split('=')
params[c[0]] = c[1]
})
}
uri.push(params)
return uri
});
riot.route(function(target, action, params) {
if (target === 'login') {
RiotControl.trigger('login_open');
}
});
dashboardStore.on('uci_configs_changed', function(configs) {
sections = [];
console.log(configs);
_.each(sectionConfigs, function(sectionConfig, sectionKey) {
var section = {
title: sectionConfig.title,
uciInputs: []
}
_.each(configs, function(uciSetting, uciSettingKey) {
_.each(sectionConfig.uciConfigs, function(uciConfig) {
if (uciConfig.section === uciSettingKey) {