Example #1
0
    def __init__(self, setting_filename):
        dir_path = os.path.dirname(os.path.realpath(__file__))

        self.cfg = Config(os.path.join(dir_path, setting_filename))
        self.logger = Log.get_logger(os.path.join(dir_path, self.cfg.LOG_FILE))
        self.cfg.verify_config()
        self.botAPI = VkApi(self.cfg)
        self.uManager = UserManager(os.path.join(dir_path, self.cfg.USERS_FILE))
        self.logger.info("\nVKBot started")
    def __init__(self, slack_clients, msg_writer, markov_chain):
        self.clients = slack_clients
        self.msg_writer = msg_writer
        self.game_manager = GameManager(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.response_master = Response_master(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.channel_manager = ChannelManager(slack_clients)

        self.markov_chain = markov_chain
    def __init__(self, slack_clients, msg_writer, markov_chain):
        self.clients = slack_clients
        self.msg_writer = msg_writer
        self.game_manager = GameManager(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.tictactoe_manager = TicTacToeManager(
            self.msg_writer, self.user_manager, self.game_manager
        )
        self.response_master = Response_master(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.rude_manager = RudeManager(self.msg_writer)
        self.channel_manager = ChannelManager(slack_clients)

        self.markov_chain = markov_chain
        markov_files = ['hpOne.txt', 'lotrOne.txt', 'memoriesOfIce.txt']
        self.lotrMarkov = Markov(2, msg_writer, markov_files)
Example #4
0
def login():
    login_form = MyForm(csrf_enabled=False)
    if login_form.validate_on_submit():
        username = login_form.data['username']
        psd = login_form.data['psd']
        print username
        print psd

        res = UserManager.authorize(username, psd)
        if res[0]:
            user = res[1]
            flask_login.login_user(user)
            next_url = request.args.get("next")
            print flask_login.current_user
            '''
            this function does not work
            if not is_safe_url(next):
                return abort(400)
            '''
            return redirect(next_url or url_for('view_environment_main'))

            #return redirect(url_for('view_environment_main'))
        else:
            return render_template('login.html',
                                   message='Bad username or password',
                                   form=login_form,
                                   name_short='login',
                                   name_long='login your account')
    return render_template('login.html',
                           form=login_form,
                           name_short='login',
                           name_long='login your account')
Example #5
0
    def __init__(self,
                 screen_title='OpenNI',
                 screen_size=(640, 480),
                 res=RES_VGA,
                 fps=30):
        self.context = Context()
        self.context.init()

        self.res = res
        self.fps = fps

        self.depth_generator = DepthGenerator()
        self.depth_generator.create(self.context)
        self.depth_generator.set_resolution_preset(self.res)
        self.depth_generator.fps = self.fps

        self.image_generator = ImageGenerator()
        self.image_generator.create(self.context)
        self.image_generator.set_resolution_preset(self.res)
        self.image_generator.fps = self.fps

        self.user_manager = UserManager(self.context, self.depth_generator)

        self.context.start_generating_all()

        pygame.init()
        self.screen = pygame.display.set_mode(screen_size)
        pygame.display.set_caption(screen_title)
Example #6
0
    def __init__(self, slack_clients, msg_writer, markov_chain):
        self.clients = slack_clients
        self.msg_writer = msg_writer
        self.game_manager = GameManager(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.tictactoe_manager = TicTacToeManager(
            self.msg_writer, self.user_manager, self.game_manager
        )
        self.response_master = Response_master(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.rude_manager = RudeManager(self.msg_writer)
        self.channel_manager = ChannelManager(slack_clients)

        self.markov_chain = markov_chain
        markov_files = ['hpOne.txt', 'lotrOne.txt', 'memoriesOfIce.txt']
        self.lotrMarkov = Markov(2, msg_writer, markov_files)
Example #7
0
    def __init__(self, controller_url, dns_host, user_manager=None):
        self.controller_url = controller_url
        self.dns_host = dns_host

        self.redis = connect_redis(host=REDIS_HOST)

        if user_manager is None:
            from user_manager import UserManager
            self.user_manager = UserManager()
        elif user_manager:
            self.user_manager = user_manager
Example #8
0
 def setUpClass(cls):
     """Called before everything. (setup)"""
     print("setUpClass")
     cls.user_manager = UserManager()
     cls.user = {
         'name': 'Libor',
         'surname': 'Zachoval',
         'email': '*****@*****.**',
         'role': 'Admin',
         'password': '******'
     }
Example #9
0
async def main():
    man = UserManager(sys.argv[1])
    await man.connect()

    if not await man.is_username_taken(sys.argv[2]):
        print("User does not exist!")
        await man.shutdown()
        return

    await man.drop_user(sys.argv[2])
    print(f"User '{sys.argv[2]}' has been removed from the database!")

    await man.shutdown()
Example #10
0
    def check_init(self, sas_if, sas_api, config=None, logger=print) -> bool:
        final_ret = True
        with self.__lock:
            if self.__init:
                return True

            self.__sas_if = sas_if
            self.__sas_api = sas_api

            self.__config = config if config is not None else self.__sas_api.config(
            )
            self.__logger = logger

            self.__sas_terminal = SasTerminal(self.__sas_if, self.__sas_api)
            self.__user_manager = UserManager()
            self.__access_control = AccessControl()

            ret = self.__init_offline_analysis_result()
            final_ret = ret and final_ret

            self.__init = final_ret
        return final_ret
Example #11
0
class User(AbstractBaseUser, PermissionsMixin):

    REQUIRED_FIELDS = []
    USERNAME_FIELD = 'user_name'

    user_name = models.EmailField(blank=False, unique=True, max_length=200)
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    parent_name = models.CharField(max_length=200, null=True)
    reg_no = models.IntegerField(null=True)
    mobile_no = models.CharField(max_length=12, null=True)
    password = models.CharField(max_length=50)
    profile_image = models.CharField(max_length=500)
    dob = models.DateField(null=True)
    standard = models.CharField(max_length=10, null=True)
    user_type = models.CharField(max_length=10)
    is_admin = models.BooleanField(default=False)
    created_by = models.ForeignKey('self',
                                   null=True,
                                   related_name="u_created_by")
    updated_by = models.ForeignKey('self',
                                   null=True,
                                   related_name="u_updated_by")
    teacher_id = models.ForeignKey('self',
                                   null=True,
                                   related_name="u_teacher_id")
    updated_at = models.DateTimeField(auto_now_add=True)
    created_at = models.DateTimeField(auto_now_add=True)

    objects = UserManager()

    def get_full_name(self):
        full_name = '%s %s' % (self.first_name, self.last_name)
        return full_name.strip()

    def check_password(self, password):
        if self.password == password:
            return True
        return False
class TweetListener(StreamListener):
    def __init__(self, configured_api):
        self.twitterApi = configured_api
        self.manager = UserManager(configured_api)

    def on_data(self, data):
        tweet = json.loads(data.strip())

        retweeted = tweet.get('retweeted')
        from_self = tweet.get('user', {}).get('screen_name',
                                              '') == "BotExistencial"

        if retweeted is not None and not retweeted and not from_self:

            tweetId = tweet.get('id_str')
            screen_name = tweet.get('user', {}).get('screen_name')
            tweetText = tweet.get('text')

            response = self.manager.get_response(screen_name)

            replyText = '@' + screen_name + ' ' + response

            #check if repsonse is over 140 char
            if len(replyText) > 140:
                replyText = replyText[0:139] + '…'

            print('Tweet ID: ' + tweetId)
            print('From: ' + screen_name)
            print('Tweet Text: ' + tweetText)
            print('Reply Text: ' + replyText)

            # If rate limited, the status posts should be queued up and sent on an interval
            self.twitterApi.api.update_status(status=replyText,
                                              in_reply_to_status_id=tweetId)
            sleep(95)

    def on_error(self, status):
        print(status)
Example #13
0
def login_command(transport, data):
    if transport is None:
        return
    else:
        log.debug('login command start')
        login = data['login']
        password = data['password']
        _id = int(data['id'])
        usermanager = UserManager()
        user = usermanager.get_user(login)
        if not user:
            usermanager.add_user(login, password)
            user = usermanager.get_user(login)
        log.debug('get user %i' % user.uid)
        transport.uid = user.uid
        user.transport = transport
        rspd = {'login': login, 'status': 'ok'}
        rsp = Mlang().create_rsp(rspd, _id)
        peername = transport.get_extra_info('peername')
        log.debug('client logon : %i %s' % (user.uid, str(peername)))
        transport.write(rsp.encode())
        log.debug('login command end')
Example #14
0
 def __init__(self):
     self.__socket = self.init_socket()
     # 用户管理器
     self.__user_manager = UserManager()
Example #15
0
class MyChatServer:
    def __init__(self):
        self.__socket = self.init_socket()
        # 用户管理器
        self.__user_manager = UserManager()

    @staticmethod
    # 配置并返回socket
    def init_socket():
        global server_addr
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.bind(server_addr)
        return s

    # 启动函数
    def start(self):
        self.run()

    # 监听客户端发来的请求
    def run(self):
        while True:
            data, addr = self.__socket.recvfrom(1024)
            # 根据客户端发来的数据不同,做不同的处理
            # 解析data
            self.respond_request(data.decode("utf-8"), addr)

    # 根据客户端发来的字符串,了解客户端需求,分发处理
    def respond_request(self, data, addr):
        ctl = data.split("|")[0]
        ctl_dict = {
            # 登陆请求  <[LOGIN]>|username
            '<[LOGIN]>': MyChatServer.client_login,
            # 下线请求 <[LOGOUT]>|username
            '<[LOGOUT]>': MyChatServer.client_logout,
            # 显示在线用户列表 <[SHOW_USR_LIST]>|username
            '<[SHOW_USR_LIST]>': MyChatServer.client_request_user_list,
            # 聊天<[SEND_MESSAGE]>|fromusername|tousername|words
            '<[SEND_MESSAGE]>': MyChatServer.clinet_send_message
        }
        try:
            ctl_dict[ctl](self, data, addr)
        except KeyError:
            print("KeyError")

    # 客户端登陆处理
    def client_login(self, data, addr):
        # 登陆请求  <[LOGIN]>|username
        username = data[10:]
        ret = self.__user_manager.login_user(username, addr)
        if ret:
            # 登陆成功
            print("【{}】登陆成功".format(username))
            # 发一个回执
            content = "<[LOGIN_SUCCESS]>"
            self.__socket.sendto(content.encode("utf-8"), addr)
        else:
            # 登陆失败
            print("【{}】登陆失败".format(username))
            # 发一个回执
            content = "<[LOGIN_FAILED]>"
            self.__socket.sendto(content.encode("utf-8"), addr)

    # 客户端下线处理
    def client_logout(self, data, addr):
        # <LOGOUT>}username
        username = data[11:]
        ret = self.__user_manager.logout_user(username)
        if ret:
            print("【{}】已下线".format(username))
            # 发回执
            content = "<[LOGOUT_SUCCESS]>"
            self.__socket.sendto(content.encode("utf-8"), addr)

    # 客户端请求显示在线用户列表
    def client_request_user_list(self, data, addr):
        content = "<[USR_LIST]>|" + self.__user_manager.get_username_list()
        self.__socket.sendto(content.encode("utf-8"), addr)
        print("发送了请求的在线用户列表to【{}】".format(data[17:]))

    # 转发客户端的聊天信息
    def clinet_send_message(self, data, addr):
        # 聊天<[SEND_MESSAGE]>|fromusername|tousername|words
        ls = data.split("|")
        # 通过usermanager找到tousername的addr
        to_addr = self.__user_manager.get_user_addr(ls[2])
        if not to_addr:
            # 发送回执
            content = "<[SEND_MESSAGE_FAILED]>|目标用户不存在"
            self.__socket.sendto(content.encode("utf-8"), addr)
            return
        # 将信息发送给目标用户
        self.__socket.sendto(data.encode("utf-8"), to_addr)
        print("【{}】向【{}】发送了信息({})".format(ls[1], ls[2], ls[-1]))
Example #16
0
class VKBotApplication:
    cfg = None
    logger = None
    botAPI = None
    uManager = None

    def __init__(self, setting_filename):
        dir_path = os.path.dirname(os.path.realpath(__file__))

        self.cfg = Config(os.path.join(dir_path, setting_filename))
        self.logger = Log.get_logger(os.path.join(dir_path, self.cfg.LOG_FILE))
        self.cfg.verify_config()
        self.botAPI = VkApi(self.cfg)
        self.uManager = UserManager(os.path.join(dir_path, self.cfg.USERS_FILE))
        self.logger.info("\nVKBot started")

    def get_id_that_members(self, vk_id_string):
        vk_id_arr = vk_id_string.split(",")
        result_id = []
        members = self.get_members()
        for vk_id in vk_id_arr:
            if int(vk_id) not in members:
                self.logger.info("skip user {0} because he is not group member".format(vk_id))
            else:
                result_id.append(int(vk_id))
        return result_id


    def get_members(self):
        self.logger.info("getting_members")
        r = self.botAPI.get_members_list()
        # count = int(r['response']['count'])
        member_user_ids = r['response']['items']

        # check if users in memory
        for user_id in member_user_ids:
            # new user detected
            if not self.uManager.has_user(user_id):
                # TODO try/catch
                # TODO multiple list
                # TODO check if user leave group
                user_info = self.get_user_info(user_id)
                first_name = user_info['response'][0]['first_name'].encode("utf-8")
                last_name = user_info['response'][0]['last_name'].encode("utf-8")
                self.uManager.add_user(user_id, -1, 0, "{0} {1}".format(first_name, last_name), "")

        self.logger.info("members are {0}".format(member_user_ids))
        return member_user_ids

    def check_allowed_receive_message(self, member_user_ids):
        self.logger.info("Check allowed receive message")
        allowed_members = []
        for member_user_id in member_user_ids:
            r = self.botAPI.is_messages_from_group_allowed(member_user_id)
            if r['response']['is_allowed'] == 1:
                self.uManager.set_user_property(member_user_id, "allow", 1)
                allowed_members.append(member_user_id)
            else:
                self.uManager.set_user_property(member_user_id, "allow", 0)
                time = self.uManager.get_user_property(member_user_id, "time")
                if time is None or time == "":
                    # try to send message first time anyway
                    allowed_members.append(member_user_id)

        self.logger.info("Allowed members are : {0}".format(allowed_members))
        return allowed_members

    def skip_blocked_users(self, user_ids):
        non_blocked = []
        for user_id in user_ids:
            if self.uManager.get_user_property(user_id, "blocked") == 0:
                non_blocked.append(user_id)

        self.logger.info("Non blocked users : {0}".format(non_blocked))
        return non_blocked

    def get_user_info(self, user_id):
        self.logger.info("Get user {0} info".format(user_id))
        r = self.botAPI.get_user_info(user_id)
        return r

    def send_message(self, message, user_ids):
        cap = 100

        if not user_ids:
            self.logger.info("no user to send message")
            return

        if message == "" or not message:
            self.logger.info("no message to send")
            return

        msg = message.decode('string_escape')

        batch_users = []
        if len(user_ids) > 1:
            for user_id in user_ids:
                batch_users.append(user_id)
                if len(batch_users) == cap:
                    user_ids_str = ','.join(str(e) for e in batch_users)
                    self.botAPI.send_messages(msg, user_ids_str)
                    batch_users = []

            if len(batch_users) > 0:
                user_ids_str = ','.join(str(e) for e in batch_users)
                self.botAPI.send_messages(msg, user_ids_str)
        else:
            self.botAPI.send_message(msg, user_ids[0])

        time = datetime.datetime.now().strftime("%d %B %Y %I:%M%p")
        for user_id in user_ids:
            self.uManager.set_user_property(user_id, "time", time)

        self.uManager.save_users()
Example #17
0
import os
import itchat
from itchat.content import TEXT, PICTURE, CARD
from constant import pkl_path, qr_path, pic_dir, cmd_user_name
from constant import use_mq, mq_queue
from log import gen_logger
from tools import msg_repeated, clear_db_task, msg2json, json2msg
from user_manager import UserManager
if use_mq:
    from mq_manager import MQProducer, MQConsumer
    import threading

logger = gen_logger("logger.py")
# UserManager对象
user_m = UserManager()
if use_mq:
    mq_p = MQProducer(mq_queue)


def log_card(msg):
    '''打印名片'''
    nickname = msg.get('RecommendInfo', {}).get('NickName', "NULL")
    logger.info(nickname)


@itchat.msg_register([TEXT, PICTURE, CARD],
                     isFriendChat=True,
                     isGroupChat=True)
def msg_reply(msg):
    '''接收消息'''
Example #18
0
#encoding=utf-8

from utils.log import logger
from user_manager import UserManager

userManager = UserManager(logger)
Example #19
0
def load_user(user_id):
    return UserManager.get(user_id)
Example #20
0
class ContainerManager(object):
    def __init__(self, controller_url, dns_host, user_manager=None):
        self.controller_url = controller_url
        self.dns_host = dns_host

        self.redis = connect_redis(host=REDIS_HOST)

        if user_manager is None:
            from user_manager import UserManager
            self.user_manager = UserManager()
        elif user_manager:
            self.user_manager = user_manager

    def ensure_container(self, user_id, container_name=None, user_is_valid=False):
        if not user_is_valid:
            # Raise exception if user id is not valid
            user_details = self.user_manager.get_user(user_id)

        # Init the container if need be, get container_id otherwise
        if not container_name:
            container_name = user_id

        return self.init_container(user_id, container_name)

    def init_container(self, user_id, container_name=None):
        'Init the container and map to the user'

        container_id = self.get_user_container_id(user_id)
        if container_id:
            try:
                self.start_container(container_id, user_id)
            except Exception, e:
                print 'Failed to start existing container %s: %s' % (container_id, e)
            else:
                return container_id

        import os
        src_code_dir = '/opt/benome/src'
        dest_code_dir = '/opt/benome/src'
        data_dir = '/opt/benome/data/%s' % user_id

        if not os.path.exists(data_dir):
            os.makedirs(data_dir)

        if not os.path.isdir(data_dir):
            raise Exception('Data dir not available')

        cmd = ['/usr/bin/python', os.path.join(dest_code_dir, 'container/container.py')]
        #auth_token = str(uuid4())

        container_id = self.docker([
                'run', '-d', '-p', str(CONTAINER_PORT), '--dns=%s' % self.dns_host,
                '--name="%s"' % container_name,
                '-v', '%s:%s' % (data_dir, data_dir),
                '-v', '%s:%s' % (src_code_dir, dest_code_dir),
                '-e', 'BENOME_DATA_DIR=%s' % data_dir,
                '-e', 'BENOME_USERID=%s' % user_id,
                '-e', 'BENOME_CONTAINER_PORT=%s' % CONTAINER_PORT,
                #'-e', 'BENOME_CONTROLLER_URL=%s' % self.controller_url,
                #'-e', 'BENOME_CONTROLLER_AUTHTOKEN=%s' % auth_token,
                '-e', 'PYTHONPATH=/opt/benome/src',
                CONTAINER_BASE_IMAGE
            ] + cmd)

        # Verify that it loaded successfully
        container_running = False
        container_ext_port = None
        begin_time = time.time()

        while not container_running and time.time() - begin_time < 5:
            container_state = self.get_container_state(container_id)

            if container_state:
                container_exists = True
                container_running = container_state['State']['Running']

                if container_running:
                    container_ext_port = self.get_container_ext_port(container_state)
                    break

            time.sleep(0.25)

        if container_running:
            self.set_user_port(user_id, container_ext_port)
            self.set_user_container_id(user_id, container_id)
            #self.set_user_auth_token(user_id, auth_token)
        else:
            raise Exception('Container failed to initialize')

        return container_id
Example #21
0
class RtmEventHandler(object):

    bold_pattern = re.compile(
        "(((?<!.)| )\*(?=\S)(?!\*).+?(?<!\*)(?<=\S)\*( |(?!.)))"
    )

    def __init__(self, slack_clients, msg_writer, markov_chain):
        self.clients = slack_clients
        self.msg_writer = msg_writer
        self.game_manager = GameManager(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.tictactoe_manager = TicTacToeManager(
            self.msg_writer, self.user_manager, self.game_manager
        )
        self.response_master = Response_master(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.rude_manager = RudeManager(self.msg_writer)
        self.channel_manager = ChannelManager(slack_clients)

        self.markov_chain = markov_chain
        markov_files = ['hpOne.txt', 'lotrOne.txt', 'memoriesOfIce.txt']
        self.lotrMarkov = Markov(2, msg_writer, markov_files)

    def handle(self, event):
        if 'type' in event:
            self._handle_by_type(event['type'], event)

    def _handle_by_type(self, event_type, event):
        # See https://api.slack.com/rtm for a full list of events
        if event_type == 'error':
            self.msg_writer.write_error(json.dumps(event), event['channel'])
        elif event_type == 'message':
            self._handle_message(event)
        elif event_type == 'channel_joined':
            # you joined a channel
            self.msg_writer.write_help_message(event['channel']['id'])
        elif event_type == 'group_joined':
            # you joined a private group
            self.msg_writer.write_help_message(event['channel'])
        elif (
            event_type == 'reaction_added' and 'user' in event
            and not self.clients.is_message_from_me(event)
        ):
            if 'channel' in event['item']:
                msg = event['item']
                self.response_master.process_reaction(
                    event['reaction'], msg['channel'], msg['ts']
                )
        else:
            pass

    def _is_edited_with_star(self, message):
        return '*' in re.sub(self.bold_pattern, '', message)

    def _is_edited_by_user(self, event):
        if 'subtype' in event:
            if event['subtype'] == 'message_changed':
                if 'message' in event:
                    event_msg = event['message']

                    # Dont allow bolton to spam his own message edits
                    if self.clients.is_message_from_me(event_msg):
                        return False

                    if (
                        'user' in event_msg and 'edited' in event_msg and
                        'user' in event_msg['edited'] and
                        not is_bot_message(event_msg['edited'])
                    ):
                        user1 = event_msg['user']
                        user2 = event_msg['edited']['user']
                        return user1 == user2
        return False

    def _handle_message(self, event):
        if 'subtype' in event:
            if self._is_edited_by_user(event):
                self.msg_writer.write_spelling_mistake(
                    event['channel'], event['message']['ts']
                )
            elif (
                event['subtype'] == 'channel_join' and
                not self.clients.is_message_from_me(event)
            ):
                self.msg_writer.write_joined_channel(
                    event['channel'], event['user']
                )
            elif event['subtype'] == 'message_deleted':
                self.msg_writer.write_message_deleted(event['channel'])
            elif event['subtype'] == 'channel_leave':
                self.msg_writer.write_left_channel(event['channel'])

        # Filter out messages from the bot itself
        if 'user' in event and not self.clients.is_message_from_me(event):
            logging.info("Handling event")

            msg_txt = event['text']
            channel_id = event['channel']
            user_id = event['user']
            ts = event['ts']

            user_name = self.user_manager.get_user_by_id(user_id)
            lower_txt = msg_txt.lower()

            # Markov chain addition and response
            if should_add_markov(event):
                self.markov_chain.add_single_line(msg_txt)
            if (
                channel_id == self.channel_manager.get_channel_id('bolton_weather')
                or lower_txt == 'markov'
            ):
                self.msg_writer.send_message(str(self.lotrMarkov), channel_id)

            # Respond to messages handled by rude_manager and response_manager
            self.rude_manager.run(channel_id, user_id)
            self.response_master.process_message(
                msg_txt, channel_id, user_id, ts
            )

            # Command line
            # logging.info("lower_txt: "+str(lower_txt.split()))
            try:
                token = lower_txt.split()[0]
                if token == '#>' or token == u'#&gt;':
                    # logging.info("entering terminal command mode")
                    self.msg_writer.write_terminal_command(
                        lower_txt, channel_id
                    )
                    return 0  # Do not continue execution
            except:
                pass

            # Return channel and user information
            if lower_txt == 'channelinfo':
                self.msg_writer.send_message(channel_id, channel_id)
            if lower_txt == 'userinfo':
                self.msg_writer.send_message(user_id, channel_id)
            if lower_txt == 'allusersinfo':
                self.user_manager.print_all_users(channel_id)

            # Loud addition and response
            if should_add_loud(event):
                self.msg_writer.write_loud(msg_txt)
                self.msg_writer.respond_loud(msg_txt, channel_id)
            if self._is_edited_with_star(msg_txt):
                self.msg_writer.write_spelling_mistake(channel_id, ts)

            # Respond to message text
            if re.search('i choose you', lower_txt):
                self.msg_writer.write_cast_pokemon(lower_txt, channel_id)
            if re.search('weather', lower_txt):
                self.msg_writer.write_weather(channel_id)
            if re.search('riri', lower_txt):
                self.msg_writer.write_riri_me(msg_txt, channel_id)
            if 'xkcd' in lower_txt:
                self.msg_writer.write_xkcd(lower_txt, channel_id)
            if (
                'tictactoe' in lower_txt or ' ttt' in lower_txt or
                lower_txt.startswith('ttt')
            ):
                self.tictactoe_manager.get_message(
                    channel_id, lower_txt, user_name
                )

            # Respond to message text with `bolton` included
            if is_bolton_mention(msg_txt) or self.clients.is_bot_mention(msg_txt):
                if re.search('erase|delete', lower_txt):
                    self.msg_writer.erase_history(
                        msg_txt, channel_id, ts
                    )
                if 'help' in lower_txt:
                    self.msg_writer.write_help_message(channel_id)
                if 'joke' in lower_txt:
                    self.msg_writer.write_joke(channel_id)
                if 'french' in lower_txt:
                    self.msg_writer.write_french(msg_txt, channel_id)
                if re.search('who\'?s that pokemon', msg_txt):
                    self.msg_writer.write_whos_that_pokemon(channel_id)
                if re.search(' ?bolton it\'?s', lower_txt):
                    self.msg_writer.write_pokemon_guessed_response(
                        msg_txt, channel_id, user_id
                    )
                if re.search('attachment|beep boop link', lower_txt):
                    self.msg_writer.demo_attachment(channel_id)
                if 'sad ' in lower_txt:
                    self.msg_writer.write_sad(channel_id)
                if 'sort me' in lower_txt:
                    self.msg_writer.write_hogwarts_house(
                        msg_txt, channel_id, user_id
                    )
                if re.search('encourage ', lower_txt):
                    self.msg_writer.write_encouragement(msg_txt, channel_id)
                if 'sass ' in lower_txt:
                    self.msg_writer.write_sass(msg_txt, channel_id)
                if 'solve' in lower_txt:
                    self.msg_writer.write_solution(msg_txt, channel_id)
                if re.search('explain|why', lower_txt):
                    self.msg_writer.write_explanation(channel_id)
                if re.search('sweetpotato|sweet potato', lower_txt):
                    self.msg_writer.write_sweetpotato_me(msg_txt, channel_id)
                if re.search('draw me', lower_txt):
                    self.msg_writer.write_draw_me(channel_id)
                if re.search('love|forever|relationship', lower_txt):
                    self.msg_writer.write_forever(channel_id)
                if re.search('unflip', lower_txt):
                    self.msg_writer.write_unflip(channel_id)
                elif re.search('flip|rageflip', lower_txt):
                    self.msg_writer.write_flip(channel_id)
                if re.search('sup son', lower_txt):
                    self.msg_writer.write_sup_son(channel_id)
                if lower_txt == "bolton":
                    self.msg_writer.write_prompt(channel_id)
                else:
                    pass
Example #22
0
from uuid import uuid4

import requests
from redis import StrictRedis
from flask import Flask, Response, request, make_response, render_template, \
                    redirect, session, abort
from flask_login import LoginManager, UserMixin, AnonymousUserMixin, login_required, login_user, logout_user, \
                    current_user

from benome.utils import json_response, json_get
from global_config import REDIS_HOST, CONTAINER_PORT, DEFAULT_TZ_OFFSET, GLOBAL_USER_ID, USER_DB_PATH
from container_manager import ContainerManager
from user_manager import UserManager

container_manager = ContainerManager('http://127.0.0.1:5200', '127.0.0.1', user_manager=False)
user_manager = UserManager()

redis = StrictRedis(host=REDIS_HOST, db=0)

app = Flask(__name__)

SECRET_FILE = os.path.normpath(os.path.join('.', 'SECRET.key'))
try:
    secret_key = open(SECRET_FILE).read().strip()
except IOError:
    try:
        secret_key = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(50))
        with open(SECRET_FILE, 'w') as f:
            f.write(secret_key)
    except IOError:
        raise Exception('Could not open %s for writing!' % SECRET_FILE)
Example #23
0
    "image": "success",
    "music": "info",
    "text": "warning"
}

iconMapping = {
    "video": "video",
    "image": "image",
    "music": "audio",
    "text": "alt"
}

offerManager = OfferManager(os.path.join(app.instance_path, 'offers.json'),
                            os.path.join(app.instance_path, 'buys.json'))

userManager = UserManager(os.path.join(app.instance_path, 'users.json'))


@app.route('/')
@app.route('/index')
def index():
    if current_user.is_authenticated:
        return redirect(url_for('shop'))

    return render_template('index.html', form=LoginForm())


@app.route("/registerAction", methods=['POST'])
def signUp():
    form = RegisterForm()
    if form.validate_on_submit():
 def __init__(self, configured_api):
     self.twitterApi = configured_api
     self.manager = UserManager(configured_api)
Example #25
0
from flask import render_template, jsonify
from flask_login import login_required, current_user
from boxer_app import app
from users import User
import boxer_app

from user_manager import UserManager

import datetime
tstring = datetime.datetime.utcnow().strftime("%Y-%H-%M-%S")

admin_user = User.get_user_by_username("admin")

user_manager = UserManager("user")

from js_source_management import js_source_dict, _develop, css_source


@app.route('/admin_list_with_metadata/<res_type>', methods=['GET', 'POST'])
@login_required
def admin_list_with_metadata(res_type):
    manager = user_manager
    return jsonify({"data_list": manager.get_resource_data_list()})


@app.route('/admin_interface', methods=['GET', 'POST'])
@login_required
def admin_interface():
    if current_user.get_id() == admin_user.get_id():
        return render_template("library/library_home_react.html",
                               develop=str(_develop),
Example #26
0
				key = k
		connections.pop(key)
		print("Total Connections: ", len(connections))



	def send_message(self,type,data):
		print("send_message")
		msg=dict()
		msg["type"]=type
		msg["data"]=data
		msg=json.dumps(msg)
		self.write_message(msg)


user_manager = UserManager()
settings = {
	'debug':True	#includes autoreload
}

app= tornado.web.Application([
	#map the handler to the URI named "wstest"
	(r'/wstest', WSHandler),
], settings)

if __name__ == '__main__':
	server_port = 8080
	print("server starting")
	app.listen(server_port)
	ioloop = tornado.ioloop.IOLoop.instance()
	autoreload.start(ioloop)
import datetime
import traceback
import logging
import requests
import os
import json

from model import Course, Teaching, Mode, Plan, Lesson, Aula, Timetable, User
import config
from user_manager import UserManager

um = UserManager.get_instance()


def get_plan_timetable(day, plan, orari, all_aule):
    if len(orari) == 0:
        return None
    timetable = Timetable()

    if plan.is_empty():
        return timetable

    start = datetime.datetime.strptime(
        day.strftime("%Y-%m-%d") + "T00:00:00", "%Y-%m-%dT%H:%M:%S")
    stop = datetime.datetime.strptime(
        day.strftime("%Y-%m-%d") + "T23:59:59", "%Y-%m-%dT%H:%M:%S")

    for t in plan.teachings:
        for o in orari[t.componente_id]:
            try:
                ##### DEBUG #####
class RtmEventHandler(object):

    bold_pattern = re.compile(
        "(((?<!.)| )\*(?=\S)(?!\*).+?(?<!\*)(?<=\S)\*( |(?!.)))"
        # btw this doesn't work exactly properly
        # if you want to fix it, don't use a regex
        # this is a commit to revive zac
    )

    def __init__(self, slack_clients, msg_writer, markov_chain):
        self.clients = slack_clients
        self.msg_writer = msg_writer
        self.game_manager = GameManager(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.tictactoe_manager = TicTacToeManager(
            self.msg_writer, self.user_manager, self.game_manager
        )
        self.response_master = Response_master(self.msg_writer)
        self.user_manager = UserManager(self.clients, self.msg_writer)
        self.rude_manager = RudeManager(self.msg_writer)
        self.channel_manager = ChannelManager(slack_clients)

        self.markov_chain = markov_chain
        markov_files = ['hpOne.txt', 'lotrOne.txt', 'memoriesOfIce.txt']
        self.lotrMarkov = Markov(2, msg_writer, markov_files)

    def handle(self, event):
        if 'type' in event:
            self._handle_by_type(event['type'], event)

    def _handle_by_type(self, event_type, event):
        # See https://api.slack.com/rtm for a full list of events
        if event_type == 'error':
            self.msg_writer.write_error(json.dumps(event), event['channel'])
        elif event_type == 'message':
            self._handle_message(event)
        elif event_type == 'channel_joined':
            # you joined a channel
            self.msg_writer.write_help_message(event['channel']['id'])
        elif event_type == 'group_joined':
            # you joined a private group
            self.msg_writer.write_help_message(event['channel'])
        elif (
            event_type == 'reaction_added' and 'user' in event and
            not self.clients.is_message_from_me(event)
        ):
            if 'channel' in event['item']:
                msg = event['item']
                self.response_master.process_reaction(
                    event['reaction'], msg['channel'], msg['ts']
                )
        else:
            pass

    def _is_edited_with_star(self, message):
        return '*' in re.sub(self.bold_pattern, '', message)

    def _is_edited_by_user(self, event):
        if 'subtype' in event:
            if event['subtype'] == 'message_changed':
                if 'message' in event:
                    event_msg = event['message']

                    # Dont allow zac to spam his own message edits
                    if self.clients.is_message_from_me(event_msg):
                        return False

                    if (
                        'user' in event_msg and 'edited' in event_msg and
                        'user' in event_msg['edited'] and
                        not is_bot_message(event_msg['edited'])
                    ):
                        user1 = event_msg['user']
                        user2 = event_msg['edited']['user']
                        return user1 == user2
        return False

    def _handle_message(self, event):
        if 'subtype' in event:
            # if self._is_edited_by_user(event):
            #     self.msg_writer.write_spelling_mistake(
            #         event['channel'], event['message']['ts']
            #     )
            if (
                event['subtype'] == 'channel_join' and
                not self.clients.is_message_from_me(event)
            ):
                self.msg_writer.write_joined_channel(
                    event['channel'], event['user']
                )
            elif event['subtype'] == 'message_deleted':
                self.msg_writer.write_message_deleted(event['channel'])
            elif event['subtype'] == 'channel_leave':
                self.msg_writer.write_left_channel(event['channel'])

        # Filter out messages from the bot itself
        if 'user' in event and not self.clients.is_message_from_me(event):
            logging.info("Handling event")

            msg_txt = event['text']
            channel_id = event['channel']
            user_id = event['user']
            ts = event['ts']

            user_name = self.user_manager.get_user_by_id(user_id)
            lower_txt = msg_txt.lower()

            # Markov chain addition and response
            if should_add_markov(event):
                self.markov_chain.add_single_line(msg_txt)
            if (
                channel_id == self.channel_manager.get_channel_id('markov') or
                lower_txt == 'markov'
            ):
                self.msg_writer.send_message(str(self.lotrMarkov), channel_id)

            # Respond to messages handled by rude_manager and response_manager
            self.rude_manager.run(channel_id, user_id)
            self.response_master.process_message(
                msg_txt, channel_id, user_id, ts
            )

            # Command line
            # logging.info("lower_txt: "+str(lower_txt.split()))
            try:
                token = lower_txt.split()[0]
                if token == '#>' or token == u'#&gt;':
                    # logging.info("entering terminal command mode")
                    self.msg_writer.write_terminal_command(
                        lower_txt, channel_id
                    )
                    return 0  # Do not continue execution
            except:
                pass

            # Return channel and user information
            if lower_txt == 'channelinfo':
                self.msg_writer.send_message(channel_id, channel_id)
            elif lower_txt == 'channelname':
                self.msg_writer.send_message(
                    self.channel_manager.get_channel_by_id(channel_id),
                    channel_id
                )
            elif lower_txt == 'userinfo':
                self.msg_writer.send_message(user_id, channel_id)
            elif lower_txt == 'allusersinfo':
                self.user_manager.print_all_users(channel_id)
            elif lower_txt == 'allchannelinfo':
                self.msg_writer.send_message(
                    str(self.channel_manager.get_all_channel_ids()),
                    channel_id
                )
            elif lower_txt == 'allchannelname':
                self.msg_writer.send_message(
                    str(self.channel_manager.get_all_channel_names()),
                    channel_id
                )
            elif lower_txt == 'ayy':
                self.msg_writer.write_lmao(channel_id)

            # Loud addition and response
            if should_add_loud(event):
                self.msg_writer.write_loud(msg_txt)
                self.msg_writer.respond_loud(msg_txt, channel_id)
            # if self._is_edited_with_star(msg_txt):
            #     self.msg_writer.write_spelling_mistake(channel_id, ts)

            # Respond to message text
            if re.search('i choose you', lower_txt):
                self.msg_writer.write_cast_pokemon(lower_txt, channel_id)
            if re.search('weather', lower_txt):
                self.msg_writer.write_weather(channel_id)
            if re.search('riri', lower_txt):
                self.msg_writer.write_riri_me(msg_txt, channel_id)
            if 'xkcd' in lower_txt:
                self.msg_writer.write_xkcd(lower_txt, channel_id)
            if (
                'tictactoe' in lower_txt or ' ttt' in lower_txt or
                lower_txt.startswith('ttt')
            ):
                self.tictactoe_manager.get_message(
                    channel_id, lower_txt, user_name
                )

            # Respond to message text with `zac` included
            if is_zac_mention(msg_txt) or self.clients.is_bot_mention(msg_txt):
                if re.search('erase|delete', lower_txt):
                    self.msg_writer.erase_history(
                        msg_txt, channel_id, ts
                    )
                if 'help' in lower_txt:
                    self.msg_writer.write_help_message(channel_id)
                if 'joke' in lower_txt:
                    self.msg_writer.write_joke(channel_id)
                if 'french' in lower_txt:
                    self.msg_writer.write_french(msg_txt, channel_id)
                if re.search('who\'?s that pokemon', msg_txt):
                    self.msg_writer.write_whos_that_pokemon(channel_id)
                if re.search(' ?zac it\'?s', lower_txt):
                    self.msg_writer.write_pokemon_guessed_response(
                        msg_txt, channel_id, user_id
                    )
                if re.search('attachment|beep boop link', lower_txt):
                    self.msg_writer.demo_attachment(channel_id)
                if 'sad ' in lower_txt:
                    self.msg_writer.write_sad(channel_id)
                if 'sort me' in lower_txt:
                    self.msg_writer.write_hogwarts_house(
                        msg_txt, channel_id, user_id
                    )
                if re.search('encourage ', lower_txt):
                    self.msg_writer.write_encouragement(msg_txt, channel_id)
                if 'sass ' in lower_txt:
                    self.msg_writer.write_sass(msg_txt, channel_id)
                if 'solve' in lower_txt:
                    self.msg_writer.write_solution(msg_txt, channel_id)
                if re.search('explain|why', lower_txt):
                    self.msg_writer.write_explanation(channel_id)
                if re.search('sweetpotato|sweet potato', lower_txt):
                    self.msg_writer.write_sweetpotato_me(msg_txt, channel_id)
                if re.search('draw me', lower_txt):
                    self.msg_writer.write_draw_me(channel_id)
                if re.search('love|forever|relationship', lower_txt):
                    self.msg_writer.write_forever(channel_id)
                if re.search('unflip', lower_txt):
                    self.msg_writer.write_unflip(channel_id)
                elif re.search('flip|rageflip', lower_txt):
                    self.msg_writer.write_flip(channel_id)
                if re.search('sup son', lower_txt):
                    self.msg_writer.write_sup_son(channel_id)
                if lower_txt == "zac":
                    self.msg_writer.write_prompt(channel_id)
                # The word google must be specified in lower case
                if 'zac google ' in msg_txt:
                    self.msg_writer.google(msg_txt, channel_id)
                if msg_txt.startswith('zac add news '):
                    user_name = self.user_manager.get_user_by_id(user_id)
                    self.msg_writer.link_945(msg_txt, channel_id, user_name)
                if re.search('open the pod bay doors', lower_txt):
                    self.msg_writer.write_hal(channel_id, user_name)
                if re.search('hackernews', lower_txt):
                    self.msg_writer.write_hackernews(channel_id)
                else:
                    # self.msg_writer.write_prompt(channel_id)
                    pass
Example #29
0
from rating_system import TopcoderRatingSystem
from user_manager import UserManager
from datetime import datetime
from utils import get_discretize_dict, get_codeforces_users_by_organization
from datetime import datetime

import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

user_manager = UserManager()

user_manager.add_user(u'何柱', {
    'codeforces': 'Hezhu',
    'atcoder': 'Hezhu',
    'topcoder': 'Herzu',
})
user_manager.add_user(u'陈鑫', {
    'codeforces': 'missever',
    'atcoder': 'missever',
    'topcoder': 'missever',
})
user_manager.add_user(u'廖奇', {
    'codeforces': 'liao772002',
    'topcoder': 'liao772002',
})
user_manager.add_user(u'杨宇同', {
    'codeforces': 'Orenji.Sora',
    'topcoder': 'Orenji.Sora',
})