WordPress.org
Get WordPress

Plugin Directory

Changeset 1669808


Ignore:
Timestamp:
06/02/2017 06:56:08 PM (9 years ago)
Author:
sckmkny
Message:

fighting folder

Location:
futusign/trunk
Files:
60 added
15 deleted
31 edited

Legend:

Unmodified
Added
Removed

  • futusign/trunk/admin/class-futusign-admin.php

    r1637139 r1669808  
    2727    public function __construct() {
    2828    }
     29    /**
     30     * Render Currently Playing Metabox for Screen
     31     *
     32     * @since    2.2.0
     33     */
     34    public function render_screen_playing( $post ) {
     35        ?>
     36        <div id="root"></div>
     37
     38        <script>
     39            window.siteUrl = "<?php echo trailingslashit( site_url() );?>";
     40            window.screenId = <?php echo $post->ID; ?>;
     41            window.priority = <?php echo class_exists( 'Futusign_Priority' ) ? 'true' : 'false'; ?>;
     42        </script>
     43        <?php
     44    }
     45    /**
     46     * Add Currently Playing Metabox for Screen
     47     *
     48     * @since    2.2.0
     49     */
     50    public function add_meta_boxes_futusign_screen() {
     51        $screen = get_current_screen();
     52        if ( 'add' !== $screen->action ) {
     53            add_meta_box(
     54                'futusign_screen_playing',
     55                __( 'Currently Playing', 'futusign'),
     56                array($this, 'render_screen_playing'),
     57                'futusign_screen',
     58                'normal',
     59                'default'
     60        );
     61        }
     62    }
     63    /**
     64     * Enqueue Admin Scripts for Screen
     65     *
     66     * @since    2.2.0
     67     * @param    string     $hook_suffix      The page.
     68     */
     69    public function admin_enqueue_scripts ( $hook_suffix ) {
     70        $cpt = 'futusign_screen';
     71        if( in_array( $hook_suffix, array( 'post.php' ) ) ){
     72            $screen = get_current_screen();
     73            if( is_object( $screen ) && $cpt == $screen->post_type ){
     74                wp_register_script('futusign_admin_screen',
     75                    plugin_dir_url( __FILE__ ) . 'screen/dist/main.bundle.js',
     76                    array(),
     77                    '2017053101', true
     78                );
     79                wp_enqueue_script('futusign_admin_screen');
     80            }
     81        }
     82    }
    2983}

  • futusign/trunk/common/class-futusign-common.php

    r1653754 r1669808  
    113113        return $this->image;
    114114    }
     115    // DUPLICATED IN INACTIVE
     116    /**
     117     * Add rewrite rules
     118     *
     119     * @since    2.1.2
     120     */
     121    public function add_rewrite_rules() {
     122        add_rewrite_rule( '^fs-endpoint/?', 'index.php?futusign_endpoint=1', 'top' );
     123    }
    115124}

  • futusign/trunk/common/class-futusign-screen.php

    r1651645 r1669808  
    235235          )
    236236        ),
     237                array (
     238                    'key' => 'field_acf_fs_sc_polling',
     239                    'label' => __('Polling Cycle', 'futusign'),
     240                    'name' => 'polling',
     241                    'type' => 'number',
     242                    'instructions' => esc_html__('The number of minutes between polling for updates', 'futusign'),
     243                    'required' => 1,
     244                    'default_value' => 60,
     245                    'placeholder' => '',
     246                    'prepend' => '',
     247                    'append' => '',
     248                    'min' => 1,
     249                    'max' => '',
     250                    'step' => 1,
     251                ),
    237252      ),
    238253      'location' => array (

  • futusign/trunk/futusign.php

    r1665899 r1669808  
    1111 * Plugin URI:       https://github.com/larkintuckerllc/futusign
    1212 * Description:      Manage and display digital signage content
    13  * Version:          2.1.1
     13 * Version:          2.2.0
    1414 * Author:           John Tucker
    1515 * Author URI:       https://github.com/larkintuckerllc

  • futusign/trunk/inactive/class-futusign-inactive.php

    r1637139 r1669808  
    2727    public function __construct() {
    2828    }
     29    // DUPLICATED IN COMMON
     30    /**
     31     * Add rewrite rules
     32     *
     33     * @since    2.1.2
     34     */
     35    public function add_rewrite_rules() {
     36        add_rewrite_rule( '^fs-endpoint/?', 'index.php?futusign_endpoint=1', 'top' );
     37    }
    2938    /**
    3039     * Display missing plugin dependency notices.
    … …  
    3342     */
    3443    public function missing_plugins_notice() {
    35         if ( ! Futusign::is_plugin_active( 'acf-to-rest-api' ) ) {
    36             include plugin_dir_path( __FILE__ ) . 'partials/futusign-missing-acf-to-rest-api.php';
     44        if ( ! Futusign::is_plugin_active( 'acf' ) ) {
     45            include plugin_dir_path( __FILE__ ) . 'partials/futusign-missing-acf.php';
    3746        }
    3847    }

  • futusign/trunk/includes/class-futusign-activator.php

    r1637139 r1669808  
    2828     */
    2929    public static function activate() {
     30        // ENDPOINT
     31        require_once plugin_dir_path( dirname( __FILE__ ) ) . 'inactive/class-futusign-inactive.php';
     32        $plugin_inactive = new Futusign_Inactive();
     33        $plugin_inactive->add_rewrite_rules();
     34        // SCREEN, ETC
    3035        require_once plugin_dir_path( dirname( __FILE__ ) ) . 'common/class-futusign-common.php';
    3136        $plugin_common = new Futusign_Common();

  • futusign/trunk/includes/class-futusign.php

    r1665899 r1669808  
    2828     */
    2929    public static function is_plugin_active( $plugin ) {
    30         if ( 'acf-to-rest-api' == $plugin ) {
    31             return class_exists( 'ACF_TO_REST_API' );
     30        if ( 'acf' == $plugin ) {
     31            return class_exists( 'acf' );
    3232        } elseif ( 'all' == $plugin ) {
    33             return class_exists( 'WP_REST_Controller' ) && class_exists( 'acf' ) && class_exists ( 'ACF_TO_REST_API' );
     33            return class_exists( 'acf' );
    3434        }
    3535        return false;
    … …  
    4646        }
    4747        $paths = false;
    48         if ( 'acf-to-rest-api' == $plugin ) {
    49             $paths = array( 'acf-to-rest-api/class-acf-to-rest-api.php' );
     48        if ( 'acf' == $plugin ) {
     49            $paths = array( 'advanced-custom-fields-pro/acf.php', 'acf-pro/acf.php', 'advanced-custom-fields/acf.php' );
    5050        }
    5151        if ( $paths ) {
    … …  
    9393    public function __construct() {
    9494        $this->plugin_name = 'futusign';
    95         $this->version = '2.1.1';
     95        $this->version = '2.2.0';
    9696        $this->load_dependencies();
    9797        $this->set_locale();
    … …  
    146146    private function define_inactive_hooks() {
    147147        $plugin_inactive = new Futusign_Inactive();
     148        $this->loader->add_action('init', $plugin_inactive, 'add_rewrite_rules');
    148149        $this->loader->add_action('admin_notices', $plugin_inactive, 'missing_plugins_notice' );
    149150    }
    … …  
    156157    private function define_common_hooks() {
    157158        $plugin_common = new Futusign_Common();
     159        // ENDPOINT
     160        $this->loader->add_action('init', $plugin_common, 'add_rewrite_rules');
    158161        // PLAYLIST
    159162        $this->loader->add_action('init', $plugin_common->get_playlist(), 'register', 20);
    … …  
    161164        $screen = $plugin_common->get_screen();
    162165        $this->loader->add_action('init', $screen, 'register');
    163         $this->loader->add_filter('init', $screen, 'register_field_group');
    164         $this->loader->add_filter('manage_futusign_screen_posts_custom_column', $screen, 'manage_posts_custom_column', 10, 2 );
     166        $this->loader->add_action('init', $screen, 'register_field_group');
     167        $this->loader->add_action('manage_futusign_screen_posts_custom_column', $screen, 'manage_posts_custom_column', 10, 2 );
    165168        $this->loader->add_filter('manage_futusign_screen_posts_columns', $screen, 'manage_posts_columns');
    166         $this->loader->add_filter('restrict_manage_posts', $screen, 'restrict_manage_posts');
    167         $this->loader->add_filter('parse_query', $screen, 'parse_query');
     169        $this->loader->add_action('restrict_manage_posts', $screen, 'restrict_manage_posts');
     170        $this->loader->add_action('parse_query', $screen, 'parse_query');
    168171        // SCREEN - OVERRIDE
    169         $this->loader->add_filter('restrict_manage_posts', $screen, 'restrict_manage_posts_override');
    170         $this->loader->add_filter('parse_query', $screen, 'parse_query_override');
     172        $this->loader->add_action('restrict_manage_posts', $screen, 'restrict_manage_posts_override');
     173        $this->loader->add_action('parse_query', $screen, 'parse_query_override');
    171174        // IMAGE
    172175        $image = $plugin_common->get_image();
    173176        $this->loader->add_action('init', $image, 'register');
    174         $this->loader->add_filter('init', $image, 'register_field_group');
    175         $this->loader->add_filter('manage_futusign_image_posts_custom_column', $image, 'manage_posts_custom_column', 10, 2 );
     177        $this->loader->add_action('init', $image, 'register_field_group');
     178        $this->loader->add_action('manage_futusign_image_posts_custom_column', $image, 'manage_posts_custom_column', 10, 2 );
    176179        $this->loader->add_filter('manage_futusign_image_posts_columns', $image, 'manage_posts_columns');
    177         $this->loader->add_filter('restrict_manage_posts', $image, 'restrict_manage_posts');
    178         $this->loader->add_filter('parse_query', $image, 'parse_query');
     180        $this->loader->add_action('restrict_manage_posts', $image, 'restrict_manage_posts');
     181        $this->loader->add_action('parse_query', $image, 'parse_query');
    179182        // IMAGE - OVERRIDE
    180         $this->loader->add_filter('restrict_manage_posts', $image, 'restrict_manage_posts_override');
    181         $this->loader->add_filter('parse_query', $image, 'parse_query_override');
     183        $this->loader->add_action('restrict_manage_posts', $image, 'restrict_manage_posts_override');
     184        $this->loader->add_action('parse_query', $image, 'parse_query_override');
    182185        // SLIDE DECK
    183186        $slide_deck = $plugin_common->get_slide_deck();
    184187        $this->loader->add_action('init', $slide_deck, 'register');
    185         $this->loader->add_filter('init', $slide_deck, 'register_field_group');
    186         $this->loader->add_filter('manage_futusign_slide_deck_posts_custom_column', $slide_deck, 'manage_posts_custom_column', 10, 2 );
     188        $this->loader->add_action('init', $slide_deck, 'register_field_group');
     189        $this->loader->add_action('manage_futusign_slide_deck_posts_custom_column', $slide_deck, 'manage_posts_custom_column', 10, 2 );
    187190        $this->loader->add_filter('manage_futusign_slide_deck_posts_columns', $slide_deck, 'manage_posts_columns');
    188         $this->loader->add_filter('restrict_manage_posts', $slide_deck, 'restrict_manage_posts');
    189         $this->loader->add_filter('parse_query', $slide_deck, 'parse_query');
     191        $this->loader->add_action('restrict_manage_posts', $slide_deck, 'restrict_manage_posts');
     192        $this->loader->add_action('parse_query', $slide_deck, 'parse_query');
    190193        // SLIDE DECK - OVERRIDE
    191         $this->loader->add_filter('restrict_manage_posts', $slide_deck, 'restrict_manage_posts_override');
    192         $this->loader->add_filter('parse_query', $slide_deck, 'parse_query_override');
     194        $this->loader->add_action('restrict_manage_posts', $slide_deck, 'restrict_manage_posts_override');
     195        $this->loader->add_action('parse_query', $slide_deck, 'parse_query_override');
    193196    }
    194197    /**
    … …  
    201204    private function define_admin_hooks() {
    202205        $plugin_admin = new Futusign_Admin();
     206        $this->loader->add_action( 'add_meta_boxes_futusign_screen', $plugin_admin, 'add_meta_boxes_futusign_screen' );
     207        $this->loader->add_action('admin_enqueue_scripts', $plugin_admin, 'admin_enqueue_scripts');
    203208    }
    204209    /**
    … …  
    212217        $plugin_public = new Futusign_Public();
    213218        $this->loader->add_action('single_template', $plugin_public, 'single_template');
     219        $this->loader->add_action('query_vars', $plugin_public, 'query_vars');
     220        $this->loader->add_action('parse_request', $plugin_public, 'parse_request');
    214221    }
    215222    /**

  • futusign/trunk/public/class-futusign-public.php

    r1637139 r1669808  
    4141        return $single;
    4242    }
     43    /**
     44     * Add to query variables
     45     *
     46     * @since    2.1.2
     47     * @param    array      $query_vars     query variables
     48     * @return   array      query variables
     49     */
     50    public function query_vars( $query_vars ) {
     51    $query_vars[] = 'futusign_endpoint';
     52        $query_vars[] = 'futusign_screen_id';
     53        return $query_vars;
     54    }
     55    /**
     56     * Define futusign-monitor endpoint
     57     *
     58     * @since    2.1.2
     59     * @param    array      $query     query
     60     */
     61    public function parse_request( $query ) {
     62        $query_vars = $query->query_vars;
     63        if ( array_key_exists( 'futusign_endpoint', $query_vars ) ) {
     64            if ( array_key_exists( 'futusign_screen_id', $query_vars ) ) {
     65                include 'partials/futusign-endpoint.php';
     66                futusign_endpoint($query_vars['futusign_screen_id']);
     67            } else {
     68                status_header(400);
     69            }
     70            exit();
     71        }
     72        return;
     73    }
    4374}

  • futusign/trunk/public/screen/package.json

    r1665899 r1669808  
    11{
    22  "name": "futusign-screen",
    3   "version": "2.1.1",
     3  "version": "2.2.0",
    44  "description": "futusign screen",
    55  "scripts": {

  • futusign/trunk/public/screen/src/components/App/Blocking/index.jsx

    r1602262 r1669808  
    33import spinner from './spinner.png';
    44
     5// TODO: PUT BAK SPINNER
    56export default () => (
    67  <div
    … …  
    89  >
    910    <img
    10       id={styles.rootSpinner}
     11      id={styles.rootSpinnerZ}
    1112      src={spinner}
    1213      alt="spinner"

  • futusign/trunk/public/screen/src/components/App/Player/PlayerYoutubeVideos/index.jsx

    r1651254 r1669808  
    2828      setBadPlaying,
    2929      setCover,
    30       setOfflinePlaying,
    3130      setNextIsReady,
    3231      youtubeVideos,
    … …  
    4443        this.readyTimeout = window.setTimeout(() => {
    4544          if (window.futusignYoutubePlayer === undefined) {
    46             setOfflinePlaying(true);
     45            setBadPlaying(true);
    4746            return;
    4847          }
    … …  
    147146  }
    148147  handleYoutubeError() {
    149     const { setOfflinePlaying } = this.props;
    150     setOfflinePlaying(true);
     148    const { setBadPlaying } = this.props;
     149    setBadPlaying(true);
    151150  }
    152151  validVideos() {
    … …  
    178177  setCurrentlyIsPlaying: PropTypes.func.isRequired,
    179178  setNextIsReady: PropTypes.func.isRequired,
    180   setOfflinePlaying: PropTypes.func.isRequired,
    181179  youtubeVideos: PropTypes.array.isRequired,
    182180};

  • futusign/trunk/public/screen/src/components/App/Player/index.jsx

    r1662779 r1669808  
    1212import * as fromCover from '../../../ducks/cover';
    1313import * as fromCounter from '../../../ducks/counter';
    14 import * as fromOfflinePlaying from '../../../ducks/offlinePlaying';
    1514import * as fromPriority from '../../../ducks/priority';
    1615import { getMinImagePriority } from '../../../ducks/minImagePriority';
    … …  
    240239      setCurrentlyIsPlaying,
    241240      setNextIsReady,
    242       setOfflinePlaying,
    243241    } = this.props;
    244242    return (
    … …  
    291289          setCurrentlyIsPlaying={setCurrentlyIsPlaying}
    292290          setNextIsReady={setNextIsReady}
    293           setOfflinePlaying={setOfflinePlaying}
    294291          youtubeVideos={this.filteredYoutubeVideos}
    295292        />
    … …  
    324321  setNextIsReady: PropTypes.func.isRequired,
    325322  setNextPlaying: PropTypes.func.isRequired,
    326   setOfflinePlaying: PropTypes.func.isRequired,
    327323  setPriority: PropTypes.func.isRequired,
    328324  slideDecks: PropTypes.array.isRequired,
    … …  
    347343    setNextIsReady: fromNextIsReady.setNextIsReady,
    348344    setNextPlaying: fromNextPlaying.setNextPlaying,
    349     setOfflinePlaying: fromOfflinePlaying.setOfflinePlaying,
    350345    setPriority: fromPriority.setPriority,
    351346  }

  • futusign/trunk/public/screen/src/components/App/index.jsx

    r1662779 r1669808  
    44import 'firebase/auth';
    55import 'firebase/database';
    6 import { CACHE_INTERVAL, POLLING_INTERVAL, TRANSITION } from '../../strings';
    7 import { fetchBase } from '../../apis/base';
     6import { CACHE_INTERVAL, ERROR_POLLING_INTERVAL, TRANSITION } from '../../strings';
    87import { minLargerPriority } from '../../util/misc';
    98import * as fromAppBlocking from '../../ducks/appBlocking';
    … …  
    1312import * as fromSlideDecksOverride from '../../ducks/slideDecksOverride';
    1413import * as fromYoutubeVideos from '../../ducks/youtubeVideos';
     14import * as fromYoutubeVideosOverride from '../../ducks/youtubeVideosOverride';
    1515import * as fromCover from '../../ducks/cover';
    1616import * as fromCounter from '../../ducks/counter';
    … …  
    1919import * as fromLayers from '../../ducks/layers';
    2020import * as fromWebs from '../../ducks/webs';
     21import * as fromWebsOverride from '../../ducks/websOverride';
    2122import * as fromOfflinePlaying from '../../ducks/offlinePlaying';
    2223import * as fromBadPlaying from '../../ducks/badPlaying';
    … …  
    5051    this.fetch = this.fetch.bind(this);
    5152    this.restartPlayingLoop = this.restartPlayingLoop.bind(this);
    52     this.fetchSubscribed = this.fetchSubscribed.bind(this);
    5353  }
    5454  componentDidMount() {
    … …  
    7373    };
    7474    this.fetch();
    75     window.setInterval(this.fetch, POLLING_INTERVAL * 1000);
    7675    window.setInterval(check, CACHE_INTERVAL * 1000);
    7776    appCache.addEventListener('updateready', handleUpdateReady);
    7877    window.addEventListener('message', handleMessage);
    7978  }
    80   fetchSubscribed(screen) {
    81     const {
    82       fetchImages,
    83       fetchMediaDecks,
    84       fetchSlideDecks,
    85       fetchWebs,
    86       fetchYoutubeVideos,
    87       fetchLayers,
    88       resetImages,
    89       resetMediaDecks,
    90       resetSlideDecks,
    91       resetWebs,
    92       resetYoutubeVideos,
    93     } = this.props;
    94     if (screen.subscribedPlaylistIds.length === 0) {
    95       resetImages();
    96       resetMediaDecks();
    97       resetWebs();
    98       resetYoutubeVideos();
    99       resetSlideDecks();
    100       return Promise.resolve([{
    101         response: {
    102           result: [],
    103           entities: {
    104             images: {},
    105           },
    106         },
    107       }, {
    108         response: {
    109           result: [],
    110           entities: {
    111             mediaDecks: {},
    112           },
    113         },
    114       }, {
    115         response: {
    116           result: [],
    117           entities: {
    118             webs: {},
    119           },
    120         },
    121       }, {
    122         response: {
    123           result: [],
    124           entities: {
    125             youtubeVideos: {},
    126           },
    127         },
    128       }, {
    129         response: {
    130           result: [],
    131           entities: {
    132             layers: {},
    133           },
    134         },
    135       }, {
    136         response: {
    137           result: [],
    138           entities: {
    139             slideDecks: {},
    140           },
    141         },
    142       }]);
    143     }
    144     return Promise.all([
    145       fetchImages(screen.subscribedPlaylistIds),
    146       fetchMediaDecks(screen.subscribedPlaylistIds),
    147       fetchWebs(screen.subscribedPlaylistIds),
    148       fetchYoutubeVideos(screen.subscribedPlaylistIds),
    149       fetchLayers(screen.subscribedPlaylistIds),
    150       fetchSlideDecks(screen.subscribedPlaylistIds),
    151     ]);
    152   }
    153   fetchSubscribedOverride(screen) {
    154     const {
    155       fetchImagesOverride,
    156       fetchMediaDecksOverride,
    157       fetchSlideDecksOverride,
    158       resetImagesOverride,
    159       resetMediaDecksOverride,
    160       resetSlideDecksOverride,
    161     } = this.props;
    162     if (screen.subscribedOverrideIds.length === 0) {
    163       resetImagesOverride();
    164       resetMediaDecksOverride();
    165       resetSlideDecksOverride();
    166       return Promise.resolve([{
    167         response: {
    168           result: [],
    169           entities: {
    170             images: {},
    171           },
    172         },
    173       }, {
    174         response: {
    175           result: [],
    176           entities: {
    177             mediaDecks: {},
    178           },
    179         },
    180       }, {
    181         response: {
    182           result: [],
    183           entities: {
    184             slideDecks: {},
    185           },
    186         },
    187       }]);
    188     }
    189     return Promise.all([
    190       fetchImagesOverride(screen.subscribedOverrideIds),
    191       fetchMediaDecksOverride(screen.subscribedOverrideIds),
    192       fetchSlideDecksOverride(screen.subscribedOverrideIds),
    193     ]);
    194   }
    19579  fetch() {
    19680    const {
    19781      badPlaying,
    198       fetchMonitor,
    199       fetchOverlay,
    200       fetchOvWidgets,
    20182      fetchScreen,
    20283      images,
    20384      imagesOverride,
     85      offlinePlaying,
     86      override,
    20487      layers,
     88      monitor,
    20589      mediaDecks,
    20690      mediaDecksOverride,
    207       monitor,
    208       offlinePlaying,
    209       override,
    210       resetOvWidgets,
     91      webs,
     92      websOverride,
     93      youtubeVideos,
     94      youtubeVideosOverride,
     95      setConnected,
     96      slideDecks,
     97      slideDecksOverride,
    21198      setAppBlocking,
    21299      setBadPlaying,
    213       setConnected,
     100      setOverride,
    214101      setOfflinePlaying,
    215       setOverride,
    216       slideDecks,
    217       slideDecksOverride,
    218       webs,
    219       youtubeVideos,
    220102    } = this.props;
    221     fetchBase()
    222     .then(() => {
    223       // DETECT COMING BACK ONLINE
     103    fetchScreen()
     104    .then(response => {
    224105      if (offlinePlaying) {
    225106        window.location.reload();
    226       }
    227       return fetchScreen();
    228     })
    229     .then(screen => {
    230       if (screen.overlay === null) {
    231         resetOvWidgets();
    232         return Promise.all([
    233           Promise.resolve(null),
    234           Promise.resolve(screen),
    235         ]);
    236       }
    237       return Promise.all([
    238         fetchOverlay(screen.overlay),
    239         Promise.resolve(screen),
    240       ]);
    241     })
    242     .then(([overlay, screen]) => {
    243       if (overlay === null) {
    244         resetOvWidgets();
    245         return screen;
    246       }
    247       return fetchOvWidgets()
    248       .then(() => screen);
    249     })
    250     .then(screen => Promise.all([
    251       this.fetchSubscribed(screen),
    252       this.fetchSubscribedOverride(screen),
    253       fetchMonitor(),
    254       Promise.resolve(screen),
    255     ]))
    256     .then(([
    257       [
    258         imagesResponse,
    259         mediaDecksResponse,
    260         websResponse,
    261         youtubeVideosResponse,
    262         layersResponse,
    263         slideDecksResponse,
    264       ],
    265       [
    266         imagesOverrideResponse,
    267         mediaDecksOverrideResponse,
    268         slideDecksOverrideResponse,
    269       ],
    270       monitorResponse,
    271       screen,
    272     ]) => {
     107        return;
     108      }
     109      const screen = response.screen;
    273110      let nextOverride = false;
    274       let usedImagesResponse = imagesResponse;
    275       let usedMediaDecksResponse = mediaDecksResponse;
    276       let usedSlideDecksResponse = slideDecksResponse;
    277       let usedWebsResponse = websResponse;
    278       let usedYoutubeVideosResponse = youtubeVideosResponse;
     111      let nextImages = response.images;
     112      let nextMediaDecks = response.mediaDecks;
     113      let nextSlideDecks = response.slideDecks;
     114      let nextWebs = response.webs;
     115      let nextYoutubeVideos = response.youtubeVideos;
     116      const nextLayers = response.layers;
     117      const nextMonitor = response.monitor;
    279118      if (
    280         imagesOverrideResponse.response.result.length !== 0 ||
    281         mediaDecksOverrideResponse.response.result.length !== 0 ||
    282         slideDecksOverrideResponse.response.result.length !== 0
     119        response.imagesOverride.length !== 0 ||
     120        response.mediaDecksOverride.length !== 0 ||
     121        response.slideDecksOverride.length !== 0 ||
     122        response.websOverride.length !== 0 ||
     123        response.youtubeVideosOverride.length !== 0
    283124      ) {
    284125        nextOverride = true;
    285126        setOverride(true);
    286         usedImagesResponse = imagesOverrideResponse;
    287         usedMediaDecksResponse = mediaDecksOverrideResponse;
    288         usedSlideDecksResponse = slideDecksOverrideResponse;
    289         usedWebsResponse = {
    290           response: {
    291             result: [],
    292             entities: {
    293               webs: {},
    294             },
    295           },
    296         };
    297         usedYoutubeVideosResponse = {
    298           response: {
    299             result: [],
    300             entities: {
    301               youtubeVideos: {},
    302             },
    303           },
    304         };
     127        nextImages = response.imagesOverride;
     128        nextMediaDecks = response.mediaDecksOverride;
     129        nextSlideDecks = response.slideDecksOverride;
     130        nextWebs = response.websOverride;
     131        nextYoutubeVideos = response.youtubeVideosOverride;
    305132      } else {
    306133        setOverride(false);
    307134      }
    308       // NEXT IMAGES
    309       let keys = usedImagesResponse.response.result;
    310       let lookup = usedImagesResponse.response.entities.images;
    311       let list = keys.map(o => lookup[o]);
    312       const nextImages = list;
    313       // NEXT MEDIA DECKS
    314       keys = usedMediaDecksResponse.response.result;
    315       lookup = usedMediaDecksResponse.response.entities.mediaDecks;
    316       list = keys.map(o => lookup[o]);
    317       const nextMediaDecks = list;
    318       // NEXT WEBS
    319       keys = usedWebsResponse.response.result;
    320       lookup = usedWebsResponse.response.entities.webs;
    321       list = keys.map(o => lookup[o]);
    322       const nextWebs = list;
    323       // NEXT YOUTUBE VIDEOS
    324       keys = usedYoutubeVideosResponse.response.result;
    325       lookup = usedYoutubeVideosResponse.response.entities.youtubeVideos;
    326       list = keys.map(o => lookup[o]);
    327       const nextYoutubeVideos = list;
    328       // NEXT LAYERS
    329       keys = layersResponse.response.result;
    330       lookup = layersResponse.response.entities.layers;
    331       list = keys.map(o => lookup[o]);
    332       const nextLayers = list;
    333       // NEXT SLIDE DECKS
    334       keys = usedSlideDecksResponse.response.result;
    335       lookup = usedSlideDecksResponse.response.entities.slideDecks;
    336       list = keys.map(o => lookup[o]);
    337       const nextSlideDecks = list;
    338       // MONITORING
    339       const nextMonitor = monitorResponse;
    340135      // MONITORING - RELOAD
    341136      if (
    … …  
    344139      ) {
    345140        window.location.reload();
    346         return null;
     141        return;
    347142      }
    348143      // MONITORING - LOGIN AND CHECK-IN
    … …  
    408203        usedImages = imagesOverride;
    409204        usedMediaDecks = mediaDecksOverride;
    410         usedWebs = [];
    411         usedYoutubeVideos = [];
     205        usedWebs = websOverride;
     206        usedYoutubeVideos = youtubeVideosOverride;
    412207        usedSlideDecks = slideDecksOverride;
    413208      }
    … …  
    425220        this.restartPlayingLoop();
    426221      }
    427       return null;
     222      window.setTimeout(this.fetch, screen.polling * 60 * 1000);
    428223    })
    429224    .catch(error => {
    … …  
    436231        return;
    437232      }
     233      window.setTimeout(this.fetch, ERROR_POLLING_INTERVAL * 1000);
    438234    });
    439235  }
    … …  
    457253      slideDecksOverride,
    458254      webs,
     255      websOverride,
    459256      youtubeVideos,
     257      youtubeVideosOverride,
    460258    } = this.props;
    461259    let usedSlideDecks = slideDecks;
    … …  
    468266      usedMediaDecks = mediaDecksOverride;
    469267      usedImages = imagesOverride;
    470       usedWebs = [];
    471       usedYoutubeVideos = [];
     268      usedWebs = websOverride;
     269      usedYoutubeVideos = youtubeVideosOverride;
    472270    }
    473271    setNextIsReady(false);
    … …  
    508306      slideDecksOverride,
    509307      webs,
     308      websOverride,
    510309      youtubeVideos,
     310      youtubeVideosOverride,
    511311    } = this.props;
    512312    const lastImageURL = window.localStorage.getItem('futusign_image_url');
    … …  
    519319      usedImages = imagesOverride;
    520320      usedMediaDecks = mediaDecksOverride;
    521       usedWebs = [];
    522       usedYoutubeVideos = [];
     321      usedWebs = websOverride;
     322      usedYoutubeVideos = youtubeVideosOverride;
    523323      usedSlideDecks = slideDecksOverride;
    524324    }
    … …  
    561361  images: PropTypes.array.isRequired,
    562362  imagesOverride: PropTypes.array.isRequired,
    563   fetchImages: PropTypes.func.isRequired,
    564   fetchImagesOverride: PropTypes.func.isRequired,
    565   fetchLayers: PropTypes.func.isRequired,
    566   fetchMediaDecks: PropTypes.func.isRequired,
    567   fetchMediaDecksOverride: PropTypes.func.isRequired,
    568   fetchOverlay: PropTypes.func.isRequired,
    569   fetchOvWidgets: PropTypes.func.isRequired,
    570   fetchMonitor: PropTypes.func.isRequired,
    571363  fetchScreen: PropTypes.func.isRequired,
    572   fetchSlideDecks: PropTypes.func.isRequired,
    573   fetchSlideDecksOverride: PropTypes.func.isRequired,
    574   fetchWebs: PropTypes.func.isRequired,
    575   fetchYoutubeVideos: PropTypes.func.isRequired,
    576364  layers: PropTypes.array.isRequired,
    577365  layerBlocking: PropTypes.bool.isRequired,
    … …  
    584372  ovWidgets: PropTypes.array.isRequired,
    585373  resetCurrentlyPlaying: PropTypes.func.isRequired,
    586   resetImages: PropTypes.func.isRequired,
    587   resetImagesOverride: PropTypes.func.isRequired,
    588   resetMediaDecks: PropTypes.func.isRequired,
    589   resetMediaDecksOverride: PropTypes.func.isRequired,
    590374  resetNextPlaying: PropTypes.func.isRequired,
    591   resetOvWidgets: PropTypes.func.isRequired,
    592   resetSlideDecks: PropTypes.func.isRequired,
    593   resetSlideDecksOverride: PropTypes.func.isRequired,
    594   resetWebs: PropTypes.func.isRequired,
    595   resetYoutubeVideos: PropTypes.func.isRequired,
    596375  setAppBlocking: PropTypes.func.isRequired,
    597376  setBadPlaying: PropTypes.func.isRequired,
    … …  
    610389  slideDecksOverride: PropTypes.array.isRequired,
    611390  webs: PropTypes.array.isRequired,
     391  websOverride: PropTypes.array.isRequired,
    612392  youtubeVideos: PropTypes.array.isRequired,
     393  youtubeVideosOverride: PropTypes.array.isRequired,
    613394};
    614395export default connect(
    … …  
    632413    slideDecksOverride: fromSlideDecksOverride.getSlideDecksOverride(state),
    633414    webs: fromWebs.getWebs(state),
     415    websOverride: fromWebsOverride.getWebsOverride(state),
    634416    youtubeVideos: fromYoutubeVideos.getYoutubeVideos(state),
     417    youtubeVideosOverride: fromYoutubeVideosOverride.getYoutubeVideosOverride(state),
    635418  }),
    636419  {
    637     fetchImages: fromImages.fetchImages,
    638     fetchImagesOverride: fromImagesOverride.fetchImagesOverride,
    639     fetchLayers: fromLayers.fetchLayers,
    640     fetchMediaDecks: fromMediaDecks.fetchMediaDecks,
    641     fetchMediaDecksOverride: fromMediaDecksOverride.fetchMediaDecksOverride,
    642     fetchMonitor: fromMonitor.fetchMonitor,
    643     fetchOverlay: fromOverlay.fetchOverlay,
    644     fetchOvWidgets: fromOvWidgets.fetchOvWidgets,
    645420    fetchScreen: fromScreen.fetchScreen,
    646     fetchSlideDecks: fromSlideDecks.fetchSlideDecks,
    647     fetchSlideDecksOverride: fromSlideDecksOverride.fetchSlideDecksOverride,
    648     fetchWebs: fromWebs.fetchWebs,
    649     fetchYoutubeVideos: fromYoutubeVideos.fetchYoutubeVideos,
    650421    resetCurrentlyPlaying: fromCurrentlyPlaying.resetCurrentlyPlaying,
    651     resetImages: fromImages.resetImages,
    652     resetImagesOverride: fromImagesOverride.resetImagesOverride,
    653     resetMediaDecks: fromMediaDecks.resetMediaDecks,
    654     resetMediaDecksOverride: fromMediaDecksOverride.resetMediaDecksOverride,
    655422    resetNextPlaying: fromNextPlaying.resetNextPlaying,
    656     resetOvWidgets: fromOvWidgets.resetOvWidgets,
    657     resetSlideDecks: fromSlideDecks.resetSlideDecks,
    658     resetSlideDecksOverride: fromSlideDecksOverride.resetSlideDecksOverride,
    659     resetWebs: fromWebs.resetWebs,
    660     resetYoutubeVideos: fromYoutubeVideos.resetYoutubeVideos,
    661423    setAppBlocking: fromAppBlocking.setAppBlocking,
    662424    setBadPlaying: fromBadPlaying.setBadPlaying,

  • futusign/trunk/public/screen/src/configureStore/reducers.js

    r1662779 r1669808  
    77import slideDecks from '../ducks/slideDecks';
    88import youtubeVideos from '../ducks/youtubeVideos';
     9import youtubeVideosOverride from '../ducks/youtubeVideosOverride';
    910import currentlyPlaying from '../ducks/currentlyPlaying';
    1011import currentlyIsPlaying from '../ducks/currentlyIsPlaying';
    … …  
    2122import minImagePriority from '../ducks/minImagePriority';
    2223import webs from '../ducks/webs';
     24import websOverride from '../ducks/websOverride';
    2325import slideDecksOverride from '../ducks/slideDecksOverride';
    2426import imagesOverride from '../ducks/imagesOverride';
    … …  
    3436  screen,
    3537  slideDecks,
    36   youtubeVideos,
    3738  currentlyPlaying,
    3839  currentlyIsPlaying,
    … …  
    5051  minImagePriority,
    5152  webs,
     53  websOverride,
    5254  slideDecksOverride,
    5355  imagesOverride,
    … …  
    5658  mediaDecks,
    5759  mediaDecksOverride,
     60  youtubeVideos,
     61  youtubeVideosOverride,
    5862});

  • futusign/trunk/public/screen/src/ducks/badPlaying.js

    r1602262 r1669808  
    1 import { ACTION_PREFIX } from '../strings';
     1import { ACTION_PREFIX, ERROR_POLLING_INTERVAL } from '../strings';
    22
    33// API
    … …  
    2424export const setBadPlaying = (value) => {
    2525  if (!validBadPlaying(value)) throw new Error();
     26  if (value) {
     27    window.setTimeout(() => {
     28      window.location.reload();
     29    }, ERROR_POLLING_INTERVAL * 1000);
     30  }
    2631  return ({
    2732    type: SET_BAD_PLAYING,

  • futusign/trunk/public/screen/src/ducks/images.js

    r1626880 r1669808  
    44import { ACTION_PREFIX } from '../strings';
    55// API
    6 import { get } from '../apis/images';
    76
    87// REDUCER MOUNT POINT
    98const reducerMountPoint = 'images';
    109// ACTIONS
    11 export const FETCH_IMAGES_REQUEST = `${ACTION_PREFIX}FETCH_IMAGES_REQUEST`;
    1210export const FETCH_IMAGES_SUCCESS = `${ACTION_PREFIX}FETCH_IMAGES_SUCCESS`;
    13 export const RESET_IMAGES = `${ACTION_PREFIX}RESET_IMAGES`;
    1411// SCHEMA
    1512const imageSchema = new Schema('images');
    … …  
    2421      };
    2522    }
    26     case RESET_IMAGES: {
    27       return {};
    28     }
    2923    default:
    3024      return state;
    … …  
    3529    case FETCH_IMAGES_SUCCESS:
    3630      return action.response.result;
    37     case RESET_IMAGES:
    38       return [];
    39     default:
    40       return state;
    41   }
    42 };
    43 const isFetching = (state = false, action) => {
    44   switch (action.type) {
    45     case FETCH_IMAGES_REQUEST:
    46       return true;
    47     case FETCH_IMAGES_SUCCESS:
    48       return false;
    4931    default:
    5032      return state;
    … …  
    5436  byId,
    5537  ids,
    56   isFetching,
    5738});
    5839// ACCESSORS AKA SELECTORS
    59 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    6040const getImagesIds = state => state[reducerMountPoint].ids;
    6141const getImagesById = state => state[reducerMountPoint].byId;
    … …  
    6444  (imagesIds, imagesById) => imagesIds.map(id => imagesById[id])
    6545);
    66 export const getIsFetchingImages = (state) => state[reducerMountPoint].isFetching;
    67 // ACTION CREATOR VALIDATORS
    68 // ACTION CREATORS
    69 export const fetchImages = (playlistIds) => (dispatch, getState) => {
    70   if (!Array.isArray(playlistIds)) throw new Error();
    71   if (getIsFetchingImages(getState())) throw new Error();
    72   dispatch({
    73     type: FETCH_IMAGES_REQUEST,
    74   });
    75   return get(playlistIds)
    76     .then(
    77       response => dispatch({
    78         type: FETCH_IMAGES_SUCCESS,
    79         response: normalize(response, imagesSchema),
    80       })
    81     );
    82 };
    83 export const resetImages = () => ({
    84   type: RESET_IMAGES,
     46export const setImages = response => ({
     47  type: FETCH_IMAGES_SUCCESS,
     48  response: normalize(response, imagesSchema),
    8549});

  • futusign/trunk/public/screen/src/ducks/imagesOverride.js

    r1653754 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/images';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'imagesOverride';
    119// ACTIONS
    12 export const FETCH_IMAGES_OVERRIDE_REQUEST
    13   = `${ACTION_PREFIX}FETCH_IMAGES_OVERRIDE_REQUEST`;
    14 export const FETCH_IMAGES_OVERRIDE_SUCCESS
    15   = `${ACTION_PREFIX}FETCH_IMAGES_OVERRIDE_SUCCESS`;
    16 export const FETCH_IMAGES_OVERRIDE_ERROR = `${ACTION_PREFIX}FETCH_IMAGES_OVERRIDE_ERROR`;
    17 export const RESET_FETCH_IMAGES_OVERRIDE_ERROR
    18   = `${ACTION_PREFIX}RESET_FETCH_IMAGES_OVERRIDE_ERROR`;
    19 export const RESET_IMAGES_OVERRIDE = `${ACTION_PREFIX}RESET_IMAGES_OVERRIDE`;
     10export const FETCH_IMAGES_OVERRIDE_SUCCESS = `${ACTION_PREFIX}FETCH_IMAGES_OVERRIDE_SUCCESS`;
    2011// SCHEMA
    21 const imageSchema = new Schema('images');
    22 const imagesOverrideSchema = arrayOf(imageSchema);
     12const imageOverrideSchema = new Schema('imagesOverride');
     13const imagesOverrideSchema = arrayOf(imageOverrideSchema);
    2314// REDUCERS
    2415const byId = (state = {}, action) => {
    … …  
    2718      return {
    2819        ...state,
    29         ...action.response.entities.images,
     20        ...action.response.entities.imagesOverride,
    3021      };
    31     }
    32     case RESET_IMAGES_OVERRIDE: {
    33       return {};
    3422    }
    3523    default:
    … …  
    4129    case FETCH_IMAGES_OVERRIDE_SUCCESS:
    4230      return action.response.result;
    43     case RESET_IMAGES_OVERRIDE:
    44       return [];
    45     default:
    46       return state;
    47   }
    48 };
    49 const isFetching = (state = false, action) => {
    50   switch (action.type) {
    51     case FETCH_IMAGES_OVERRIDE_REQUEST:
    52       return true;
    53     case FETCH_IMAGES_OVERRIDE_SUCCESS:
    54     case FETCH_IMAGES_OVERRIDE_ERROR:
    55       return false;
    56     default:
    57       return state;
    58   }
    59 };
    60 const fetchErrorMessage = (state = null, action) => {
    61   switch (action.type) {
    62     case FETCH_IMAGES_OVERRIDE_ERROR:
    63       return action.message;
    64     case FETCH_IMAGES_OVERRIDE_REQUEST:
    65     case FETCH_IMAGES_OVERRIDE_SUCCESS:
    66       return null;
    6731    default:
    6832      return state;
    … …  
    7236  byId,
    7337  ids,
    74   isFetching,
    75   fetchErrorMessage,
    7638});
    7739// ACCESSORS AKA SELECTORS
    78 export const getImage = (state, id) => state[reducerMountPoint].byId[id];
    7940const getImagesOverrideIds = state => state[reducerMountPoint].ids;
    8041const getImagesOverrideById = state => state[reducerMountPoint].byId;
    8142export const getImagesOverride = createSelector(
    8243  [getImagesOverrideIds, getImagesOverrideById],
    83   (imagesOverrideIds, imagesOverrideById) => imagesOverrideIds
    84     .map(id => imagesOverrideById[id])
     44  (imagesOverrideIds, imagesOverrideById) => imagesOverrideIds.map(id => imagesOverrideById[id])
    8545);
    86 export const getIsFetchingImagesOverride = (state) => state[reducerMountPoint].isFetching;
    87 export const getFetchImagesOverrideErrorMessage = (state) => state[reducerMountPoint]
    88   .fetchErrorMessage;
    89 // ACTION CREATOR VALIDATORS
    90 // ACTION CREATORS
    91 export const fetchImagesOverride = (overrideIds) => (dispatch, getState) => {
    92   if (!Array.isArray(overrideIds)) throw new Error();
    93   if (getIsFetchingImagesOverride(getState())) throw new Error();
    94   dispatch({
    95     type: FETCH_IMAGES_OVERRIDE_REQUEST,
    96   });
    97   return get(overrideIds, true)
    98     .then(
    99       response => dispatch({
    100         type: FETCH_IMAGES_OVERRIDE_SUCCESS,
    101         response: normalize(response, imagesOverrideSchema),
    102       }),
    103       error => {
    104         dispatch({
    105           type: FETCH_IMAGES_OVERRIDE_ERROR,
    106           message: error.message,
    107         });
    108         throw new ServerException(error.message);
    109       }
    110     );
    111 };
    112 export const resetFetchImagesOverrideError = () => ({
    113   type: RESET_FETCH_IMAGES_OVERRIDE_ERROR,
     46export const setImagesOverride = response => ({
     47  type: FETCH_IMAGES_OVERRIDE_SUCCESS,
     48  response: normalize(response, imagesOverrideSchema),
    11449});
    115 export const resetImagesOverride = () => ({
    116   type: RESET_IMAGES_OVERRIDE,
    117 });

  • futusign/trunk/public/screen/src/ducks/layers.js

    r1641749 r1669808  
    44import { ACTION_PREFIX } from '../strings';
    55// API
    6 import { get } from '../apis/layers';
    76
    87// REDUCER MOUNT POINT
    98const reducerMountPoint = 'layers';
    109// ACTIONS
    11 export const FETCH_LAYERS_REQUEST = `${ACTION_PREFIX}FETCH_LAYERS_REQUEST`;
    1210export const FETCH_LAYERS_SUCCESS = `${ACTION_PREFIX}FETCH_LAYERS_SUCCESS`;
    13 export const RESET_LAYERS = `${ACTION_PREFIX}RESET_LAYERS`;
    1411// SCHEMA
    1512const layerSchema = new Schema('layers');
    … …  
    2421      };
    2522    }
    26     case RESET_LAYERS: {
    27       return {};
    28     }
    2923    default:
    3024      return state;
    … …  
    3529    case FETCH_LAYERS_SUCCESS:
    3630      return action.response.result;
    37     case RESET_LAYERS:
    38       return [];
    39     default:
    40       return state;
    41   }
    42 };
    43 const isFetching = (state = false, action) => {
    44   switch (action.type) {
    45     case FETCH_LAYERS_REQUEST:
    46       return true;
    47     case FETCH_LAYERS_SUCCESS:
    48       return false;
    4931    default:
    5032      return state;
    … …  
    5436  byId,
    5537  ids,
    56   isFetching,
    5738});
    5839// ACCESSORS AKA SELECTORS
    59 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    6040const getLayersIds = state => state[reducerMountPoint].ids;
    6141const getLayersById = state => state[reducerMountPoint].byId;
    … …  
    6444  (layersIds, layersById) => layersIds.map(id => layersById[id])
    6545);
    66 export const getIsFetchingLayers = (state) => state[reducerMountPoint].isFetching;
    67 // ACTION CREATOR VALIDATORS
    68 // ACTION CREATORS
    69 export const fetchLayers = (playlistIds) => (dispatch, getState) => {
    70   if (!Array.isArray(playlistIds)) throw new Error();
    71   if (getIsFetchingLayers(getState())) throw new Error();
    72   dispatch({
    73     type: FETCH_LAYERS_REQUEST,
    74   });
    75   return get(playlistIds)
    76     .then(
    77       response => dispatch({
    78         type: FETCH_LAYERS_SUCCESS,
    79         response: normalize(response, layersSchema),
    80       })
    81     );
    82 };
    83 export const resetLayers = () => ({
    84   type: RESET_LAYERS,
     46export const setLayers = response => ({
     47  type: FETCH_LAYERS_SUCCESS,
     48  response: normalize(response, layersSchema),
    8549});

  • futusign/trunk/public/screen/src/ducks/mediaDecks.js

    r1662779 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/mediaDecks';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'mediaDecks';
    119// ACTIONS
    12 export const FETCH_MEDIA_DECKS_REQUEST = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_REQUEST`;
    1310export const FETCH_MEDIA_DECKS_SUCCESS = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_SUCCESS`;
    14 export const FETCH_MEDIA_DECKS_ERROR = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_ERROR`;
    15 export const RESET_FETCH_MEDIA_DECKS_ERROR = `${ACTION_PREFIX}RESET_FETCH_MEDIA_DECKS_ERROR`;
    16 export const RESET_MEDIA_DECKS = `${ACTION_PREFIX}RESET_MEDIA_DECKS`;
    1711// SCHEMA
    1812const mediaDeckSchema = new Schema('mediaDecks');
    … …  
    2721      };
    2822    }
    29     case RESET_MEDIA_DECKS: {
    30       return {};
    31     }
    3223    default:
    3324      return state;
    … …  
    3829    case FETCH_MEDIA_DECKS_SUCCESS:
    3930      return action.response.result;
    40     case RESET_MEDIA_DECKS:
    41       return [];
    42     default:
    43       return state;
    44   }
    45 };
    46 const isFetching = (state = false, action) => {
    47   switch (action.type) {
    48     case FETCH_MEDIA_DECKS_REQUEST:
    49       return true;
    50     case FETCH_MEDIA_DECKS_SUCCESS:
    51     case FETCH_MEDIA_DECKS_ERROR:
    52       return false;
    53     default:
    54       return state;
    55   }
    56 };
    57 const fetchErrorMessage = (state = null, action) => {
    58   switch (action.type) {
    59     case FETCH_MEDIA_DECKS_ERROR:
    60       return action.message;
    61     case FETCH_MEDIA_DECKS_REQUEST:
    62     case FETCH_MEDIA_DECKS_SUCCESS:
    63       return null;
    6431    default:
    6532      return state;
    … …  
    6936  byId,
    7037  ids,
    71   isFetching,
    72   fetchErrorMessage,
    7338});
    7439// ACCESSORS AKA SELECTORS
    75 export const getMediaDeck = (state, id) => state[reducerMountPoint].byId[id];
    7640const getMediaDecksIds = state => state[reducerMountPoint].ids;
    7741const getMediaDecksById = state => state[reducerMountPoint].byId;
    … …  
    8044  (mediaDecksIds, mediaDecksById) => mediaDecksIds.map(id => mediaDecksById[id])
    8145);
    82 export const getIsFetchingMediaDecks = (state) => state[reducerMountPoint].isFetching;
    83 export const getFetchMediaDecksErrorMessage = (state) => state[reducerMountPoint].fetchErrorMessage;
    84 // ACTION CREATOR VALIDATORS
    85 // ACTION CREATORS
    86 export const fetchMediaDecks = (playlistIds) => (dispatch, getState) => {
    87   if (!Array.isArray(playlistIds)) throw new Error();
    88   if (getIsFetchingMediaDecks(getState())) throw new Error();
    89   dispatch({
    90     type: FETCH_MEDIA_DECKS_REQUEST,
    91   });
    92   return get(playlistIds)
    93     .then(
    94       response => dispatch({
    95         type: FETCH_MEDIA_DECKS_SUCCESS,
    96         response: normalize(response, mediaDecksSchema),
    97       }),
    98       error => {
    99         dispatch({
    100           type: FETCH_MEDIA_DECKS_ERROR,
    101           message: error.message,
    102         });
    103         throw new ServerException(error.message);
    104       }
    105     );
    106 };
    107 export const resetFetchMediaDecksError = () => ({
    108   type: RESET_FETCH_MEDIA_DECKS_ERROR,
     46export const setMediaDecks = response => ({
     47  type: FETCH_MEDIA_DECKS_SUCCESS,
     48  response: normalize(response, mediaDecksSchema),
    10949});
    110 export const resetMediaDecks = () => ({
    111   type: RESET_MEDIA_DECKS,
    112 });

  • futusign/trunk/public/screen/src/ducks/mediaDecksOverride.js

    r1662779 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/mediaDecks';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'mediaDecksOverride';
    119// ACTIONS
    12 export const FETCH_MEDIA_DECKS_OVERRIDE_REQUEST
    13   = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_OVERRIDE_REQUEST`;
    14 export const FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS
    15   = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS`;
    16 export const FETCH_MEDIA_DECKS_OVERRIDE_ERROR = `${ACTION_PREFIX}FETCH_MEDIA_DECKS_OVERRIDE_ERROR`;
    17 export const RESET_FETCH_MEDIA_DECKS_OVERRIDE_ERROR
    18   = `${ACTION_PREFIX}RESET_FETCH_MEDIA_DECKS_OVERRIDE_ERROR`;
    19 export const RESET_MEDIA_DECKS_OVERRIDE = `${ACTION_PREFIX}RESET_MEDIA_DECKS_OVERRIDE`;
     10export const FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS =
     11  `${ACTION_PREFIX}FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS`;
    2012// SCHEMA
    21 const mediaDeckSchema = new Schema('mediaDecks');
    22 const mediaDecksOverrideSchema = arrayOf(mediaDeckSchema);
     13const mediaDeckOverrideSchema = new Schema('mediaDecksOverride');
     14const mediaDecksOverrideSchema = arrayOf(mediaDeckOverrideSchema);
    2315// REDUCERS
    2416const byId = (state = {}, action) => {
    … …  
    2719      return {
    2820        ...state,
    29         ...action.response.entities.mediaDecks,
     21        ...action.response.entities.mediaDecksOverride,
    3022      };
    31     }
    32     case RESET_MEDIA_DECKS_OVERRIDE: {
    33       return {};
    3423    }
    3524    default:
    … …  
    4130    case FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS:
    4231      return action.response.result;
    43     case RESET_MEDIA_DECKS_OVERRIDE:
    44       return [];
    45     default:
    46       return state;
    47   }
    48 };
    49 const isFetching = (state = false, action) => {
    50   switch (action.type) {
    51     case FETCH_MEDIA_DECKS_OVERRIDE_REQUEST:
    52       return true;
    53     case FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS:
    54     case FETCH_MEDIA_DECKS_OVERRIDE_ERROR:
    55       return false;
    56     default:
    57       return state;
    58   }
    59 };
    60 const fetchErrorMessage = (state = null, action) => {
    61   switch (action.type) {
    62     case FETCH_MEDIA_DECKS_OVERRIDE_ERROR:
    63       return action.message;
    64     case FETCH_MEDIA_DECKS_OVERRIDE_REQUEST:
    65     case FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS:
    66       return null;
    6732    default:
    6833      return state;
    … …  
    7237  byId,
    7338  ids,
    74   isFetching,
    75   fetchErrorMessage,
    7639});
    7740// ACCESSORS AKA SELECTORS
    78 export const getMediaDeck = (state, id) => state[reducerMountPoint].byId[id];
    7941const getMediaDecksOverrideIds = state => state[reducerMountPoint].ids;
    8042const getMediaDecksOverrideById = state => state[reducerMountPoint].byId;
    … …  
    8446    .map(id => mediaDecksOverrideById[id])
    8547);
    86 export const getIsFetchingMediaDecksOverride = (state) => state[reducerMountPoint].isFetching;
    87 export const getFetchMediaDecksOverrideErrorMessage = (state) => state[reducerMountPoint]
    88   .fetchErrorMessage;
    89 // ACTION CREATOR VALIDATORS
    90 // ACTION CREATORS
    91 export const fetchMediaDecksOverride = (overrideIds) => (dispatch, getState) => {
    92   if (!Array.isArray(overrideIds)) throw new Error();
    93   if (getIsFetchingMediaDecksOverride(getState())) throw new Error();
    94   dispatch({
    95     type: FETCH_MEDIA_DECKS_OVERRIDE_REQUEST,
    96   });
    97   return get(overrideIds, true)
    98     .then(
    99       response => dispatch({
    100         type: FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS,
    101         response: normalize(response, mediaDecksOverrideSchema),
    102       }),
    103       error => {
    104         dispatch({
    105           type: FETCH_MEDIA_DECKS_OVERRIDE_ERROR,
    106           message: error.message,
    107         });
    108         throw new ServerException(error.message);
    109       }
    110     );
    111 };
    112 export const resetFetchMediaDecksOverrideError = () => ({
    113   type: RESET_FETCH_MEDIA_DECKS_OVERRIDE_ERROR,
     48export const setMediaDecksOverride = response => ({
     49  type: FETCH_MEDIA_DECKS_OVERRIDE_SUCCESS,
     50  response: normalize(response, mediaDecksOverrideSchema),
    11451});
    115 export const resetMediaDecksOverride = () => ({
    116   type: RESET_MEDIA_DECKS_OVERRIDE,
    117 });

  • futusign/trunk/public/screen/src/ducks/monitor.js

    r1626880 r1669808  
    11import { combineReducers } from 'redux';
    22import { ACTION_PREFIX } from '../strings';
     3// API
    34
    4 // API
    5 import { get } from '../apis/monitor';
    65// REDUCER MOUNT POINT
    76const reducerMountPoint = 'monitor';
    87// ACTIONS
    9 export const FETCH_MONITOR_REQUEST = `${ACTION_PREFIX}FETCH_MONITOR_REQUEST`;
    108export const FETCH_MONITOR_SUCCESS = `${ACTION_PREFIX}FETCH_MONITOR_SUCCESS`;
    119// SCHEMA
    … …  
    1917  }
    2018};
    21 const isFetching = (state = false, action) => {
    22   switch (action.type) {
    23     case FETCH_MONITOR_REQUEST:
    24       return true;
    25     case FETCH_MONITOR_SUCCESS:
    26       return false;
    27     default:
    28       return state;
    29   }
    30 };
    3119export default combineReducers({
    3220  value,
    33   isFetching,
    3421});
    3522// ACCESSORS AKA SELECTORS
    3623export const getMonitor = (state) => state[reducerMountPoint].value;
    37 export const getIsFetchingMonitor = (state) => state[reducerMountPoint].isFetching;
    3824// ACTION CREATOR VALIDATORS
    3925// ACTION CREATORS
    40 export const fetchMonitor = () => (dispatch, getState) => {
    41   const state = getState();
    42   if (getIsFetchingMonitor(state)) throw new Error();
    43   dispatch({
    44     type: FETCH_MONITOR_REQUEST,
    45   });
    46   return get()
    47     .then(
    48       response => dispatch({
    49         type: FETCH_MONITOR_SUCCESS,
    50         response,
    51       }).response
    52     );
    53 };
     26export const setMonitor = response => ({
     27  type: FETCH_MONITOR_SUCCESS,
     28  response,
     29});

  • futusign/trunk/public/screen/src/ducks/ovWidgets.js

    r1629524 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/ovWidgets';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'ovWidgets';
    119// ACTIONS
    12 export const FETCH_OV_WIDGETS_REQUEST = `${ACTION_PREFIX}FETCH_OV_WIDGETS_REQUEST`;
    1310export const FETCH_OV_WIDGETS_SUCCESS = `${ACTION_PREFIX}FETCH_OV_WIDGETS_SUCCESS`;
    14 export const FETCH_OV_WIDGETS_ERROR = `${ACTION_PREFIX}FETCH_OV_WIDGETS_ERROR`;
    15 export const RESET_FETCH_OV_WIDGETS_ERROR = `${ACTION_PREFIX}RESET_FETCH_OV_WIDGETS_ERROR`;
    16 export const RESET_OV_WIDGETS = `${ACTION_PREFIX}RESET_OV_WIDGETS`;
    1711// SCHEMA
    18 const slideDeckSchema = new Schema('ovWidgets');
    19 const ovWidgetsSchema = arrayOf(slideDeckSchema);
     12const ovWidgetSchema = new Schema('ovWidgets');
     13const ovWidgetsSchema = arrayOf(ovWidgetSchema);
    2014// REDUCERS
    2115const byId = (state = {}, action) => {
    … …  
    2721      };
    2822    }
    29     case RESET_OV_WIDGETS: {
    30       return {};
    31     }
    3223    default:
    3324      return state;
    … …  
    3829    case FETCH_OV_WIDGETS_SUCCESS:
    3930      return action.response.result;
    40     case RESET_OV_WIDGETS:
    41       return [];
    42     default:
    43       return state;
    44   }
    45 };
    46 const isFetching = (state = false, action) => {
    47   switch (action.type) {
    48     case FETCH_OV_WIDGETS_REQUEST:
    49       return true;
    50     case FETCH_OV_WIDGETS_SUCCESS:
    51     case FETCH_OV_WIDGETS_ERROR:
    52       return false;
    53     default:
    54       return state;
    55   }
    56 };
    57 const fetchErrorMessage = (state = null, action) => {
    58   switch (action.type) {
    59     case FETCH_OV_WIDGETS_ERROR:
    60       return action.message;
    61     case FETCH_OV_WIDGETS_REQUEST:
    62     case FETCH_OV_WIDGETS_SUCCESS:
    63       return null;
    6431    default:
    6532      return state;
    … …  
    6936  byId,
    7037  ids,
    71   isFetching,
    72   fetchErrorMessage,
    7338});
    7439// ACCESSORS AKA SELECTORS
    75 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    7640const getOvWidgetsIds = state => state[reducerMountPoint].ids;
    7741const getOvWidgetsById = state => state[reducerMountPoint].byId;
    … …  
    8044  (ovWidgetsIds, ovWidgetsById) => ovWidgetsIds.map(id => ovWidgetsById[id])
    8145);
    82 export const getIsFetchingOvWidgets = (state) => state[reducerMountPoint].isFetching;
    83 export const getFetchOvWidgetsErrorMessage = (state) => state[reducerMountPoint].fetchErrorMessage;
    84 // ACTION CREATOR VALIDATORS
    85 // ACTION CREATORS
    86 export const fetchOvWidgets = () => (dispatch, getState) => {
    87   if (getIsFetchingOvWidgets(getState())) throw new Error();
    88   dispatch({
    89     type: FETCH_OV_WIDGETS_REQUEST,
    90   });
    91   return get()
    92     .then(
    93       response => dispatch({
    94         type: FETCH_OV_WIDGETS_SUCCESS,
    95         response: normalize(response, ovWidgetsSchema),
    96       }),
    97       error => {
    98         dispatch({
    99           type: FETCH_OV_WIDGETS_ERROR,
    100           message: error.message,
    101         });
    102         throw new ServerException(error.message);
    103       }
    104     );
    105 };
    106 export const resetFetchOvWidgetsError = () => ({
    107   type: RESET_FETCH_OV_WIDGETS_ERROR,
     46export const setOvWidgets = response => ({
     47  type: FETCH_OV_WIDGETS_SUCCESS,
     48  response: normalize(response, ovWidgetsSchema),
    10849});
    109 export const resetOvWidgets = () => ({
    110   type: RESET_OV_WIDGETS,
    111 });

  • futusign/trunk/public/screen/src/ducks/overlay.js

    r1629524 r1669808  
    22import { ACTION_PREFIX } from '../strings';
    33// API
    4 import { get } from '../apis/overlay';
    54
    65// REDUCER MOUNT POINT
    76const reducerMountPoint = 'overlay';
    87// ACTIONS
    9 export const FETCH_OVERLAY_REQUEST = `${ACTION_PREFIX}FETCH_OVERLAY_REQUEST`;
    108export const FETCH_OVERLAY_SUCCESS = `${ACTION_PREFIX}FETCH_OVERLAY_SUCCESS`;
    11 export const FETCH_OVERLAY_ERROR = `${ACTION_PREFIX}FETCH_OVERLAY_ERROR`;
    12 export const RESET_FETCH_OVERLAY_ERROR = `${ACTION_PREFIX}RESET_FETCH_OVERLAY_ERROR`;
    139// SCHEMA
    1410// REDUCERS
    … …  
    2117  }
    2218};
    23 const isFetching = (state = false, action) => {
    24   switch (action.type) {
    25     case FETCH_OVERLAY_REQUEST:
    26       return true;
    27     case FETCH_OVERLAY_SUCCESS:
    28     case FETCH_OVERLAY_ERROR:
    29       return false;
    30     default:
    31       return state;
    32   }
    33 };
    34 const fetchErrorMessage = (state = null, action) => {
    35   switch (action.type) {
    36     case FETCH_OVERLAY_ERROR:
    37       return action.message;
    38     case FETCH_OVERLAY_REQUEST:
    39     case FETCH_OVERLAY_SUCCESS:
    40     case RESET_FETCH_OVERLAY_ERROR:
    41       return null;
    42     default:
    43       return state;
    44   }
    45 };
    4619export default combineReducers({
    4720  value,
    48   isFetching,
    49   fetchErrorMessage,
    5021});
    5122// ACCESSORS AKA SELECTORS
    5223export const getOverlay = (state) => state[reducerMountPoint].value;
    53 export const getIsFetchingOverlay = (state) => state[reducerMountPoint].isFetching;
    54 export const getFetchOverlayErrorMessage = (state) => state[reducerMountPoint].fetchErrorMessage;
    5524// ACTION CREATOR VALIDATORS
    5625// ACTION CREATORS
    57 export const fetchOverlay = (id) => (dispatch, getState) => {
    58   const state = getState();
    59   if (getIsFetchingOverlay(state)) throw new Error();
    60   dispatch({
    61     type: FETCH_OVERLAY_REQUEST,
    62   });
    63   return get(id)
    64     .then(
    65       response => dispatch({
    66         type: FETCH_OVERLAY_SUCCESS,
    67         response,
    68       }).response
    69     );
    70 };
    71 export const resetFetchOverlayError = () => ({
    72   type: RESET_FETCH_OVERLAY_ERROR,
     26export const setOverlay = response => ({
     27  type: FETCH_OVERLAY_SUCCESS,
     28  response,
    7329});

  • futusign/trunk/public/screen/src/ducks/screen.js

    r1626880 r1669808  
    22import { ACTION_PREFIX, SCREEN_ID } from '../strings';
    33import { ServerException } from '../util/exceptions';
     4import { setImages } from './images';
     5import { setImagesOverride } from './imagesOverride';
     6import { setWebs } from './webs';
     7import { setWebsOverride } from './websOverride';
     8import { setYoutubeVideos } from './youtubeVideos';
     9import { setYoutubeVideosOverride } from './youtubeVideosOverride';
     10import { setSlideDecks } from './slideDecks';
     11import { setSlideDecksOverride } from './slideDecksOverride';
     12import { setLayers } from './layers';
     13import { setMediaDecks } from './mediaDecks';
     14import { setMediaDecksOverride } from './mediaDecksOverride';
     15import { setOverlay } from './overlay';
     16import { setOvWidgets } from './ovWidgets';
     17import { setMonitor } from './monitor';
    418// API
    5 import { get } from '../apis/screen';
     19import { get } from '../apis/endpoint';
     20
    621// REDUCER MOUNT POINT
    722const reducerMountPoint = 'screen';
    … …  
    1530const value = (state = {
    1631  id: SCREEN_ID,
    17   title: null,
    18   subscribedPlaylistIds: [],
    1932}, action) => {
    2033  switch (action.type) {
    … …  
    6881  return get(screen.id)
    6982    .then(
    70       response => dispatch({
    71         type: FETCH_SCREEN_SUCCESS,
    72         response,
    73       }).response,
     83      response => {
     84        dispatch({
     85          type: FETCH_SCREEN_SUCCESS,
     86          response: response.screen,
     87        });
     88        dispatch(setImages(response.images));
     89        dispatch(setImagesOverride(response.imagesOverride));
     90        dispatch(setMediaDecks(response.mediaDecks));
     91        dispatch(setMediaDecksOverride(response.mediaDecksOverride));
     92        dispatch(setWebs(response.webs));
     93        dispatch(setWebsOverride(response.websOverride));
     94        dispatch(setYoutubeVideos(response.youtubeVideos));
     95        dispatch(setYoutubeVideosOverride(response.youtubeVideosOverride));
     96        dispatch(setSlideDecks(response.slideDecks));
     97        dispatch(setSlideDecksOverride(response.slideDecksOverride));
     98        dispatch(setLayers(response.layers));
     99        dispatch(setOverlay(response.overlay));
     100        dispatch(setOvWidgets(response.ovWidgets));
     101        dispatch(setMonitor(response.monitor));
     102        return response;
     103      },
    74104      error => {
    75105        dispatch({

  • futusign/trunk/public/screen/src/ducks/slideDecks.js

    r1602262 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/slideDecks';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'slideDecks';
    119// ACTIONS
    12 export const FETCH_SLIDE_DECKS_REQUEST = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_REQUEST`;
    1310export const FETCH_SLIDE_DECKS_SUCCESS = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_SUCCESS`;
    14 export const FETCH_SLIDE_DECKS_ERROR = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_ERROR`;
    15 export const RESET_FETCH_SLIDE_DECKS_ERROR = `${ACTION_PREFIX}RESET_FETCH_SLIDE_DECKS_ERROR`;
    16 export const RESET_SLIDE_DECKS = `${ACTION_PREFIX}RESET_SLIDE_DECKS`;
    1711// SCHEMA
    1812const slideDeckSchema = new Schema('slideDecks');
    … …  
    2721      };
    2822    }
    29     case RESET_SLIDE_DECKS: {
    30       return {};
    31     }
    3223    default:
    3324      return state;
    … …  
    3829    case FETCH_SLIDE_DECKS_SUCCESS:
    3930      return action.response.result;
    40     case RESET_SLIDE_DECKS:
    41       return [];
    42     default:
    43       return state;
    44   }
    45 };
    46 const isFetching = (state = false, action) => {
    47   switch (action.type) {
    48     case FETCH_SLIDE_DECKS_REQUEST:
    49       return true;
    50     case FETCH_SLIDE_DECKS_SUCCESS:
    51     case FETCH_SLIDE_DECKS_ERROR:
    52       return false;
    53     default:
    54       return state;
    55   }
    56 };
    57 const fetchErrorMessage = (state = null, action) => {
    58   switch (action.type) {
    59     case FETCH_SLIDE_DECKS_ERROR:
    60       return action.message;
    61     case FETCH_SLIDE_DECKS_REQUEST:
    62     case FETCH_SLIDE_DECKS_SUCCESS:
    63       return null;
    6431    default:
    6532      return state;
    … …  
    6936  byId,
    7037  ids,
    71   isFetching,
    72   fetchErrorMessage,
    7338});
    7439// ACCESSORS AKA SELECTORS
    75 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    7640const getSlideDecksIds = state => state[reducerMountPoint].ids;
    7741const getSlideDecksById = state => state[reducerMountPoint].byId;
    … …  
    8044  (slideDecksIds, slideDecksById) => slideDecksIds.map(id => slideDecksById[id])
    8145);
    82 export const getIsFetchingSlideDecks = (state) => state[reducerMountPoint].isFetching;
    83 export const getFetchSlideDecksErrorMessage = (state) => state[reducerMountPoint].fetchErrorMessage;
    84 // ACTION CREATOR VALIDATORS
    85 // ACTION CREATORS
    86 export const fetchSlideDecks = (playlistIds) => (dispatch, getState) => {
    87   if (!Array.isArray(playlistIds)) throw new Error();
    88   if (getIsFetchingSlideDecks(getState())) throw new Error();
    89   dispatch({
    90     type: FETCH_SLIDE_DECKS_REQUEST,
    91   });
    92   return get(playlistIds)
    93     .then(
    94       response => dispatch({
    95         type: FETCH_SLIDE_DECKS_SUCCESS,
    96         response: normalize(response, slideDecksSchema),
    97       }),
    98       error => {
    99         dispatch({
    100           type: FETCH_SLIDE_DECKS_ERROR,
    101           message: error.message,
    102         });
    103         throw new ServerException(error.message);
    104       }
    105     );
    106 };
    107 export const resetFetchSlideDecksError = () => ({
    108   type: RESET_FETCH_SLIDE_DECKS_ERROR,
     46export const setSlideDecks = response => ({
     47  type: FETCH_SLIDE_DECKS_SUCCESS,
     48  response: normalize(response, slideDecksSchema),
    10949});
    110 export const resetSlideDecks = () => ({
    111   type: RESET_SLIDE_DECKS,
    112 });

  • futusign/trunk/public/screen/src/ducks/slideDecksOverride.js

    r1651645 r1669808  
    33import { createSelector } from 'reselect';
    44import { ACTION_PREFIX } from '../strings';
    5 import { ServerException } from '../util/exceptions';
    65// API
    7 import { get } from '../apis/slideDecks';
    86
    97// REDUCER MOUNT POINT
    108const reducerMountPoint = 'slideDecksOverride';
    119// ACTIONS
    12 export const FETCH_SLIDE_DECKS_OVERRIDE_REQUEST
    13   = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_OVERRIDE_REQUEST`;
    14 export const FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS
    15   = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS`;
    16 export const FETCH_SLIDE_DECKS_OVERRIDE_ERROR = `${ACTION_PREFIX}FETCH_SLIDE_DECKS_OVERRIDE_ERROR`;
    17 export const RESET_FETCH_SLIDE_DECKS_OVERRIDE_ERROR
    18   = `${ACTION_PREFIX}RESET_FETCH_SLIDE_DECKS_OVERRIDE_ERROR`;
    19 export const RESET_SLIDE_DECKS_OVERRIDE = `${ACTION_PREFIX}RESET_SLIDE_DECKS_OVERRIDE`;
     10export const FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS =
     11  `${ACTION_PREFIX}FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS`;
    2012// SCHEMA
    21 const slideDeckSchema = new Schema('slideDecks');
    22 const slideDecksOverrideSchema = arrayOf(slideDeckSchema);
     13const slideDeckOverrideSchema = new Schema('slideDecksOverride');
     14const slideDecksOverrideSchema = arrayOf(slideDeckOverrideSchema);
    2315// REDUCERS
    2416const byId = (state = {}, action) => {
    … …  
    2719      return {
    2820        ...state,
    29         ...action.response.entities.slideDecks,
     21        ...action.response.entities.slideDecksOverride,
    3022      };
    31     }
    32     case RESET_SLIDE_DECKS_OVERRIDE: {
    33       return {};
    3423    }
    3524    default:
    … …  
    4130    case FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS:
    4231      return action.response.result;
    43     case RESET_SLIDE_DECKS_OVERRIDE:
    44       return [];
    45     default:
    46       return state;
    47   }
    48 };
    49 const isFetching = (state = false, action) => {
    50   switch (action.type) {
    51     case FETCH_SLIDE_DECKS_OVERRIDE_REQUEST:
    52       return true;
    53     case FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS:
    54     case FETCH_SLIDE_DECKS_OVERRIDE_ERROR:
    55       return false;
    56     default:
    57       return state;
    58   }
    59 };
    60 const fetchErrorMessage = (state = null, action) => {
    61   switch (action.type) {
    62     case FETCH_SLIDE_DECKS_OVERRIDE_ERROR:
    63       return action.message;
    64     case FETCH_SLIDE_DECKS_OVERRIDE_REQUEST:
    65     case FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS:
    66       return null;
    6732    default:
    6833      return state;
    … …  
    7237  byId,
    7338  ids,
    74   isFetching,
    75   fetchErrorMessage,
    7639});
    7740// ACCESSORS AKA SELECTORS
    78 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    7941const getSlideDecksOverrideIds = state => state[reducerMountPoint].ids;
    8042const getSlideDecksOverrideById = state => state[reducerMountPoint].byId;
    … …  
    8446    .map(id => slideDecksOverrideById[id])
    8547);
    86 export const getIsFetchingSlideDecksOverride = (state) => state[reducerMountPoint].isFetching;
    87 export const getFetchSlideDecksOverrideErrorMessage = (state) => state[reducerMountPoint]
    88   .fetchErrorMessage;
    89 // ACTION CREATOR VALIDATORS
    90 // ACTION CREATORS
    91 export const fetchSlideDecksOverride = (overrideIds) => (dispatch, getState) => {
    92   if (!Array.isArray(overrideIds)) throw new Error();
    93   if (getIsFetchingSlideDecksOverride(getState())) throw new Error();
    94   dispatch({
    95     type: FETCH_SLIDE_DECKS_OVERRIDE_REQUEST,
    96   });
    97   return get(overrideIds, true)
    98     .then(
    99       response => dispatch({
    100         type: FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS,
    101         response: normalize(response, slideDecksOverrideSchema),
    102       }),
    103       error => {
    104         dispatch({
    105           type: FETCH_SLIDE_DECKS_OVERRIDE_ERROR,
    106           message: error.message,
    107         });
    108         throw new ServerException(error.message);
    109       }
    110     );
    111 };
    112 export const resetFetchSlideDecksOverrideError = () => ({
    113   type: RESET_FETCH_SLIDE_DECKS_OVERRIDE_ERROR,
     48export const setSlideDecksOverride = response => ({
     49  type: FETCH_SLIDE_DECKS_OVERRIDE_SUCCESS,
     50  response: normalize(response, slideDecksOverrideSchema),
    11451});
    115 export const resetSlideDecksOverride = () => ({
    116   type: RESET_SLIDE_DECKS_OVERRIDE,
    117 });

  • futusign/trunk/public/screen/src/ducks/webs.js

    r1649894 r1669808  
    44import { ACTION_PREFIX } from '../strings';
    55// API
    6 import { get } from '../apis/webs';
    76
    87// REDUCER MOUNT POINT
    98const reducerMountPoint = 'webs';
    109// ACTIONS
    11 export const FETCH_WEBS_REQUEST = `${ACTION_PREFIX}FETCH_WEBS_REQUEST`;
    1210export const FETCH_WEBS_SUCCESS = `${ACTION_PREFIX}FETCH_WEBS_SUCCESS`;
    13 export const RESET_WEBS = `${ACTION_PREFIX}RESET_WEBS`;
    1411// SCHEMA
    15 const layerSchema = new Schema('webs');
    16 const websSchema = arrayOf(layerSchema);
     12const webSchema = new Schema('webs');
     13const websSchema = arrayOf(webSchema);
    1714// REDUCERS
    1815const byId = (state = {}, action) => {
    … …  
    2421      };
    2522    }
    26     case RESET_WEBS: {
    27       return {};
    28     }
    2923    default:
    3024      return state;
    … …  
    3529    case FETCH_WEBS_SUCCESS:
    3630      return action.response.result;
    37     case RESET_WEBS:
    38       return [];
    39     default:
    40       return state;
    41   }
    42 };
    43 const isFetching = (state = false, action) => {
    44   switch (action.type) {
    45     case FETCH_WEBS_REQUEST:
    46       return true;
    47     case FETCH_WEBS_SUCCESS:
    48       return false;
    4931    default:
    5032      return state;
    … …  
    5436  byId,
    5537  ids,
    56   isFetching,
    5738});
    5839// ACCESSORS AKA SELECTORS
    59 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    6040const getWebsIds = state => state[reducerMountPoint].ids;
    6141const getWebsById = state => state[reducerMountPoint].byId;
    … …  
    6444  (websIds, websById) => websIds.map(id => websById[id])
    6545);
    66 export const getIsFetchingWebs = (state) => state[reducerMountPoint].isFetching;
    67 // ACTION CREATOR VALIDATORS
    68 // ACTION CREATORS
    69 export const fetchWebs = (playlistIds) => (dispatch, getState) => {
    70   if (!Array.isArray(playlistIds)) throw new Error();
    71   if (getIsFetchingWebs(getState())) throw new Error();
    72   dispatch({
    73     type: FETCH_WEBS_REQUEST,
    74   });
    75   return get(playlistIds)
    76     .then(
    77       response => dispatch({
    78         type: FETCH_WEBS_SUCCESS,
    79         response: normalize(response, websSchema),
    80       })
    81     );
    82 };
    83 export const resetWebs = () => ({
    84   type: RESET_WEBS,
     46export const setWebs = response => ({
     47  type: FETCH_WEBS_SUCCESS,
     48  response: normalize(response, websSchema),
    8549});

  • futusign/trunk/public/screen/src/ducks/youtubeVideos.js

    r1626880 r1669808  
    44import { ACTION_PREFIX } from '../strings';
    55// API
    6 import { get } from '../apis/youtubeVideos';
    76
    87// REDUCER MOUNT POINT
    98const reducerMountPoint = 'youtubeVideos';
    109// ACTIONS
    11 export const FETCH_YOUTUBE_VIDEOS_REQUEST = `${ACTION_PREFIX}FETCH_YOUTUBE_VIDEOS_REQUEST`;
    1210export const FETCH_YOUTUBE_VIDEOS_SUCCESS = `${ACTION_PREFIX}FETCH_YOUTUBE_VIDEOS_SUCCESS`;
    13 export const RESET_YOUTUBE_VIDEOS = `${ACTION_PREFIX}RESET_YOUTUBE_VIDEOS`;
    1411// SCHEMA
    1512const youtubeVideoSchema = new Schema('youtubeVideos');
    … …  
    2421      };
    2522    }
    26     case RESET_YOUTUBE_VIDEOS: {
    27       return {};
    28     }
    2923    default:
    3024      return state;
    … …  
    3529    case FETCH_YOUTUBE_VIDEOS_SUCCESS:
    3630      return action.response.result;
    37     case RESET_YOUTUBE_VIDEOS:
    38       return [];
    39     default:
    40       return state;
    41   }
    42 };
    43 const isFetching = (state = false, action) => {
    44   switch (action.type) {
    45     case FETCH_YOUTUBE_VIDEOS_REQUEST:
    46       return true;
    47     case FETCH_YOUTUBE_VIDEOS_SUCCESS:
    48       return false;
    4931    default:
    5032      return state;
    … …  
    5436  byId,
    5537  ids,
    56   isFetching,
    5738});
    5839// ACCESSORS AKA SELECTORS
    59 export const getSlideDeck = (state, id) => state[reducerMountPoint].byId[id];
    6040const getYoutubeVideosIds = state => state[reducerMountPoint].ids;
    6141const getYoutubeVideosById = state => state[reducerMountPoint].byId;
    … …  
    6444  (youtubeVideosIds, youtubeVideosById) => youtubeVideosIds.map(id => youtubeVideosById[id])
    6545);
    66 export const getIsFetchingYoutubeVideos = (state) => state[reducerMountPoint].isFetching;
    67 // ACTION CREATOR VALIDATORS
    68 // ACTION CREATORS
    69 export const fetchYoutubeVideos = (playlistIds) => (dispatch, getState) => {
    70   if (!Array.isArray(playlistIds)) throw new Error();
    71   if (getIsFetchingYoutubeVideos(getState())) throw new Error();
    72   dispatch({
    73     type: FETCH_YOUTUBE_VIDEOS_REQUEST,
    74   });
    75   return get(playlistIds)
    76     .then(
    77       response => dispatch({
    78         type: FETCH_YOUTUBE_VIDEOS_SUCCESS,
    79         response: normalize(response, youtubeVideosSchema),
    80       })
    81     );
    82 };
    83 export const resetYoutubeVideos = () => ({
    84   type: RESET_YOUTUBE_VIDEOS,
     46export const setYoutubeVideos = response => ({
     47  type: FETCH_YOUTUBE_VIDEOS_SUCCESS,
     48  response: normalize(response, youtubeVideosSchema),
    8549});

  • futusign/trunk/public/screen/src/index.html

    r1649894 r1669808  
    8888    window.siteUrl = '/data/';
    8989    window.publicPath = '/';
    90     window.screenId = 80;
     90    window.screenId = 0;
    9191  </script>
    9292</body>

  • futusign/trunk/public/screen/src/strings.js

    r1665899 r1669808  
    33export const SITE_URL = window.siteUrl;
    44export const SCREEN_ID = window.screenId;
    5 export const SCREENS_API_ENDPOINT = 'fs-screens';
    6 export const SLIDE_DECKS_API_ENDPOINT = 'fs-slide-decks';
    7 export const MEDIA_DECKS_API_ENDPOINT = 'fs-media-decks';
    8 export const WEBS_API_ENDPOINT = 'fs-webs';
    9 export const YOUTUBE_VIDEOS_API_ENDPOINT = 'fs-youtube-videos';
    10 export const IMAGES_API_ENDPOINT = 'fs-images';
    11 export const LAYERS_API_ENDPOINT = 'fs-layers';
    12 export const MONITOR_API_ENDPOINT = 'fs-monitor';
    13 export const OVERLAYS_API_ENDPOINT = 'fs-overlays';
    14 export const OVERRIDES_API_ENDPOINT = 'fs-overrides';
     5export const ENDPOINT_API_ENDPOINT = 'fs-endpoint';
    156export const CACHE_INTERVAL = 60 * 60;
    16 export const POLLING_INTERVAL = 60 * 60;
    17 export const OV_WIDGETS_API_ENDPOINT = 'fs-ov-widgets';
     7export const ERROR_POLLING_INTERVAL = 60;
    188// PLAYERS
    199export const TRANSITION = 'TRANSITION';

  • futusign/trunk/readme.txt

    r1665899 r1669808  
    44Requires at least: 4.3
    55Tested up to: 4.7
    6 Stable tag: 2.1.1
     6Stable tag: 2.2.0
    77License: GPLv2 or later
    88License URI: https://www.gnu.org/licenses/gpl.html
    … …  
    2222
    2323== Changelog ==
     24
     25= 2.2.0 =
     26
     27Enhancement: Currently playing / layers summary on screens.
     28
     29Enhancement: Screen polling cycle choice; default hour.
     30
     31Enhancement: No longer dependent on ACF to Rest plugin.
     32
     33Performance fix: Collapsed poll from 10+ polls to a single poll.
    2434
    2535= 2.1.1 =
Note: See TracChangeset for help on using the changeset viewer.