Example #1
0
    def post(self):
        asset = prepare_asset_v1_2(request)
        if url_fails(asset['uri']):
            raise Exception("Could not retrieve file. Check the asset URL.")
        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]

            asset = assets_helper.create(conn, asset)

            if asset['is_active']:
                ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])
            assets_helper.save_ordering(conn, ids_of_active_assets)
            return assets_helper.read(conn, asset['asset_id']), 201
Example #2
0
    def post(self):
        request_environ = Request(request.environ)
        asset = prepare_asset_v1_2(request_environ, unique_name=True)
        if not asset['skip_asset_check'] and url_fails(asset['uri']):
            raise Exception("Could not retrieve file. Check the asset URL.")
        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]

            asset = assets_helper.create(conn, asset)

            if asset['is_active']:
                ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])
            assets_helper.save_ordering(conn, ids_of_active_assets)
            return assets_helper.read(conn, asset['asset_id']), 201
Example #3
0
    def test_edit_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit(main_page_url)
            wait_for_and_do(browser, '.edit-asset-button',
                            lambda btn: btn.click())
            sleep(1)

            wait_for_and_do(browser, 'input[name="duration"]',
                            lambda field: field.fill('333'))
            sleep(1)  # wait for new-asset panel animation

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['duration'], u'333')
Example #4
0
    def test_add_asset_streaming(self):
        with Browser() as browser:
            browser.visit(main_page_url)

            wait_for_and_do(browser, '#add-asset-button',
                            lambda btn: btn.click())
            sleep(1)

            wait_for_and_do(
                browser, 'input[name="uri"]', lambda field: field.fill(
                    'rtmp://localhost:1935/app/video.flv'))
            sleep(1)

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(10)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['name'],
                             u'rtmp://localhost:1935/app/video.flv')
            self.assertEqual(asset['uri'],
                             u'rtmp://localhost:1935/app/video.flv')
            self.assertEqual(asset['mimetype'], u'streaming')
            self.assertEqual(asset['duration'],
                             settings['default_streaming_duration'])
Example #5
0
    def test_add_asset_url(self):
        with Browser() as browser:
            browser.visit(main_page_url)

            wait_for_and_do(browser, '#add-asset-button',
                            lambda btn: btn.click())
            sleep(1)

            wait_for_and_do(browser, 'input[name="uri"]',
                            lambda field: field.fill('http://example.com'))
            sleep(1)

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['name'], u'http://example.com')
            self.assertEqual(asset['uri'], u'http://example.com')
            self.assertEqual(asset['mimetype'], u'webpage')
            self.assertEqual(asset['duration'], settings['default_duration'])
Example #6
0
    def test_add_asset_streaming(self):
        with Browser() as browser:
            browser.visit(main_page_url)

            wait_for_and_do(browser, '#add-asset-button', lambda btn: btn.click())
            sleep(1)

            wait_for_and_do(browser, 'input[name="uri"]', lambda field: field.fill('rtmp://localhost:1935/app/video.flv'))
            sleep(1)

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(10)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['name'], u'rtmp://localhost:1935/app/video.flv')
            self.assertEqual(asset['uri'], u'rtmp://localhost:1935/app/video.flv')
            self.assertEqual(asset['mimetype'], u'streaming')
            self.assertEqual(asset['duration'], settings['default_streaming_duration'])
Example #7
0
    def test_add_asset_url(self):
        with Browser() as browser:
            browser.visit('http://localhost:8080')

            wait_for_and_do(browser, '#add-asset-button', lambda btn: btn.click())
            sleep(1)
            wait_for_and_do(browser, 'input[name="uri"]', lambda field: field.fill('http://example.com'))
            wait_for_and_do(browser, 'input[name="duration"]', lambda field: field.fill('30'))
            sleep(1)
            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['name'], u'http://example.com')
            self.assertEqual(asset['uri'], u'http://example.com')
            self.assertEqual(asset['mimetype'], u'webpage')
            self.assertEqual(asset['duration'], u'30')
