Exemplo n.º 1
0
def show():
    if authenticated():
        userID = session["userID"]
        user = User.get(userID)

        return render_template("index.html", menu="home", login=True, user=user)

    return render_template("index.html", menu="home")
Exemplo n.º 2
0
def process_unfollows():
    print("Process unfollows")

    if auth.authenticated():
        print("User is authenticated. Unfollows will be processed...")

        list_members = get_list_members(MNG_MAIN, auth.get_user_id())
        print_list_stats(list_members)

        u = 0
        following = 0
        not_following_dict = {}
        unfollowed_dict = {}
        for m in list_members:
            u = u + 1
            print("#### User %d ####" % u)
            user_dict = m.AsDict()
            m_id = user_dict["id"]
            m_screename = user_dict["screen_name"]

            # TODO: LookupFriendship() should be a bit more efficient
            friendship_data = auth.api.ShowFriendship(auth.get_user_id(),None,m_id,None) # Check friendship between the two users (the authenticated user and the one on the list)

            src_tar = friendship_data["relationship"]
            src = src_tar["source"]
            
            if src["followed_by"]:
                print("%s IS following!" % m_screename)
                following += 1

                if not src["following"]:
                    # Remove user from this list and pass it to the following list in the pipeline
                    auth.api.DestroyListsMember(None,MNG_MAIN,None,auth.get_user_id(),m_id,None)
                    auth.api.CreateListsMember(None,MNG_UNFOLLOWED,m_id,None,None,auth.get_user_id())
                    print("User %s deleted from %s list and added to %s" % (m_screename,MNG_MAIN,MNG_UNFOLLOWED))

                    unfollowed_dict[m_id] = m_screename
            else:
                print("%s IS NOT following!" % m_screename)
                not_following_dict[m_id] = m_screename
                
                # Unfriend user
                auth.api.DestroyFriendship(m_id,None)
                print("User %s unfriended" % m_screename)

                # Remove user from this list and pass it to the following list in the pipeline
                auth.api.DestroyListsMember(None,MNG_MAIN,None,auth.get_user_id(),m_id,None)
                auth.api.CreateListsMember(None,MNG_UNFOLLOWED_ME,m_id,None,None,auth.get_user_id())
                print("User %s deleted from %s list and added to %s" % (m_screename,MNG_MAIN,MNG_UNFOLLOWED_ME))

        print("Total users following: %s" % following)
        print("Total users NOT following (unfriended and moved): %s %s" % (len(not_following_dict), not_following_dict))
        print("Total users unfollowed: %s %s" % (len(unfollowed_dict), unfollowed_dict))

    else:
        print("Please, check authentication tokens")
Exemplo n.º 3
0
def process_unfollowed_me():
    print("Unfollowed stats")

    if auth.authenticated():
        print("User is authenticated. Unfollowed stats will be listed...")

        list_members = get_list_members(MNG_UNFOLLOWED_ME, auth.get_user_id())
        print_list_stats(list_members)
    else:
        print("Please, check authentication tokens")
Exemplo n.º 4
0
def show():
    if authenticated():
        userID = session['userID']
        user = User.get(userID)

        return render_template('index.html',
                               menu="home",
                               login=True,
                               user=user)

    return render_template('index.html', menu="home")
Exemplo n.º 5
0
def user_login():
    if authenticated():
        return redirect(session['last_url'])
    elif request.method == 'GET':
        return render_template('login.html', isConsultant = False)
    if request.method == 'POST':
        logging_user = validate_login(request.form['username'], request.form['password'])
        if logging_user is not None:
            session.permanent = True
            session['user'] = {'username':logging_user.name, 'uid':logging_user.id, 'roles':[role.name for role in logging_user.roles]}
            return redirect('/user/home')
        else:
            return 'login failed'
