예제 #1
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def token_check(token):
    if config.authenticate(token):
        session['auth_token'] = config.signature
        flash('login successful', 'success')
        return redirect(url_for('index'))

    fail()
예제 #2
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def index():
    token = session.get('auth_token')
    if config.authenticate(token):
        return render_template('main.html')
    else:
        abort(
            401,
            'The request requires authentication.  Please contact sysadmin for details.'
        )
예제 #3
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def stop_video():
    """stop the video stream"""
    if not config.authenticate(session.get('auth_token')):
        fail()

    print("STOP VIDEO")
    # kill the videoplayer scripts
    os.system('kill -9 `pgrep videoplayer.sh`')
    os.system('kill -9 `pgrep omxplayer`')
    return redirect(url_for('index'))
예제 #4
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def file_view():
    if not config.authenticate(session.get('auth_token')):
        return fail()
    """render the file upload form"""
    # session['no_csrf'] = True
    file_list = []
    temp_list = sorted(os.listdir(app.config['UPLOAD_FOLDER']))
    for idx, f in enumerate(temp_list):
        file_list.append((idx, f))

    return render_template('files.html', file_list=file_list)
예제 #5
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def restart_video():
    """restart the video stream"""
    if not config.authenticate(session.get('auth_token')):
        fail()

    print("RESTART VIDEO")
    # kill the videoplayer scripts
    os.system('kill -9 `pgrep videoplayer.sh`')
    os.system('kill -9 `pgrep omxplayer`')
    time.sleep(2)
    # start the videoplayer
    os.system('~/videoplayer.sh &')
    return redirect(url_for('index'))
예제 #6
0
 def _check_auth():
     """
     Check the user's credentials against the web API.
     """
     user = {}
     try:
         user = config.authenticate(config.get_auth())
         assert (user['is_authenticated'])
         # An EPD Free user who is trying to install a package not in
         # EPD free.  Print out subscription level and fail.
         print config.subscription_message(user)
         _done(FAILURE)
     except Exception as e:
         print e.message
         # No credentials.
         print ""
         _prompt_for_auth()
예제 #7
0
def search(enpkg, pat=None):
    """
    Print the packages that are available in the (remote) KVS.
    """
    # Flag indicating if the user received any 'not subscribed to'
    # messages
    SUBSCRIBED = True

    print FMT4 % ('Name', '  Versions', 'Product', 'Note')
    print 80 * '='

    names = {}
    for key, info in enpkg.query_remote():
        names[info['name']] = name_egg(key)

    installed = {}
    for key, info in enpkg.query_installed():
        installed[info['name']] = VB_FMT % info

    for name in sorted(names, key=string.lower):
        if pat and not pat.search(name):
            continue
        disp_name = names[name]
        installed_version = installed.get(name)
        for info in enpkg.info_list_name(name):
            version = VB_FMT % info
            disp_ver = (('* ' if installed_version == version else '  ') +
                        version)
            available = info.get('available', True)
            product = info.get('product', '')
            if not (available):
                SUBSCRIBED = False
            print FMT4 % (disp_name, disp_ver, product,
                          '' if available else 'not subscribed to')
            disp_name = ''

    # if the user's search returns any packages that are not available
    # to them, attempt to authenticate and print out their subscriber
    # level
    if config.get('use_webservice') and not (SUBSCRIBED):
        user = {}
        try:
            user = config.authenticate(config.get_auth())
        except Exception as e:
            print e.message
        print config.subscription_message(user)
예제 #8
0
 def _check_auth():
     """
     Check the user's credentials against the web API.
     """
     user = {}
     try:
         user = config.authenticate(config.get_auth())
         assert(user['is_authenticated'])
         # An EPD Free user who is trying to install a package not in
         # EPD free.  Print out subscription level and fail.
         print config.subscription_message(user)
         _done(FAILURE)
     except Exception as e:
         print e.message
         # No credentials.
         print ""
         _prompt_for_auth()
예제 #9
0
def search(enpkg, pat=None):
    """
    Print the packages that are available in the (remote) KVS.
    """
    # Flag indicating if the user received any 'not subscribed to'
    # messages
    SUBSCRIBED = True

    print FMT4 % ('Name', '  Versions', 'Product', 'Note')
    print 80 * '='

    names = {}
    for key, info in enpkg.query_remote():
        names[info['name']] = name_egg(key)

    installed = {}
    for key, info in enpkg.query_installed():
        installed[info['name']] = VB_FMT % info

    for name in sorted(names, key=string.lower):
        if pat and not pat.search(name):
            continue
        disp_name = names[name]
        installed_version = installed.get(name)
        for info in enpkg.info_list_name(name):
            version = VB_FMT % info
            disp_ver = (('* ' if installed_version == version else '  ') +
                        version)
            available = info.get('available', True)
            product = info.get('product', '')
            if not(available):
                SUBSCRIBED = False
            print FMT4 % (disp_name, disp_ver, product,
                   '' if available else 'not subscribed to')
            disp_name = ''

    # if the user's search returns any packages that are not available
    # to them, attempt to authenticate and print out their subscriber
    # level
    if config.get('use_webservice') and not(SUBSCRIBED):
        user = {}
        try:
            user = config.authenticate(config.get_auth())
        except Exception as e:
            print e.message
        print config.subscription_message(user)