Example #8
0
    def test_add_asset_video_upload(self):
        video_file = '/tmp/video.mov'

        with Browser() as browser:
            browser.visit('http://localhost:8080')

            browser.find_by_id('add-asset-button').click()
            sleep(1)

            wait_for_and_do(browser, 'a[href="#tab-file_upload"]', lambda tab: tab.click())
            wait_for_and_do(browser, 'input[name="file_upload"]', lambda input: input.fill(video_file))
            sleep(1)  # wait for new-asset panel animation

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['name'], u'video.mov')
            self.assertEqual(asset['mimetype'], u'video')
            self.assertEqual(asset['duration'], u'33')
Example #9
0
    def get(self, asset_id):
        with db.conn(settings['database']) as conn:
            asset = assets_helper.read(conn, asset_id)

        if isinstance(asset, list):
            raise Exception('Invalid asset ID provided')

        if path.isfile(asset['uri']):
            filename = asset['name']

            with open(asset['uri'], 'rb') as f:
                content = f.read()

            mimetype = guess_type(filename)[0]
            if not mimetype:
                mimetype = 'application/octet-stream'

            result = {
                'type': 'file',
                'filename': filename,
                'content': b64encode(content),
                'mimetype': mimetype
            }
        else:
            result = {
                'type': 'url',
                'url': asset['uri']
            }

        return result
Example #10
0
    def test_edit_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit('http://localhost:8080')
            wait_for_and_do(browser, '.edit-asset-button', lambda btn: btn.click())
            sleep(1)

            wait_for_and_do(browser, 'input[name="duration"]', lambda field: field.fill('333'))
            sleep(1)  # wait for new-asset panel animation

            wait_for_and_do(browser, '#add-form', lambda form: form.click())
            sleep(1)

            wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 1)
            asset = assets[0]

            self.assertEqual(asset['duration'], u'333')
Example #11
0
    def test_add_two_assets_upload(self):
        video_file = '/tmp/video.flv'
        image_file = '/tmp/image.png'

        with Browser() as browser:
            browser.visit(main_page_url)

            browser.find_by_id('add-asset-button').click()
            sleep(1)

            wait_for_and_do(browser, 'a[href="#tab-file_upload"]', lambda tab: tab.click())
            wait_for_and_do(browser, 'input[name="file_upload"]', lambda input: input.fill(image_file))
            wait_for_and_do(browser, 'input[name="file_upload"]', lambda input: input.fill(video_file))

            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 2)

            self.assertEqual(assets[0]['name'], u'image.png')
            self.assertEqual(assets[0]['mimetype'], u'image')
            self.assertEqual(assets[0]['duration'], settings['default_duration'])

            self.assertEqual(assets[1]['name'], u'video.flv')
            self.assertEqual(assets[1]['mimetype'], u'video')
            self.assertEqual(assets[1]['duration'], u'54')
Example #12
0
    def test_add_two_assets_upload(self):
        video_file = '/tmp/video.flv'
        image_file = '/tmp/image.png'

        with Browser() as browser:
            browser.visit(main_page_url)

            browser.find_by_id('add-asset-button').click()
            sleep(1)

            wait_for_and_do(browser, 'a[href="#tab-file_upload"]',
                            lambda tab: tab.click())
            wait_for_and_do(browser, 'input[name="file_upload"]',
                            lambda input: input.fill(image_file))
            wait_for_and_do(browser, 'input[name="file_upload"]',
                            lambda input: input.fill(video_file))

            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)

            self.assertEqual(len(assets), 2)

            self.assertEqual(assets[0]['name'], u'image.png')
            self.assertEqual(assets[0]['mimetype'], u'image')
            self.assertEqual(assets[0]['duration'],
                             settings['default_duration'])

            self.assertEqual(assets[1]['name'], u'video.flv')
            self.assertEqual(assets[1]['mimetype'], u'video')
            self.assertEqual(assets[1]['duration'], u'54')
Example #13
0
    def get(self, asset_id):
        with db.conn(settings['database']) as conn:
            asset = assets_helper.read(conn, asset_id)

        if isinstance(asset, list):
            raise Exception('Invalid asset ID provided')

        if path.isfile(asset['uri']):
            filename = asset['name']

            with open(asset['uri'], 'rb') as f:
                content = f.read()

            mimetype = guess_type(filename)[0]
            if not mimetype:
                mimetype = 'application/octet-stream'

            result = {
                'type': 'file',
                'filename': filename,
                'content': b64encode(content),
                'mimetype': mimetype
            }
        else:
            result = {'type': 'url', 'url': asset['uri']}

        return result