Exemplo n.º 6
0
def register():
    if authenticated() and (not has_role(['admin'])):
        return '请先注销当前登录'
    if request.method == 'GET':
        return render_template('register.html')
    else:
        registering_user = register_user(request.form['username'],request.form['password'])
        if registering_user is not None:
            if not 'user' in session:
                session.permanent = True
                session['user'] = {'username':registering_user.name, 'uid':registering_user.id, 'roles':[role.name for role in registering_user.roles]} 
                return redirect('/user/home')
            elif has_role(['admin']):
                return redirect('/user/register')
        else:
            return redirect('/user/register')
Exemplo n.º 7
0
def consultant_login():
    if authenticated():
        return redirect(session["last_url"])
    if request.method == "GET":
        return render_template("login.html", isConsultant=True)
    if request.method == "POST":
        logging_user = validate_login(request.form["username"], request.form["password"])
        if logging_user is not None:
            session.permanent = True
            session["user"] = {
                "username": logging_user.name,
                "uid": logging_user.id,
                "roles": [role.name for role in logging_user.roles],
            }
            if has_role(["consultant", "admin"]):
                return redirect("/consultant/home")
            else:
                return redirect("/user/home")
        else:
            abort(401)
Exemplo n.º 8
0
def query_lists():
    print("User lists stats")

    if auth.authenticated():
        print("User is authenticated. User lists stats will be listed...")

        lists = auth.api.GetLists()
        i = 0
        for l in lists:
            i = i + 1
            list_dict = l.AsDict()

            print("##### List %d #####" % i)
            print("Name: %s (slug: %s)" % (list_dict["name"], list_dict["slug"]))
            
            if "description" in list_dict:
                print("Description: %s" % list_dict["description"])
            else:
                print("Description: -")

            print("Member count: %s" % list_dict["member_count"])

    else:
        print("Please, check authentication tokens")
Exemplo n.º 9
0
def main():

    try:
        shortflags = '-h'
        longflags = [
            'help', 'generate-access-token', 'consumer-key=',
            'consumer-secret=', 'access-key=', 'access-secret='
        ]
        opts, args = getopt.gnu_getopt(sys.argv[1:], shortflags, longflags)
    except getopt.GetoptError:
        print_usage_and_exit()

    #print("Options: {opt}".format(opt=opts))
    #print("Args: {args}".format(args=args))

    consumer_keyflag = None
    consumer_secretflag = None
    access_keyflag = None
    access_secretflag = None

    generate_token = False
    for o, a in opts:
        if o in ("-h", "--help"):
            print_usage_and_exit()
        if o in ("--generate-access-token"):
            generate_token = True
        if o in ("--consumer-key"):
            consumer_keyflag = a
        if o in ("--consumer-secret"):
            consumer_secretflag = a
        if o in ("--access-key"):
            access_keyflag = a
        if o in ("--access-secret"):
            access_secretflag = a

    #print_tokens(consumer_keyflag,consumer_secretflag,access_keyflag,access_secretflag)

    consumer_key = consumer_keyflag or auth.GetConsumerKeyEnv(
    ) or auth.GetConsumerKeyHardcoded()
    consumer_secret = consumer_secretflag or auth.GetConsumerSecretEnv(
    ) or auth.GetConsumerSecretHardcoded()
    access_key = access_keyflag or auth.GetAccessKeyEnv(
    ) or auth.GetAccessKeyHardcoded()
    access_secret = access_secretflag or auth.GetAccessSecretEnv(
    ) or auth.GetAccessSecretHardcoded()

    #print_tokens(consumer_key,consumer_secret,access_key,access_secret)

    # if we want the program to generate the token for us, we try to generate them based
    # on the consumer tokens and override the access key values
    if generate_token:
        print("An access token will be generated")

        if not consumer_key or not consumer_secret:
            print_usage_and_exit()
        else:
            try:
                tmp_access_key, tmp_access_secret = get_access_token.get_access_token(
                    consumer_key, consumer_secret)
            except ValueError as e:
                print(
                    "Access token couldn't be generated. Please check the correctness of the provided consumer token: {0}"
                    .format(e))
                sys.exit(2)

            if not tmp_access_key and not tmp_access_secret:
                print(
                    "Access token couldn't be generated. The given access keys (environment's or hardcoded) will be used instead..."
                )
            else:
                # override the already read access keys
                access_key = tmp_access_key
                access_secret = tmp_access_secret
    else:
        print(
            "An access token won't be generated. The given access keys (environment's or hardcoded) will be used instead..."
        )

    if not consumer_key or not consumer_secret or not access_key or not access_secret:
        print(
            "At least one of the tokens is missing. Please check and try again"
        )
        print_usage_and_exit()

    auth.authenticate(consumer_key, consumer_secret, access_key, access_secret)

    if not auth.authenticated():
        print(
            "Authentication failed, please check authentication tokens and try again"
        )
        sys.exit(2)
    else:
        print("User correctly authenticated, starting program...\n")

    while True:
        menu.print_menu()
        m = user_input.read_selection()
        process(m)