예제 #10
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def upload_video():
    """render upload page and upload file"""
    if not config.authenticate(session.get('auth_token')):
        fail()

    if request.method == "POST":

        file = request.files["file"]

        print("File uploaded")
        print(file)
        save_file(file)

        res = make_response(jsonify({"message": "File uploaded"}), 200)

        return res

    return render_template("upload_video.html")
예제 #11
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def save_file(file):
    """save the file to the proper location, rename if necessary"""
    # check if user is logged in and session is authentic
    if not config.authenticate(session.get('auth_token')):
        fail()

    # sanitize the filename
    filename = secure_filename(file.filename)
    pathname = os.path.join(app.config['UPLOAD_FOLDER'], filename)

    # handle name collision if needed
    # filename will add integers at beginning of filename in dotted fashion
    # hello.jpg => 1.hello.jpg => 2.hello.jpg => ...
    # until it finds an unused name
    i = 1
    while os.path.isfile(pathname):
        parts = filename.split('.')
        parts.insert(0, 'copy')

        filename = '.'.join(parts)
        i += 1
        if i > 100:
            # probably under attack, so just fail
            raise ValueError(
                "too many filename collisions, administrator should check this out"
            )

        pathname = os.path.join(app.config['UPLOAD_FOLDER'], filename)

    try:
        # ensure directory where we are storing exists, and create it
        directory = app.config['UPLOAD_FOLDER']
        if not os.path.exists(directory):
            os.makedirs(directory)
        # finally, save the file AND create its resource object in database
        file.save(pathname)
        return True
    except:
        flash("The upload failed", "danger")
        return False
예제 #12
0
파일: app.py 프로젝트: jefmud/chem_kiosk
def file_delete():
    """handle file deletion from form"""
    if not config.authenticate(session.get('auth_token')):
        fail()

    command = request.form.get('command')
    if command == 'reorder':
        items = request.form
        for item in items:
            if item[0] == '@':
                # here is an item to reorder
                try:
                    idx = int(items.get(item))
                    orig_fname = item[1:]
                    orig_pathname = os.path.join(app.config['UPLOAD_FOLDER'],
                                                 orig_fname)
                    # is old filename already numbered?
                    at_loc = orig_fname.find('^')
                    if at_loc > 0:
                        _ord = orig_fname[:at_loc]
                        _fname = orig_fname[at_loc + 1:]
                    else:
                        _fname = orig_fname
                    newfilename = "{}^{}".format(idx, _fname)
                    new_pathname = os.path.join(app.config['UPLOAD_FOLDER'],
                                                newfilename)
                    os.rename(orig_pathname, new_pathname)
                except:
                    flash('the order must be a number', "warning")

                print(item)
    else:
        items = request.form
        for item in items:
            pathname = os.path.join(app.config['UPLOAD_FOLDER'], item)
            if os.path.isfile(pathname):
                os.remove(pathname)
                flash('deleted {}'.format(item), "success")
    return redirect(url_for('file_view'))
예제 #13
0
 def __init__(self):
     self.api = authenticate()