Example #14
0
    def put(self, asset_id):
        asset = prepare_asset_v1_2(request, asset_id)
        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]

            asset = assets_helper.update(conn, asset_id, asset)

            try:
                ids_of_active_assets.remove(asset['asset_id'])
            except ValueError:
                pass
            if asset['is_active']:
                ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])

            assets_helper.save_ordering(conn, ids_of_active_assets)
            return assets_helper.read(conn, asset_id)
Example #15
0
    def test_create_update_read_asset_utf8(self):
        assets_helper.create(self.conn, asset_w)
        asset_w_ = asset_w.copy()
        asset_w_.update(**asset_w_diff)
        assets_helper.update(self.conn, asset_w['asset_id'], asset_w_)

        should_be_w_ = assets_helper.read(self.conn)
        self.assertEqual([asset_w_], should_be_w_)
Example #16
0
    def put(self, asset_id):
        asset = prepare_asset_v1_2(request, asset_id)
        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]

            asset = assets_helper.update(conn, asset_id, asset)

            try:
                ids_of_active_assets.remove(asset['asset_id'])
            except ValueError:
                pass
            if asset['is_active']:
                ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])

            assets_helper.save_ordering(conn, ids_of_active_assets)
            return assets_helper.read(conn, asset_id)
Example #17
0
    def test_create_update_read_asset_utf8(self):
        assets_helper.create(self.conn, asset_w)
        asset_w_ = asset_w.copy()
        asset_w_.update(**asset_w_diff)
        assets_helper.update(self.conn, asset_w['asset_id'], asset_w_)

        should_be_w_ = assets_helper.read(self.conn)
        self.assertEqual([asset_w_], should_be_w_)
Example #18
0
    def test_set_order_empty(self):
        assets = [asset_x, asset_y, asset_z]

        assets_helper.create_multiple(self.conn, assets)
        assets_helper.save_ordering(self.conn, [])

        fetched = assets_helper.read(self.conn)

        self.assertEquals([0, 0, 0], [asset['play_order'] for asset in fetched])
Example #19
0
def remove_asset(asset_id):
    asset = assets_helper.read(db_conn, asset_id)
    try:
        if asset['uri'].startswith(settings['assetdir']):
            os.remove(asset['uri'])
    except OSError:
        pass
    assets_helper.delete(db_conn, asset_id)
    response.status = 204  # return an OK with no content
Example #20
0
    def test_create_delete_asset(self):
        assets_helper.create(self.conn, asset_x)
        assets_helper.delete(self.conn, asset_x['asset_id'])

        assets_helper.create(self.conn, asset_y)
        assets_helper.delete(self.conn, asset_y['asset_id'])

        should_be_empty = assets_helper.read(self.conn)
        self.assertEmpty(should_be_empty)
Example #21
0
def remove_asset(asset_id):
    asset = assets_helper.read(db_conn, asset_id)
    try:
        if asset['uri'].startswith(settings['assetdir']):
            os.remove(asset['uri'])
    except OSError:
        pass
    assets_helper.delete(db_conn, asset_id)
    response.status = 204  # return an OK with no content
Example #22
0
    def test_create_delete_asset(self):
        assets_helper.create(self.conn, asset_x)
        assets_helper.delete(self.conn, asset_x['asset_id'])

        assets_helper.create(self.conn, asset_y)
        assets_helper.delete(self.conn, asset_y['asset_id'])

        should_be_empty = assets_helper.read(self.conn)
        self.assertEmpty(should_be_empty)
Example #23
0
 def delete(self, asset_id):
     with db.conn(settings['database']) as conn:
         asset = assets_helper.read(conn, asset_id)
         try:
             if asset['uri'].startswith(settings['assetdir']):
                 remove(asset['uri'])
         except OSError:
             pass
         assets_helper.delete(conn, asset_id)
         return '', 204  # return an OK with no content
Example #24
0
    def test_set_order_empty(self):
        assets = [asset_x, asset_y, asset_z]

        assets_helper.create_multiple(self.conn, assets)
        assets_helper.save_ordering(self.conn, [])

        fetched = assets_helper.read(self.conn)

        self.assertEquals([0, 0, 0],
                          [asset['play_order'] for asset in fetched])