Exemplo n.º 10
0
def index():
    if authenticated():
        return redirect(url_for('dashboard'))
    else:
        return redirect(url_for('login'))
Exemplo n.º 11
0
class ExampleApplication(GOApplication):
    """
    A Gate One Application (`GOApplication`) that serves as an example of how
    to write a Gate One application.
    """
    info = {
        'name': "Example",  # A user-friendly name for your app
        # A description of what your app does:
        'description': "An example of how to write a Gate One Application.",
        'hidden': HIDDEN
    }

    def __init__(self, ws):
        example_log.debug("ExampleApplication.__init__(%s)" % ws)
        # Having your app's policies handy is a good idea.  However, you can't
        # get them until you've got a user to pass to applicable_policies().
        # For this reason we'll place a `self.policy` placeholder here and
        # assign it after the user authenticates (successfully)...
        self.policy = {}  # Gets set in authenticate() below
        # If you override __init__() (like we are here) don't forget to call
        # the parent __init__():
        GOApplication.__init__(self, ws)

    def initialize(self):
        """
        Called when the WebSocket is instantiated, sets up our WebSocket
        actions, security policies, and attaches all of our plugin hooks/events.
        """
        example_log.debug("ExampleApplication.initialize()")
        # Register our security policy function in the 'security' dict
        self.ws.security.update({'example': example_policies})
        # Register some WebSocket actions...
        # These can be called from the client like so:
        # GateOne.ws.send(JSON.stringify({'example:test_example': whatever}));
        self.ws.actions.update({
            'example:test_example': self.test_example,
        })
        # Gate One provides a location where you can store information that you
        # want to be persistent across user sesions/connections and whatnot:
        if 'example' not in self.ws.persist:
            # If it doesn't belong in SESSIONS but you still need it to stick
            # around after the user disconnects put it here:
            self.ws.persist['example'] = {}
        # NOTE: If you don't care about your app having its own plugins you can
        # delete everything from here until the end of this function.
        # -- BEGIN PLUGIN CODE --
        # If you want your app to support plugins here's how you do it:
        # First let's check if someone has explicitly given us a list of plugins
        # that should be enabled (so we can exclude the others):
        enabled_plugins = self.ws.prefs['*']['example'].get(
            'enabled_plugins', [])
        # Now we'll use Gate One's utils.get_plugins() function to fetch a dict
        # containing all our Python, JavaScript, and CSS plugin files.  This is
        # really only so we can log which plugins are enabled because the
        # process of importing Python plugins happens inside of init() and
        # JS/CSS plugin files get sent via the send_plugin_static_files()
        # function inside of authenticate().
        self.plugins = get_plugins(  # Get everything in example/plugins/
            os.path.join(APPLICATION_PATH, 'plugins'), enabled_plugins)
        # Now let's separate the plugins by type (to save some typing)
        js_plugins = []
        for js_path in self.plugins['js']:
            name = js_path.split(os.path.sep)[-2]
            name = os.path.splitext(name)[0]
            js_plugins.append(name)
        css_plugins = []
        for css_path in css_plugins:
            name = css_path.split(os.path.sep)[-2]
            css_plugins.append(name)
        plugin_list = list(set(self.plugins['py'] + js_plugins + css_plugins))
        plugin_list.sort()  # So there's consistent ordering
        example_log.info(
            _("Active Example Plugins: %s" % ", ".join(plugin_list)))
        # Now let's attach plugin hooks.  Plugin hooks can be whatever you like
        # and called from anywhere in your application.  There's three types of
        # hooks you'll definitely want though:  initialize(), 'WebSocket' and
        # 'Events'
        #
        # The initialize() hook just calls a given plugin's "initializ()"
        # function if it has one.  The function will be passed `self` (the
        # current instance of your app).  This allows plugins to take care of
        # any initialization stuff that needs to happen before anything else.
        #
        # 'WebSocket' hooks are what allow plugins to add their own WebSocket
        # actions such as, "myplugin:do_something" which is a very important
        # part of Gate One.
        #
        # 'Events' hooks allow plugins to attach functions to `OnOff` events
        # such as 'self.on("example:some_event", handle_some_event)'
        #
        # With those three kinds of hooks plugins can add or override pretty
        # much anything.
        #
        # NOTE: All GOApplication instances include the OnOff mixin class so
        # they can use self.on(), self.off, self.trigger(), and self.once()
        #
        # How do plugins assign these hooks?  They simply include a 'hooks' dict
        # somewhere in the global scope of their .py files.  Example:
        # hooks = {
        #     'WebSocket': {'myplugin:some_func': some_func}
        #     'Events': {'example:authenticate': auth_func}
        # }
        self.plugin_hooks = {}  # We'll store our plugin hooks here
        imported = load_modules(self.plugins['py'])
        for plugin in imported:
            try:
                # Add the plugin's hooks dict to self.plugin_hooks:
                self.plugin_hooks.update({plugin.__name__: plugin.hooks})
                # Now we'll call the plugin's initialize() function:
                if hasattr(plugin, 'initialize'):
                    plugin.initialize(self)
            except AttributeError:
                pass  # No hooks--probably just a supporting .py file.
        # Now we hook up the hooks:
        for plugin_name, hooks in self.plugin_hooks.items():
            if 'WebSocket' in hooks:
                # Apply the plugin's WebSocket actions to ApplicationWebSocket
                for ws_command, func in hooks['WebSocket'].items():
                    self.ws.actions.update({ws_command: bind(func, self)})
                # Attach the plugin's event hooks to their respective events:
            if 'Events' in hooks:
                for event, callback in hooks['Events'].items():
                    self.on(event, bind(callback, self))
        # -- END PLUGIN CODE --

    def open(self):
        """
        This gets called at the end of :meth:`ApplicationWebSocket.open` when
        the WebSocket is opened.  It just triggers the "example:open" event.

        .. note::

            The authenticate() method is usually a better place to call stuff
            that needs to happen after the user loads the page.
        """
        example_log.debug('ExampleApplication.open()')
        self.trigger("example:open")

    def authenticate(self):
        """
        This gets called immediately after the user is authenticated
        successfully at the end of :meth:`ApplicationWebSocket.authenticate`.
        Sends all plugin JavaScript files to the client and triggers the
        'example:authenticate' event.
        """
        example_log.debug('ExampleApplication.authenticate()')
        # This is the log metadata that was mentioned near the top of this file.
        # This log_metadata will be JSON-encoded and included in all log
        # messages that use `self.example_log` which is super useful when
        # you need to parse logs at some later date and want to know the
        # circumstances surrounding any given message.
        self.log_metadata = {
            'upn': self.current_user['upn'],
            'ip_address': self.ws.request.remote_ip,
            # If your app uses the location feature make sure to include it:
            'location': self.ws.location
        }
        self.example_log = go_logger("gateone.example", **self.log_metadata)
        # NOTE:  To include even *more* metadata in a log message on a one-time
        # basis simply pass the metadata to the logger like so:
        #   self.example_log("Some log message", metadata={'foo': 'bar'})
        # That will ensure that {'foo': 'bar'} is included in the JSON portion
        # Assign our user-specific settings/policies for quick reference
        self.policy = applicable_policies('example', self.current_user,
                                          self.ws.prefs)
        # NOTE:  The applicable_policies() function *is* memoized but the above
        #        is still much faster.
        # Start by determining if the user can even use this app
        if 'allow' in self.policy:
            # This is the same check inside example_policies().  Why put it here
            # too?  So we can skip sending the client JS/CSS that they won't be
            # able to use.
            if not self.policy['allow']:
                # User is not allowed to access this application.  Don't
                # bother sending them any static files and whatnot...
                self.example_log.debug(
                    _("User is not allowed to use the Example application.  "
                      "Skipping post-authentication functions."))
                return
        # Render and send the client our example.css
        example_css = os.path.join(APPLICATION_PATH, 'templates',
                                   'example.css')
        self.render_and_send_css(example_css, element_id="example.css")
        # NOTE:  See the Gate One docs for gateone.py to see how
        #        render_and_send_css() works.  It auto-minifies and caches!
        # Send the client our application's static JavaScript files
        static_dir = os.path.join(APPLICATION_PATH, 'static')
        js_files = []
        if os.path.isdir(static_dir):
            js_files = os.listdir(static_dir)  # Everything in static/*.js
            js_files.sort()
        for fname in js_files:
            if fname.endswith('.js'):
                js_file_path = os.path.join(static_dir, fname)
                # This is notable:  To ensure that all your JavaScript files
                # get loaded *after* example.js we add 'example.js' as a
                # dependency for all JS files we send to the client.
                if fname == 'example.js':
                    # Adding CSS as a dependency to your app's JS is also a
                    # good idea.  You could also put 'theme.css' if you want to
                    # ensure that the theme gets loaded before your JavaScript
                    # init() function is called.
                    self.send_js(js_file_path, requires=["example.css"])
                else:
                    # Send any other discovered JS files to the client with
                    # example.js as the only dependency.
                    self.send_js(js_file_path, requires='example.js')
        # If you're not using plugins you can disregard this:
        # The send_plugin_static_files() function will locate any JS/CSS files
        # in your plugins' respective static directories and send them to the
        # client.  It is also smart enough to know which plugins are enabled
        # or disabled.
        self.ws.send_plugin_static_files(os.path.join(APPLICATION_PATH,
                                                      'plugins'),
                                         application="example",
                                         requires=["example.js"])
        sess = SESSIONS[self.ws.session]  # A shortcut to save some typing
        # Create a place to store app-specific stuff related to this session
        # (but not necessarily this 'location')
        if "example" not in sess:
            sess['example'] = {}  # A mostly persistent place to store info
        # If you want to call a function whenever Gate One exits just add it
        # to SESSIONS[self.ws.session]["kill_session_callbacks"] like so:
        #if kill_session_func not in sess["kill_session_callbacks"]:
        #sess["kill_session_callbacks"].append(kill_session_func)
        # If you want to call a function whenever a user's session times out
        # just attach it to SESSIONS[self.ws.session]["timeout_callbacks"]
        # like so:
        #if timeout_session_func not in sess["timeout_callbacks"]:
        #sess["timeout_callbacks"].append(timeout_session_func)
        # NOTE: The user will often be authenticated before example.js is
        # loaded.  In fact, the only time this won't be the case is when the
        # user is disconnected (e.g. server restart) and then reconnects.
        self.trigger("example:authenticate")

    def on_close(self):
        """
        This method gets called when the WebSocket connection closes
        (disconnected).  Triggers the `example:on_close` event.
        """
        # This is a nice little check to prevent you from calling all sorts
        # of uninitialization/teardown stuff when you don't need to:
        if not hasattr(self.ws, 'location'):
            return  # Connection closed before authentication completed
        # Here's where you'd deal with any uninitialization/teardown stuff
        self.trigger("example:on_close")

    @require(authenticated(), policies('example'))
    def test_example(self, settings):
        """
        This is an example WebSocket action that sends a message to the client
        indicating that it was called successfully.  Calls the
        `example:test_example` event when complete.
        """
        self.ws.send_message(
            _("The test_example WebSocket action was called successfully!"))
        self.ws.send_message(
            _("Here's what was recieved: %s") % repr(settings))
        self.trigger("example:test_example", settings)