예제 #14
0
class TweetService:
    api = authenticate()

    def __init__(self):
        self.ids_cache = []
        self.tweets_cache = {}
        self.users_cache = {}
        self.dont_engage_list = self.api.get_list(
            owner_screen_name='sole_hunt', slug='sneaker-friends')
        self._get_ids_for_users_followed()

    def _get_ids_for_users_followed(self, ids=None):
        if not ids or self.ids_cache:
            logging.info("Collecting ids for users I follow")
            ids = self.api.friends_ids()
        self.ids_cache.extend(ids)
        logging.info("Returning {} ids".format(len(ids)))
        return ids

    def _store_user(self, user_id=None):
        user = self.api.get_user(user_id)
        if user.id in self.users_cache.keys():
            return
        self.users_cache[user_id] = user
        logging.info("Stored user {}".format(user.screen_name))

    def store_users(self, ids):
        for user_id in ids:
            self._store_user(user_id)

    def get_followed_by_followers_count(self, count=50000):
        # final store for desired users to return
        users_with_desired_followers_count = []
        # ensure ids_cache exists
        if not self.ids_cache:
            self._get_ids_for_users_followed()
        if not self.users_cache:
            self.store_users(self.ids_cache)
        for i in self.ids_cache:
            user = self.users_cache[i]
            logging.info("Getting tweets from {}".format(user.screen_name))
            if user.followers_count >= count:
                logging.info("Adding {} to return list".format(
                    user.screen_name))
                users_with_desired_followers_count.append(user)
        return users_with_desired_followers_count

    def get_relevant_tweets_from_followed(self):
        """
        Gets tweet that mentioned a tag from followed list
        """
        users = self.get_followed_by_followers_count()
        rate_limit = self.get_rate_limit('users', '/users/show/:id')
        logging.info("followed_ids count: {}".format(len(users)))
        logging.info("monitoring rate limit: {}".format(rate_limit))

        while rate_limit_ok(rate_limit):
            logging.info("rate limit ok: {}".format(rate_limit_ok(rate_limit)))
            for _user in users:
                if not self.should_engage(_user):
                    logging.info("Not going to engage with {}".format(_user))
                    return
                user = self.users_cache[_user.id]
                logging.info("Collecting user {}".format(user.screen_name))
                if not user.status.favorited:
                    self.tweets_cache[user.status.id] = {
                        "tweet": user.status.text,
                        'status': user.status
                    }
                    logging.info("Updated cache with tweet from {}".format(
                        user.screen_name))
                    time.sleep(1)
                    rate_limit = self.get_rate_limit('users',
                                                     '/users/show/:id')
                if rate_limit_too_low(rate_limit):
                    logging.warn("Rate limit met")
                    break
            break
        return self.tweets_cache

    def get_rate_limit(self, *args):
        """
        example call: self.get_rate_limits('users', '/users/show/:id')
        """
        query = "self.api.rate_limit_status()['resources']"
        for arg in args:
            query += "['{}']".format(arg)
        rate_limit_data = eval(query)
        return rate_limit_data

    def _engage_tweet(self, tweet):
        if tweet['status'].favorited:
            logging.info("Already liked")
            return
        logging.info("engaging tweet_id {}".format(tweet['status'].id))
        if has_enough_retweets(tweet['status'].retweet_count):
            if not tweet['status'].retweeted:
                try:
                    tweet['status'].retweet()
                    logging.info("Retweeted")
                except:
                    pass
        if not tweet['status'].favorited:
            try:
                tweet['status'].favorite()
                logging.info("Liked!")
            except:
                pass

    def engage_tweets(self, tweets=None):
        """
        query for all tweets in cache
        engage with a subset of tweets
        """
        limit = TEN
        if not self.tweets_cache or tweets:
            # create cache if it does not exist
            self.get_relevant_tweets_from_followed()
        for tweet_id, tweet in self.tweets_cache.iteritems():
            if tweet['status'].entities['urls']:
                url = tweet['status'].entities['urls'][0]['url']
                logging.info("Engaging tweet {}".format(url))
            self._engage_tweet(tweet)
            limit -= ONE
            time.sleep(ONE)
            if limit <= ZERO:
                limit = TEN
                time.sleep(MIN_INTERVAL * 2)
                continue

    def _reset(self):
        self.ids_cache = []
        self.tweets_cache = {}
        self.users_cache = {}
        self._get_ids_for_users_followed()

    def should_engage(self, user):
        member_screen_names = [
            member.screen_name for member in self.dont_engage_list.members()
        ]
        if user.screen_name in member_screen_names:
            return False
        return True

    def follow_retweeter(self, user_id):
        """
        follow users that retweet
        :param tweet:
        :return:
        """
        user = self.users_cache[user_id]
        tweet = user.status

        is_retweeted = tweet.retweeted
        if is_retweeted:
            retweets = tweet.retweets()
            if len(retweets) > 16:
                retweets = retweets[:15]
            for retweet in retweets:
                # follow user and add to list
                user = retweet.user
                if not user.following and user.id != self.api.me().id:
                    user.follow()
                    logging.info("Followed {}".format(user.screen_name))
                self.api.add_list_member(slug=NON_ENGAGED_FRIENDS_LIST,
                                         user_id=user.id,
                                         owner_screen_name='sole_hunt')
                logging.info("Added {} to non engaged list".format(
                    user.screen_name))

    def follow_retweeters(self):
        # first ensure users have been stored
        self.store_users(self.ids_cache)

        followed = []
        for user_id, user in self.users_cache.iteritems():
            try:
                self.follow_retweeter(user.id)
                followed.append(user_id)
            except:
                continue
        logging.info("Followed users: {}".format(followed))
        return followed