Example #25
0
 def delete(self, asset_id):
     with db.conn(settings['database']) as conn:
         asset = assets_helper.read(conn, asset_id)
         try:
             if asset['uri'].startswith(settings['assetdir']):
                 remove(asset['uri'])
         except OSError:
             pass
         assets_helper.delete(conn, asset_id)
         return '', 204  # return an OK with no content
Example #26
0
    def test_create_update_read_asset(self):
        assets_helper.create(self.conn, asset_x)
        asset_x_ = asset_x.copy()
        asset_x_.update(**asset_x_diff)
        assets_helper.update(self.conn, asset_x['asset_id'], asset_x_)

        assets_helper.create(self.conn, asset_y)
        asset_y_ = asset_y.copy()
        asset_y_.update(**asset_y_diff)
        assets_helper.update(self.conn, asset_y['asset_id'], asset_y_)

        should_be_y__x_ = assets_helper.read(self.conn)
        self.assertEqual([asset_y_, asset_x_], should_be_y__x_)
Example #27
0
    def post(self):
        asset = prepare_asset_v1_2(request)
        if url_fails(asset['uri']):
            raise Exception("Could not retrieve file. Check the asset URL.")
        with db.conn(settings['database']) as conn:
            if (asset['mimetype'] == 'presentation'
                    or asset['mimetype'] == 'pdf'):
                createMultipleAssetsFromPresentationOrPdf(asset, conn)
                #return assets_helper.read(conn, asset['asset_id']),201
            else:
                assets = assets_helper.read(conn)
                ids_of_active_assets = [
                    x['asset_id'] for x in assets if x['is_active']
                ]

                asset = assets_helper.create(conn, asset)

                if asset['is_active']:
                    ids_of_active_assets.insert(asset['play_order'],
                                                asset['asset_id'])
                assets_helper.save_ordering(conn, ids_of_active_assets)
                return assets_helper.read(conn, asset['asset_id']), 201
Example #28
0
    def test_create_update_read_asset(self):
        assets_helper.create(self.conn, asset_x)
        asset_x_ = asset_x.copy()
        asset_x_.update(**asset_x_diff)
        assets_helper.update(self.conn, asset_x['asset_id'], asset_x_)

        assets_helper.create(self.conn, asset_y)
        asset_y_ = asset_y.copy()
        asset_y_.update(**asset_y_diff)
        assets_helper.update(self.conn, asset_y['asset_id'], asset_y_)

        should_be_y__x_ = assets_helper.read(self.conn)
        self.assertEqual([asset_y_, asset_x_], should_be_y__x_)
Example #29
0
    def test_reorder_asset(self):
        with db.conn(settings['database']) as conn:
            _asset_x = asset_x.copy()
            _asset_x['is_enabled'] = 1
            assets_helper.create(conn, _asset_x)
            assets_helper.create(conn, asset_y)

        with Browser() as browser:
            browser.visit('http://localhost:8080')

            asset_x_for_drag = browser.find_by_id(asset_x['asset_id'])
            sleep(1)

            asset_y_to_reorder = browser.find_by_id(asset_y['asset_id'])
            asset_x_for_drag.drag_and_drop(asset_y_to_reorder)
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            x = assets_helper.read(conn, asset_x['asset_id'])
            y = assets_helper.read(conn, asset_y['asset_id'])

            self.assertEqual(x['play_order'], 0)
            self.assertEqual(y['play_order'], 1)
Example #30
0
    def get(self):
        collector = ZmqCollector.get_instance()

        publisher = ZmqPublisher.get_instance()
        publisher.send_to_viewer('current_asset_id')

        collector_result = collector.recv_json(2000)
        current_asset_id = collector_result.get('current_asset_id')

        if not current_asset_id:
            return []

        with db.conn(settings['database']) as conn:
            return assets_helper.read(conn, current_asset_id)
Example #31
0
    def test_reorder_asset(self):
        with db.conn(settings['database']) as conn:
            _asset_x = asset_x.copy()
            _asset_x['is_enabled'] = 1
            assets_helper.create(conn, _asset_x)
            assets_helper.create(conn, asset_y)

        with Browser() as browser:
            browser.visit(main_page_url)

            asset_x_for_drag = browser.find_by_id(asset_x['asset_id'])
            sleep(1)

            asset_y_to_reorder = browser.find_by_id(asset_y['asset_id'])
            asset_x_for_drag.drag_and_drop(asset_y_to_reorder)
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            x = assets_helper.read(conn, asset_x['asset_id'])
            y = assets_helper.read(conn, asset_y['asset_id'])

            self.assertEqual(x['play_order'], 0)
            self.assertEqual(y['play_order'], 1)
Example #32
0
    def test_set_order(self):
        assets = [asset_x, asset_y, asset_z, asset_w]
        for_order = [asset_y, asset_x]

        assets_helper.create_multiple(self.conn, assets)
        assets_helper.save_ordering(self.conn,
                                    [asset['asset_id'] for asset in for_order])

        fetched = assets_helper.read(self.conn)

        self.assertEquals([(0, asset_y['asset_id']), (1, asset_x['asset_id']),
                           (2, asset_z['asset_id']), (2, asset_w['asset_id'])],
                          [(asset['play_order'], asset['asset_id'])
                           for asset in fetched])
Example #33
0
    def test_rm_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit(main_page_url)

            wait_for_and_do(browser, '.delete-asset-button', lambda btn: btn.click())
            wait_for_and_do(browser, '.confirm-delete', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            self.assertEqual(len(assets), 0)
Example #34
0
    def test_rm_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit('http://localhost:8080')

            wait_for_and_do(browser, '.delete-asset-button', lambda btn: btn.click())
            wait_for_and_do(browser, '.confirm-delete', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            self.assertEqual(len(assets), 0)
Example #35
0
    def get(self):
        collector = ZmqCollector.get_instance()

        publisher = ZmqPublisher.get_instance()
        publisher.send_to_viewer('current_asset_id')

        collector_result = collector.recv_json(2000)
        current_asset_id = collector_result.get('current_asset_id')

        if not current_asset_id:
            return []

        with db.conn(settings['database']) as conn:
            return assets_helper.read(conn, current_asset_id)
Example #36
0
    def test_enable_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit(main_page_url)
            wait_for_and_do(browser, '.toggle', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            self.assertEqual(len(assets), 1)

            asset = assets[0]
            self.assertEqual(asset['is_enabled'], 1)
Example #37
0
    def test_enable_asset(self):
        with db.conn(settings['database']) as conn:
            assets_helper.create(conn, asset_x)

        with Browser() as browser:
            browser.visit('http://localhost:8080')
            wait_for_and_do(browser, 'span[class="on"]', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            self.assertEqual(len(assets), 1)

            asset = assets[0]
            self.assertEqual(asset['is_enabled'], 1)
Example #38
0
    def test_set_order(self):
        assets = [asset_x, asset_y, asset_z, asset_w]
        for_order = [asset_y, asset_x]

        assets_helper.create_multiple(self.conn, assets)
        assets_helper.save_ordering(self.conn, [asset['asset_id'] for asset in for_order])

        fetched = assets_helper.read(self.conn)

        self.assertEquals(
            [(0, asset_y['asset_id']),
             (1, asset_x['asset_id']),
             (2, asset_z['asset_id']),
             (2, asset_w['asset_id'])],
            [(asset['play_order'], asset['asset_id']) for asset in fetched])
Example #39
0
def generate_asset_list():
    """Choose deadline via:
        1. Map assets to deadlines with rule: if asset is active then 'end_date' else 'start_date'
        2. Get nearest deadline
    """
    logging.info('Generating asset-list...')
    assets = assets_helper.read(db_conn)
    deadlines = [asset['end_date'] if assets_helper.is_active(asset) else asset['start_date'] for asset in assets]

    playlist = filter(assets_helper.is_active, assets)
    deadline = sorted(deadlines)[0] if len(deadlines) > 0 else None
    logging.debug('generate_asset_list deadline: %s', deadline)

    if settings['shuffle_playlist']:
        shuffle(playlist)

    return playlist, deadline
Example #40
0
def generate_asset_list():
    """Choose deadline via:
        1. Map assets to deadlines with rule: if asset is active then 'end_date' else 'start_date'
        2. Get nearest deadline
    """
    logging.info('Generating asset-list...')
    assets = assets_helper.read(db_conn)
    deadlines = [asset['end_date'] if assets_helper.is_active(asset) else asset['start_date'] for asset in assets]

    playlist = filter(assets_helper.is_active, assets)
    deadline = sorted(deadlines)[0] if len(deadlines) > 0 else None
    logging.debug('generate_asset_list deadline: %s', deadline)

    if settings['shuffle_playlist']:
        shuffle(playlist)

    return playlist, deadline
Example #41
0
    def test_disable_asset(self):
        with db.conn(settings['database']) as conn:
            _asset_x = asset_x.copy()
            _asset_x['is_enabled'] = 1
            assets_helper.create(conn, _asset_x)

        with Browser() as browser:
            browser.visit(main_page_url)

            wait_for_and_do(browser, 'span[class="off"]', lambda btn: btn.click())
            sleep(3)  # backend need time to process request

        with db.conn(settings['database']) as conn:
            assets = assets_helper.read(conn)
            self.assertEqual(len(assets), 1)

            asset = assets[0]
            self.assertEqual(asset['is_enabled'], 0)
Example #42
0
def generate_asset_list():
    """Choose deadline via:
        1. Map assets to deadlines with rule:
           if asset is active then 'end_date' else 'start_date'
        2. Get nearest deadline
    """
    logging.info('Generating asset-list...')
    assets = assets_helper.read(db_conn)
    deadlines = [asset['end_date'] if assets_helper.is_active(asset)
                 else asset['start_date'] for asset in assets]

    # FIXME: we need a list for the shuffle
    # should we use list comprehension for playlist, instead of filter()?
    playlist = list(filter(assets_helper.is_active, assets))
    deadline = sorted(deadlines)[0] if len(deadlines) > 0 else None
    logging.debug('generate_asset_list deadline: %s', deadline)

    if settings['shuffle_playlist']:
        random.shuffle(playlist)

    return playlist, deadline
Example #43
0
 def get(self, asset_id):
     with db.conn(settings['database']) as conn:
         return assets_helper.read(conn, asset_id)
Example #44
0
 def get(self):
     with db.conn(settings['database']) as conn:
         assets = assets_helper.read(conn)
         return assets
Example #45
0
def api_assets():
    with db.conn(settings['database']) as conn:
        assets = assets_helper.read(conn)
        return make_json_response(assets)
Example #46
0
 def test_create_read_asset(self):
     assets_helper.create(self.conn, asset_x)
     assets_helper.create(self.conn, asset_y)
     should_be_y_x = assets_helper.read(self.conn)
     self.assertEqual([asset_y, asset_x], should_be_y_x)
Example #47
0
 def setUp(self):
     with db.conn(settings['database']) as conn:
         assets = assets_helper.read(conn)
         for asset in assets:
             assets_helper.delete(conn, asset['asset_id'])
Example #48
0
 def get(self):
     with db.conn(settings['database']) as conn:
         assets = assets_helper.read(conn)
         return assets
Example #49
0
 def get(self, asset_id):
     with db.conn(settings['database']) as conn:
         return assets_helper.read(conn, asset_id)
Example #50
0
def edit_asset(asset_id):
    return assets_helper.read(db_conn, asset_id)
Example #51
0
def api_assets():
    assets = assets_helper.read(db_conn)
    return make_json_response(assets)
Example #52
0
def get_specific_asset(asset_id):
    logging.info('Getting specific asset')
    return assets_helper.read(db_conn, asset_id)
Example #53
0
def api_assets():
    with db.conn(settings['database']) as conn:
        assets = assets_helper.read(conn)
        return make_json_response(assets)
Example #54
0
def edit_asset(asset_id):
    return assets_helper.read(db_conn, asset_id)
Example #55
0
def get_specific_asset(asset_id):
    logging.info('Getting specific asset')
    return assets_helper.read(db_conn, asset_id)
Example #56
0
 def setUp(self):
     with db.conn(settings['database']) as conn:
         assets = assets_helper.read(conn)
         for asset in assets:
             assets_helper.delete(conn, asset['asset_id'])
Example #57
0
def api_assets():
    assets = assets_helper.read(db_conn)
    return make_json_response(assets)
Example #58
0
 def test_create_read_asset(self):
     assets_helper.create(self.conn, asset_x)
     assets_helper.create(self.conn, asset_y)
     should_be_y_x = assets_helper.read(self.conn)
     self.assertEqual([asset_y, asset_x], should_be_y_x)