Exemplo n.º 1
0
def add_channel(update, context):
    temp = update.message.reply_text('لطفا صبر کنید...')
    try:
        channel_sent_list = update.effective_message.text.split('\n')
    except ValueError:
        update.message.reply_text('ورودی اشتباه')
        return ADD_CHANNELS

    channel_store_list = []
    for channel in Channel.get_all():
        channel_store_list.append(channel.username)
    for username in channel_sent_list:
        if username.__contains__('t.me') or username.__contains__(
                'telegram.me'):
            try:
                username = '******' + \
                    re.search(r'\/\w{5,}', username).group(0).replace('/', '')
            except Exception:
                continue
        if username not in channel_store_list:
            channel_name = get_channel_name(username)
            if channel_name:
                Channel(username=username, name=channel_name.get_text()).add()
            else:
                update.message.reply_text(
                    'کانال {} وجود ندارد'.format(username))
    update.message.bot.edit_message_text(
        chat_id=update.message.chat_id,
        message_id=temp.message_id,
        text='اکنون /done را برای ذخیره سازی کانال ها ارسال کنید')
    return ADD_CHANNELS
Exemplo n.º 2
0
class MessagesCatcher(tornado.websocket.WebSocketHandler):
    def __init__(self, *args, **kwargs):
        super(MessagesCatcher, self).__init__(*args, **kwargs)

    def open(self, channel):
        #logging.info("opened connection")
        self.board_name = 'board:' + channel
        publisher.subscribe(self.board_name, self.on_new_board_message)
        self.channel = Channel(self.board_name)
        # when client connects send all commands written
        for cmd in iter(self.channel.get_commands()):
            self.write_message(cmd)

    def on_new_board_message(self, result):
        """ called when other client draws """
        # publish in the channel
        try:
            self.write_message(result)
        except IOError as e:
            # when client closes the page websocket is not closed
            # but connection do, so unsuscribe from channel
            self.close()

    def on_message(self, result):
        """ client message with draw command """
        # publish to other clients
        publisher.publish(self.board_name, result)
        self.channel.add_command(result)

    def close(self):
        publisher.unsubscribe(self.board_name, self.on_new_board_message)
        try:
            super(MessagesCatcher, self).close()
        except IOError:
            pass  # java rocks
Exemplo n.º 3
0
def index(request):
	# Validate token from Slack.
	token = request.GET['token']
	if (token != 'RNmcnBKCdOZBfs3S7habfT85'):
		return JsonResponse({'text': 'ERROR: Invalid token %s' % token})
	
	# Fetch channel if it exists, else create a new Channel object.
	channel_id = request.GET['channel_id']
	try:
		channel = Channel.objects.get(channel_id=channel_id)
	except Channel.DoesNotExist:
		channel = Channel(channel_id=channel_id)
		channel.save() 

	# Parse command from user.
	command = request.GET['text']	
	args = command.split(' ')
	if (len(args) < 1 or args[0] == 'help'):
		return showHelp()
	elif (args[0] == 'startGame'):
		return startGame(args, request.GET['user_name'], channel)
	elif (args[0] == 'makeMove'):
		return makeMove(args, request.GET['user_name'], channel)
	elif (args[0] == 'showBoard'):
		return showBoard(channel)
	else:
		return showHelp()
Exemplo n.º 4
0
 def delete_scene(self, args, guild, channel, scenario, sc, user):
     messages = []
     search = ''
     if len(args) == 1:
         if not sc:
             raise Exception('No scene provided for deletion')
     else:
         search = ' '.join(args[1:])
         sc = Scene().find(guild.name, str(channel.id), str(scenario.id),
                           search)
     if not sc:
         return [f'{search} was not found. No changes made.']
     else:
         search = str(sc.name)
         scenario_id = str(sc.scenario_id) if sc.scenario_id else ''
         channel_id = str(sc.channel_id) if sc.channel_id else ''
         sc.character.archive(user)
         sc.archived = True
         sc.updated_by = str(user.id)
         sc.updated = T.now()
         sc.save()
         messages.append(f'***{search}*** removed')
         if scenario_id:
             secenario = Scenario().get_by_id(scenario_id)
             messages.append(secenario.get_string(channel))
         elif channel_id:
             channel = Channel().get_by_id(channel_id)
             messages.append(channel.get_string())
         return messages
Exemplo n.º 5
0
  def fetchDataset (self):
    """Fetch a dataset to the list of cacheable datasets"""

    token = self.dataset_name.split('-')[0]
    
    try:
      json_info = json.loads(getURL('http://{}/ocpca/{}/info/'.format(settings.SERVER, token)))
    except Exception as e:
      logger.error("Token {} doesn not exist on the backend {}".format(token, settings.SERVER))
      raise NDTILECACHEError("Token {} doesn not exist on the backend {}".format(token, settings.SERVER))
    
    ximagesize, yimagesize, zimagesize = json_info['dataset']['imagesize']['0']
    xoffset, yoffset, zoffset = json_info['dataset']['offset']['0']
    xvoxelres, yvoxelres, zvoxelres = json_info['dataset']['voxelres']['0']
    scalinglevels = json_info['dataset']['scalinglevels']
    scalingoption = ND_scalingtoint[json_info['dataset']['scaling']]
    starttime, endtime = json_info['dataset']['timerange']
    project_name = json_info['project']['name']
    s3backend = json_info['project']['s3backend']
    
    self.ds = Dataset(dataset_name=self.dataset_name, ximagesize=ximagesize, yimagesize=yimagesize, zimagesize=zimagesize, xoffset=xoffset, yoffset=yoffset, zoffset=zoffset, xvoxelres=xvoxelres, yvoxelres=yvoxelres, zvoxelres=zvoxelres, scalingoption=scalingoption, scalinglevels=scalinglevels, starttime=starttime, endtime=endtime, project_name=project_name, s3backend=s3backend)
    self.ds.save()

    for channel_name in json_info['channels'].keys():
      channel_name = channel_name
      dataset_id = self.dataset_name
      channel_type = json_info['channels'][channel_name]['channel_type']
      channel_datatype = json_info['channels'][channel_name]['datatype']
      startwindow, endwindow = json_info['channels'][channel_name]['windowrange']
      propagate = json_info['channels'][channel_name]['propagate'] 
      readonly = json_info['channels'][channel_name]['readonly']
      ch = Channel(channel_name=channel_name, dataset=self.ds, channel_type=channel_type, channel_datatype=channel_datatype, startwindow=startwindow, endwindow=endwindow, propagate=propagate, readonly=readonly)
      ch.save()
Exemplo n.º 6
0
def index(request):
    # Validate token from Slack.
    token = request.GET['token']
    if (token != 'RNmcnBKCdOZBfs3S7habfT85'):
        return JsonResponse({'text': 'ERROR: Invalid token %s' % token})

    # Fetch channel if it exists, else create a new Channel object.
    channel_id = request.GET['channel_id']
    try:
        channel = Channel.objects.get(channel_id=channel_id)
    except Channel.DoesNotExist:
        channel = Channel(channel_id=channel_id)
        channel.save()

    # Parse command from user.
    command = request.GET['text']
    args = command.split(' ')
    if (len(args) < 1 or args[0] == 'help'):
        return showHelp()
    elif (args[0] == 'startGame'):
        return startGame(args, request.GET['user_name'], channel)
    elif (args[0] == 'makeMove'):
        return makeMove(args, request.GET['user_name'], channel)
    elif (args[0] == 'showBoard'):
        return showBoard(channel)
    else:
        return showHelp()
Exemplo n.º 7
0
def emap_process(emap_version, emap_path):
    emap = open(emap_path, 'r')
    for index, line in enumerate(emap):
        if line[0] == "#":
            continue
        if len(line.split()) < 10:
            continue
        contents = line.split()
        crate = int(contents[1])
        slot = int(contents[2])
        dcc = int(contents[4])
        spigot = int(contents[5])
        fiber = int(contents[6])
        fiber_channel = int(contents[7])
        subdet = str(contents[8])
        ieta = int(contents[9])
        iphi = int(contents[10])
        depth = int(contents[11])

        channel = Channel(subdet=subdet,
                          ieta=ieta,
                          iphi=iphi,
                          depth=depth,
                          crate=crate,
                          slot=slot,
                          dcc=dcc,
                          spigot=spigot,
                          fiber=fiber,
                          fiber_channel=fiber_channel,
                          emap_version=emap_version,
                          index=index)
        channel.save()
    async def new_channel(self, ctx, limit: int = 0):
        """
        Creates a new voice channel.

        This command creates a new voice channel for the user
        to use with friends.
        They can specify how many people should be limited to the channel.
        """
        category = discord.utils.get(ctx.guild.categories,
                                     name='Private Channels')
        if category is None:
            await ctx.send("I couldn't find the required category, "
                           "please contact an admin.")
            return

        if Channel.where('creator_id', ctx.author.id).first():
            await ctx.send("You already have a channel! "
                           "If you believe this is an error then "
                           "please contact an admin.")
        else:
            channel = await ctx.guild.create_voice_channel(ctx.author.name +
                                                           "'s Channel",
                                                           category=category,
                                                           user_limit=limit)

            Channel.create(id=channel.id, creator_id=ctx.author.id, voice=True)

            await ctx.send("Successfully made you a new channel!")
Exemplo n.º 9
0
 def on_join(self, channel_name):
     if not channel_name.startswith('#'):
         emit('error', {'message': 'Channel name should start with a #'})
         return
     channel = Channel.get(channel_name)
     if current_user.is_authenticated:
         if channel is None:
             channel = Channel(channel_name)
             db.session.add(channel)
         if channel not in current_user.channels:
             current_user.channels.append(channel)
             join_room(channel_name)
         current_user.last_channel = channel
         db.session.commit()
         data = {
             'channel': {
                 'name': channel_name
             },
             'user': current_user.name
         }
     else:
         if channel is None:
             data = {'channel': None}
         else:
             join_room(channel_name)
             data = {'channel': {'name': channel_name}}
     emit('channel-joined', data, room=channel_name, include_self=True)
Exemplo n.º 10
0
def initChannel(userid):
    #Refreshes the channel api
    chan = Channel.get_by_key_name(userid)
    if not chan:
        chan = Channel(key_name = userid)
    chan.token = channel.create_channel(userid, duration_minutes=5)
    chan.put()
    return chan.token
Exemplo n.º 11
0
 def open(self, channel):
     #logging.info("opened connection")
     self.board_name = 'board:' + channel
     publisher.subscribe(self.board_name, self.on_new_board_message)
     self.channel = Channel(self.board_name)
     # when client connects send all commands written
     for cmd in iter(self.channel.get_commands()):
         self.write_message(cmd)
Exemplo n.º 12
0
    def setUp(self):
        user = User.objects.create(username='******')
        user.save()

        channel = Channel(creator=user)
        channel.save()

        self.queue = QueueManager(channel=channel.id)
Exemplo n.º 13
0
    def __init__(self):
        self.players = []
        self.history = []

        self.channel = Channel('game')

        self.turn = random.randint(0, 1)
        self.started = False
Exemplo n.º 14
0
 def get(self):
     outlets = Outlet.all().filter('target =', self.account).fetch(100)
     if len(self.request.path.split('/')) > 2:
         source = Account.get_by_hash(self.request.path.split('/')[-1])
         channel = Channel.get_by_source_and_target(source, self.account)
         self.render('templates/source.html', locals())
     else:
         enabled_channels = Channel.get_all_by_target(self.account).order('-count').filter('status =', 'enabled')
         self.render('templates/sources.html', locals())
Exemplo n.º 15
0
def channel_add():
    j = request.get_json()
    c = Channel(j)
    c.save()
    responseData = {
        'channel_name': c.name,
        'channel_id': c.id,
    }
    return json.dumps(responseData, indent=2)
Exemplo n.º 16
0
    def update_subscriptions(self):
        log.info('running update subscriptions')
        head = {'referer': 'http://' + 'www.hominem.se'}
        payload = {
            'key': settings.APIKEY,
            'part': 'snippet',
            'channelId': 'UCvVx_jTHBKt0HW-iEkZnXTg',
            'maxResults': '50'
        }
        nextpage = None
        more = True
        while more:
            try:
                r = requests.get(
                    'https://www.googleapis.com/youtube/v3/subscriptions',
                    headers=head,
                    params=payload)
            except requests.RequestException as e:
                log.error("Exception in requests.get when searching: " +
                          str(e))
                return

            subscriptions = json.loads(r.text)
            if 'nextPageToken' in subscriptions:
                nextpage = subscriptions['nextPageToken']
                payload['pageToken'] = nextpage
                more = True
            else:
                nextpage = None
                more = False

            existing_subs = Channel.objects.all()
            log.info('Got ' + str(len(subscriptions['items'])) +
                     ' subscriptions')
            for sub in subscriptions['items']:
                s = sub['snippet']
                title = s['title']
                channelId = s['resourceId']['channelId']
                publishedAt = timezone.datetime.strptime(
                    s['publishedAt'], '%Y-%m-%dT%H:%M:%S.%fZ')
                pub = timezone.make_aware(publishedAt, timezone=None)
                description = s['description']
                thumb = s['thumbnails']['default']['url']

                channels = Channel.objects.filter(title_text=title)
                if len(channels) == 0:
                    q = Channel(channel_id=channelId,
                                title_text=title,
                                description_text=description,
                                thumbnail=thumb,
                                pub_date=pub,
                                latest_video=pub)
                    q.save()
                    log.info("Added new channel: " + title)
                else:
                    log.info("Channel " + title + "already exists")
Exemplo n.º 17
0
 def get(self):
     global is_modified
     is_modified = True
     for ch in Channel.all():
         ch.delete()
     for c in CHANNELS_LIST:
         channel = Channel(img_url=c["img_url"], name=c["name"])
         channel.put()
         taskqueue.add(url="/tvfeed/update", method="POST", params={"key": channel.key(), "gogo_id": c["c_id"]})
     self.response.out.write("Started")
Exemplo n.º 18
0
def next_channels(update, context):
    query = update.callback_query
    if context.user_data['current_channel_page'] == math.ceil(
            len(Channel.get_all()) / 25):
        query.answer('صفحه بعد وجود ندارد')
    else:
        query.answer()
        context.user_data['current_channel_page'] += 1
        cp = context.user_data['current_channel_page']
        channels = Channel.get_all()[(cp - 1) * 25:cp * 25]
        return show(update, context, channels)
Exemplo n.º 19
0
def admin():
    user = current_user()
    is_admin = is_administrator(user)
    log('Is admin?', is_admin)
    if is_admin:
        option_json = request.json
        Channel.update_roles(option_json)
        response_data = cid_rid_for_cookie()
        return json.dumps(response_data, indent=2)
    else:
        abort(401)
Exemplo n.º 20
0
def add_channel():
    form = ChannelForm(request.form)
    if request.method == 'POST' and form.validate():
        channel = Channel(name = form.name.data)
        channel.owner_id = g.user.id
        db.session.add(channel)
        db.session.commit()
        return redirect(url_for('channel_view', id=channel.id))
    return render_template('add_channel.html',
        title = 'Add channel',
        user = g.user,
        form = form)
Exemplo n.º 21
0
    def execute(self):
        channel = Channel.get(self.request.channel_id)
        channel.now_playing_song_id = self.request.song_id
        channel.song_play_time = self.request.song_play_time
        channel.server_start_time = (time.time() * 1000)
        channel.playing = True
        Channel.update(channel)

        package = SyncPackage(channel=channel)
        channel.push_to_all(package.data)
        self.response.update(package.data)
        self.response.update({'cmd': self.cmd_id})
Exemplo n.º 22
0
    def post(self, hash):
        hash = hash.lower()
        target = Account.all().filter('hash =', hash).get()
        if not target:
            target = Account.all().filter('hashes =', hash).get()
        source = Account.all().filter('api_key =',
                                      self.request.get('api_key')).get()

        channel = Channel.all().filter('target =',
                                       target).filter('source =',
                                                      source).get()
        approval_notice = None
        if not channel and source and target:
            channel = Channel(target=target,
                              source=source,
                              outlet=target.get_default_outlet())
            channel.put()
            approval_notice = channel.get_approval_notice()
            channel.send_activation_email()

        if channel:
            notice = Notification(channel=channel,
                                  text=strip_tags(self.request.get('text')),
                                  icon=source.source_icon)
            for arg in ['title', 'link', 'icon', 'sticky', 'tags']:
                value = strip_tags(self.request.get(arg, None))
                if value:
                    setattr(notice, arg, value)
            notice.put()

            # Increment the counter on the channel to represent number of notices sent
            channel.count += 1
            channel.put()

            if channel.status == 'enabled':
                notice.dispatch()
                self.response.out.write("OK\n")

            elif channel.status == 'pending':
                self.response.set_status(202)
                if approval_notice:
                    approval_notice.dispatch()
                    self.response.out.write("OK\n")
                else:
                    self.response.out.write("202 Pending approval")
            elif channel.status == 'disabled':
                self.response.set_status(202)
                self.response.out.write("202 Accepted but disabled")
        else:
            self.error(404)
            self.response.out.write("404 Target or source not found")
Exemplo n.º 23
0
def request_chat():
    request_data = request.get_json()
    from_user = request_data.get('from_user', '')
    to_user = request_data.get('to_user', '')
    to_user_channel = "private-notification_user_%s" % (to_user)
    from_user_channel = "private-notification_user_%s" % (from_user)

    try:
        bot = User.query.filter(User.id == to_user).one()
    except NoResultFound:
        print('Error! No bot (yet).')
    except MultipleResultsFound:
        print('Error! Wait what?')

    try:
        yolo.get_model(bot.username)
    except:
        print('Error! Cannot load model!')

    # check if there is a channel that already exists between this two user
    channel = Channel.query.filter( Channel.from_user.in_([from_user, to_user]) ) \
                            .filter( Channel.to_user.in_([from_user, to_user]) ) \
                            .first()
    if not channel:
        # Generate a channel...
        chat_channel = "private-chat_%s_%s" % (from_user, to_user)

        new_channel = Channel()
        new_channel.from_user = from_user
        new_channel.to_user = to_user
        new_channel.name = chat_channel
        db_session.add(new_channel)
        db_session.commit()
    else:
        # Use the channel name stored on the database
        chat_channel = channel.name

    data = {
        "from_user": from_user,
        "to_user": to_user,
        "from_user_notification_channel": from_user_channel,
        "to_user_notification_channel": to_user_channel,
        "channel_name": chat_channel,
    }

    # Trigger an event to the other user
    pusher.trigger(to_user_channel, 'new_chat', data)

    return jsonify(data)
Exemplo n.º 24
0
 def add_bot(self, channel, name):
     channel = channel.lower()
     name = name.lower()
     try:
         Bot.get(Bot.name == name)
     except peewee.DoesNotExist:
         pass  # this seems really unpythonic somehow
     else:
         raise KeyError('Bot already exists')
     try:
         chan_o = Channel.get(Channel.name == channel)
     except peewee.DoesNotExist:
         chan_o = Channel.create(name=channel)
     Bot.create(name=name,
                channel=chan_o)
Exemplo n.º 25
0
def channel_add():
    name = request.form.get("name")

    new_channel = Channel(name=name,
                          slack_webhook="",
                          user_id=flask_login.current_user.user.id,
                          discord_webhook="",
                          count=0,
                          active=True)
    db.session.add(new_channel)
    db.session.commit()
    new_channel.code = hashids.encode(new_channel.id + 100)
    db.session.commit()
    flash("Project added successfully", "success")
    return redirect(url_for("channel_detail", id=new_channel.id))
Exemplo n.º 26
0
def channel_add():
    user = current_user()
    is_admin = is_administrator(user)
    log('Is admin? ', is_admin)
    if is_admin:
        j = request.json
        c = Channel(j)
        c.save()
        responseData = {
            'channel_name': c.name,
            'channel_id': c.id,
        }
        return json.dumps(responseData, indent=2)
    else:
        abort(401)
Exemplo n.º 27
0
def channel_compile(update, context, user, text) -> str:
    """ Handler: fsm:2.1 -> ___ """
    language = user.settings.language
    state = user.settings.fsm_state

    # TODO: don't use a context menu -> takes too long to start up.
    # use client.start() at initializiation.
    with client:
        # TODO: make sure the client doesn't get Floodwaited..
        # If more accounts (i.e. clients) are to be used, there needs to be
        # an efficient way to distribute the load.
        try:
            channel = client.get_chat(text)
        except BadRequestPyro:  # raised if username isn't occupied
            return txt['CALLBACK']['error_channel'][language]

        if channel.type != 'channel':
            return txt['CALLBACK']['error_channel'][language]

        last_message_id = client.get_history(chat_id=channel.id,
                                             limit=1)[0].message_id

    try:
        db_channel = Channel(channel_id=channel.id,
                             username=text,
                             last_entry_id=last_message_id,
                             title=channel.title,
                             description=channel.description).save()
    except errors.NotUniqueError:
        db_channel = Channel.get_channel(channel.id)

        if user.user_id in db_channel.subscribed:
            return txt['CALLBACK']['repeated_channel'][language]

    # adding the user to subscribed list in the channel document
    db_channel.subscribed.append(user.user_id)
    db_channel.meta_info.fetched = True
    db_channel.save()
    # adding channel to subscribed on the user document
    user.subscribed.channel_list.append(db_channel.pk)
    user.subscribed.session_list.append(db_channel.title)
    user.save()

    # format the channel looks, etc.
    channel_formatted = f"<a href=\"{db_channel.link}\">" + \
        f"{utility.escape(channel.title)}</a>"

    return txt['FSM'][f'{state}b']['text'][language].format(channel_formatted)
Exemplo n.º 28
0
    def __init__(self, parent, ctx, args, guild, user, channel):
        """
        Command handler for SessionCommand

        Parameters
        ----------
        parent : DreamcraftHandler
            The handler for Dreamcraft Bot commands and subcommands
        ctx : object(Context)
            The Discord.Context object used to retrieve and send information to Discord users
        args : array(str)
            The arguments sent to the bot to parse and evaluate
        guild : Guild
            The guild object containing information about the server issuing commands
        user : User
            The user database object containing information about the user's current setttings, and dialogs
        channel : Channel
            The channel from which commands were issued

        Returns
        -------
        SessionCommand - object for processing session commands and subcommands
        """

        self.parent = parent
        self.new = parent.new
        self.delete = parent.delete
        self.ctx = ctx
        self.args = args[1:]
        self.guild = guild
        self.user = user
        self.command = self.args[0].lower() if len(self.args) > 0 else 'n'
        channel = 'private' if ctx.channel.type.name == 'private' else ctx.channel.name
        self.channel = Channel().get_or_create(channel, self.guild.name,
                                               self.user)
        self.scenario = Scenario().get_by_id(
            self.channel.active_scenario
        ) if self.channel and self.channel.active_scenario else None
        self.sc = Scene().get_by_id(
            self.channel.active_scene
        ) if self.channel and self.channel.active_scene else None
        self.session = Session().get_by_id(
            self.channel.active_session
        ) if self.channel and self.channel.active_session else None
        self.can_edit = self.user.role == 'Game Master' if self.user and self.session else True
        self.char = Character().get_by_id(
            self.user.active_character
        ) if self.user and self.user.active_character else None
Exemplo n.º 29
0
    def UpdateChannelStats(self):
        """Recompute num_members for a channel."""
        channel = Channel.ChannelByName(self.request.get('channel'),
                                        create=False)
        if not channel: return  # channel became empty?
        num_members = int(self.request.get('num_members', '0'))

        q = Person.all(keys_only=True).filter('channel =',
                                              channel).order('__key__')
        start_at = self.request.get('start_at')
        if start_at:
            q.filter('__key__ >', db.Key(start_at))
        people = q.fetch(self._STATS_BATCH)
        if people:
            # More to go.
            num_members += len(people)
            params = {
                'channel': channel.name,
                'num_members': num_members,
                'start_at': str(people[-1]),
            }
            taskqueue.Task(url='/task/update-channel-stats',
                           params=params).add('stats')
            return
        # Finished
        channel.num_members = num_members
        channel.put()
        logging.debug('%s now has %d members.' % (channel, num_members))
Exemplo n.º 30
0
 def names_command(self, msg):
     """Handle /names commands."""
     m = re.match(r'^(#(?P<channel>' + Channel.CHANNEL_NAME_REGEX + '))?$',
                  msg.arg)
     if not m:
         msg.reply('* Bad /names syntax')
         return
     if m.group('channel'):
         channel = Channel.ChannelByName(m.group('channel'), create=False)
         if not channel:
             msg.reply('* No such channel: #%s' % m.group('channel'))
             return
     else:
         channel = self.person.channel
         if not channel:
             msg.reply(
                 '* You either need to be in a channel, or specify one.')
             return
     q = Person.all().filter('channel =', channel)
     people = q.fetch(self._NAME_LIMIT + 1)
     if len(people) <= self._NAME_LIMIT:
         people = people[0:self._NAME_LIMIT]
         names = sorted([str(p) for p in people])
         msg.reply('* Members of %s: %s' % (channel, ' '.join(names)))
     else:
         msg.reply('* More than %d people in %s' %
                   (self._NAME_LIMIT, channel))
Exemplo n.º 31
0
 def list_command(self, msg):
     """Handle /list commands."""
     lines = []
     q = Channel.all().order('-num_members').filter('num_members >', 0)
     channels = q.fetch(self._LIST_LIMIT + 1)
     if not len(channels):
         msg.reply('* No channels exist!')
         return
     if len(channels) <= self._LIST_LIMIT:
         # Show all, sorted by channel name.
         channels.sort(key=lambda c: c.name)
         lines.append('* All channels:')
     else:
         # Show the top N channels, sorted by num_members.
         channels.pop()
         lines.append(
             '* More than %d channels; here are the most popular:' %
             self._LIST_LIMIT)
     for c in channels:
         if c.num_members == 1:
             count = '1 person'
         else:
             count = '%d people' % c.num_members
         s = '* - %s (%s)' % (c, count)
         lines.append(s)
     msg.reply('\n'.join(lines))
Exemplo n.º 32
0
def newchan(request):
	if request.method == 'POST':
		uc = NewChanForm(request.POST)
		if uc.is_valid():
			cname = uc.cleaned_data['cname']
			chan = Channel(name=cname, description=uc.cleaned_data['desc'], publish=[request.user.username,], subscribe=[request.user.username,], creator=request.user)
			#request.user.publish.append(cname)
			#request.user.subscribe.append(cname)
			chan.save()
			#request.user.save()
			return render_to_response('chancreated.html', {'cname': cname}, context_instance=RequestContext(request))
		else:
			return render_to_response('chancreate.html', {'form': uc}, context_instance=RequestContext(request))
		
	uc = NewChanForm()
	return render_to_response('chancreate.html', {'form': uc}, context_instance=RequestContext(request))
Exemplo n.º 33
0
Arquivo: main.py Projeto: Korben85/bot
    async def nudge_channel(message, stripped, preferences):

        time_parser = TimeExtractor(stripped, preferences.timezone)

        try:
            t = time_parser.extract_displacement()

        except InvalidTime:
            await message.channel.send(embed=discord.Embed(
                description=preferences.language.get_string('nudge/invalid_time')))

        else:
            if 2 ** 15 > t > -2 ** 15:
                channel, _ = Channel.get_or_create(message.channel)

                channel.nudge = t

                session.commit()

                await message.channel.send(
                    embed=discord.Embed(description=preferences.language.get_string('nudge/success').format(t)))

            else:
                await message.channel.send(
                    embed=discord.Embed(description=preferences.language.get_string('nudge/invalid_time')))
Exemplo n.º 34
0
def channel(channel_name):
    new_channel_form = NewChannelForm()
    new_post_form = NewPostForm()
    if request.method == "POST":
        if new_channel_form.submit.data and new_channel_form.validate_on_submit(
        ):
            channel = Channel(name=new_channel_form.channel_name.data)
            db.session.add(channel)
            db.session.commit()
            new_channel_form.channel_name.data = ""
            return redirect(url_for("channel", channel_name=channel_name))
        elif new_post_form.submit.data and new_post_form.validate_on_submit():
            post = Post(body=new_post_form.post_body.data,
                        timestamp=datetime.utcnow(),
                        user_id=current_user.id,
                        channel_id=Channel.query.filter_by(
                            name=channel_name).first().id)
            db.session.add(post)
            db.session.commit()
            new_post_form.post_body.data = ""
            return redirect(url_for("channel", channel_name=channel_name))

    channels = Channel.query.all()
    if not any(channel_name == channel.name for channel in channels):
        return redirect(url_for("channels"))
    cur_channel = Channel.query.filter_by(name=channel_name).first()
    posts = cur_channel.posts
    return render_template("channel.html",
                           new_channel_form=new_channel_form,
                           new_post_form=new_post_form,
                           channels=channels,
                           posts=posts)
Exemplo n.º 35
0
def send(event, message):
    from models import Channel
    for channel in Channel.query():
        channel.send({
            'event': event,
            'data': message
        })
Exemplo n.º 36
0
 def post(self, *args, **kwargs):
     db_connection = self.get_db_connection()
     already_joined = True
     channel_repo = ChannelRepository(db_connection)
     channel_name = self.get_argument('channel')
     channel = yield channel_repo.filter({'name': channel_name})
     if not channel:
         channel = Channel(name=channel_name)
         yield channel_repo.save(channel)
     channel_user_repo = ChannelUserRepository(db_connection)
     channel_user = yield channel_user_repo.filter({
         'user': self.current_user,
         'channel': channel
     })
     if not channel_user:
         already_joined = False
         channel_user = ChannelUser(channel=channel,
                                    user=self.current_user,
                                    admin=True)
         yield channel_user_repo.save(channel_user)
         message_text = '{} has subscribed to the channel'.format(
             self.current_user.name)
         message = Message(channel=channel, text=message_text)
         message_repo = MessageRepository(db_connection)
         yield message_repo.save(message)
         yield message_repo.publish_message(message)
     yield self.release_db_connection(db_connection)
     self.write_json_response({
         'status': True,
         'channel': {
             'name': channel.name,
             'id': channel.id,
             'already_joined': already_joined,
         }
     })
Exemplo n.º 37
0
def populate():
    q=Channel.gql("WHERE id=:1", 'koan')
    channel=q.get()
    code="""
__author__ = 'peter'

from application import settings
import logging

MSG_TYPE_TEXT = u'text'
MSG_TYPE_LOCATION = u'location'
MSG_TYPE_IMAGE = u'image'

def process_text(remark, retort):
    if remark['content']:
        retort['content']='Bot Spawned!'
        retort['msgType']=MSG_TYPE_TEXT
        retort['funcFlag']=0
    return retort

def process_location(remark, retort):
    return retort

def process_image(remark, retort):
    return retort
    """
    bot=Bot(name=u'spawn', code=code, channel=channel.key)
    bot.put()
    return 'populated.'
Exemplo n.º 38
0
 def get(self):
     outlets = Outlet.all().filter("target =", self.account).fetch(100)
     if len(self.request.path.split("/")) > 2:
         source = Account.get_by_hash(self.request.path.split("/")[-1])
         channel = Channel.get_by_source_and_target(source, self.account)
         self.render("templates/source.html", locals())
     else:
         enabled_channels = Channel.get_all_by_target(self.account).order("-count").filter("status =", "enabled")
         # TODO: remove me after a while. this is to fix my poor reference management
         for c in enabled_channels:
             try:
                 c.outlet
             except:
                 c.outlet = None
                 c.put()
         self.render("templates/sources.html", locals())
Exemplo n.º 39
0
def fetch_new_questions():
    res = ''
    channels = Channel.query().fetch(Channel.MAXIMUM_CHANNELS_NUMBER)
    for c in channels:
        c.fetch_new_questions()
        res += u'Channel: {}<br/>{}<br/>'.format(c.title, c.data)
    return res
Exemplo n.º 40
0
 def setupChannels(self):
     cfg = configparser.ConfigParser()
     cfg.read("config/channels.ini")
     for section in cfg.sections():
         validToken = False
         while not validToken:
             try:
                 channel = Channel.Channel(int(section), self._helix, self)
                 for option in cfg.options(section):
                     category = Category.Category(option, section)
                     emoteList = cfg[section][option].split(",")
                     for emote in emoteList:
                         category.addEmote(emote)
                     channel.addCategory(category)
                 self.addChannel(channel)
                 validToken = True
             except requests.exceptions.HTTPError as http_err:
                 statusCode = http_err.response.status_code
                 if statusCode == 401:
                     print(
                         "401 Unauthorized error, refreshing access token")
                     self.refreshToken()
                 else:
                     print("Other error received:", statusCode)
                     break
     self.hasChannels = True
Exemplo n.º 41
0
  def post(self, channelid):
    """Handles a POST to the /channel/{id}/subscriber/ resource
    which is to add a subscriber to the channel
    """
#   Get channel first
    channel = Channel.get_by_id(int(channelid))
    if channel is None:
      self.response.out.write("Channel %s not found" % (channelid, ))
      self.response.set_status(404)
      return

#   Add subscriber
    name = self.request.get('name').rstrip('\n')
    resource = self.request.get('resource').rstrip('\n')
    subscriber = Subscriber()
    subscriber.channel = channel
    subscriber.name = name
    subscriber.resource = resource
    subscriber.put()
#   Not sure I like this ... re-put()ing
    if len(subscriber.name) == 0:
      subscriber.name = 'subscriber-' + str(subscriber.key().id())
      subscriber.put()

#   If we've got here from a web form, redirect the user to the 
#   channel subscriber resource, otherwise return the 201
    if self.request.get('subscribersubmissionform'):
      self.redirect(self.request.path_info)
    else:
      self.response.headers['Location'] = self.request.url + str(subscriber.key().id()) + '/'
      self.response.set_status(201)
Exemplo n.º 42
0
 def list_command(self, msg):
   """Handle /list commands."""
   lines = []
   q = Channel.all().order('-num_members').filter('num_members >', 0)
   channels = q.fetch(self._LIST_LIMIT + 1)
   if not len(channels):
     msg.reply(u'* 沒有任何頻道!')
     return
   if len(channels) <= self._LIST_LIMIT:
     # Show all, sorted by channel name.
     channels.sort(key=lambda c: c.name)
     lines.append('* 所有頻道清單如下:')
   else:
     # Show the top N channels, sorted by num_members.
     channels.pop()
     lines.append('* 頻道數超過 %d; 底下是最受歡迎的清單:' %
                  self._LIST_LIMIT)
   for c in channels:
     if c.num_members == 1:
       count = '1 個人'
     else:
       count = '%d 個人' % c.num_members
     s = '* - %s (%s)' % (c, count)
     lines.append(s)
   msg.reply(u'\n'.join(lines))
Exemplo n.º 43
0
    def post(self):
        body = self.check_body(['title', 'base64_img'])
        logging.debug('called')
        try:
            channel = Channel.query(Channel.title == body['title']).get()
            logging.info(body)

            if channel:
                channel.put()
                self.response.out.write(channel.key.id())
            else:
                channel_id = Channel.create(title=body['title'],
                                            base64_img=body['base64_img'])
                self.response.out.write(channel_id)
        except ValueError as e:
            self.abort(code=404, detail=e.message)
Exemplo n.º 44
0
def create_channel():
    req = request.get_json()
    name = req['name']
    creator = current_user
    # Check if the creator has created a channel with that name before
    bad_name = str.strip(name.lower()) in [channel.name.lower() for channel in creator.channels]
    if bad_name:
        return jsonify(
            {
                'success': False,
                'error': 'Channel name already exisits for this user'
            }
        )

    new_channel = Channel(name=name, creator=creator)
    db.session.add(new_channel)
    db.session.commit()

    socketio.emit('new channel',
                  {
                      'name': name,
                      'creator': current_user.username
                  },
                  broadcast=True
                  )
    return jsonify(
        {
            'success': True,
        }
    )
Exemplo n.º 45
0
 def decorated_view(*args, **kwargs):
     channel=kwargs['channel']
     channel=Channel.gql("WHERE id = :1", channel).get()
     if channel:
         kwargs['channel']=channel
         return func(*args, **kwargs)
     return redirect(url_for('qq.list_channels'))
Exemplo n.º 46
0
 def list_command(self, msg):
   """Handle /list commands."""
   lines = []
   q = Channel.all().order('-num_members').filter('num_members >', 0)
   channels = q.fetch(self._LIST_LIMIT + 1)
   if not len(channels):
     msg.reply('* No channels exist!')
     return
   if len(channels) <= self._LIST_LIMIT:
     # Show all, sorted by channel name.
     channels.sort(key=lambda c: c.name)
     lines.append('* All channels:')
   else:
     # Show the top N channels, sorted by num_members.
     channels.pop()
     lines.append('* More than %d channels; here are the most popular:' %
                  self._LIST_LIMIT)
   for c in channels:
     if c.num_members == 1:
       count = '1 person'
     else:
       count = '%d people' % c.num_members
     s = '* - %s (%s)' % (c, count)
     lines.append(s)
   msg.reply('\n'.join(lines))
Exemplo n.º 47
0
def new_channel():
    """Create a new channel"""

    if request.method == 'POST':
        error = None

        # Get user input
        channel_name = request.form.get('channel_name')

        # Form validation
        if not channel_name:
            error = 'Enter channel name'
        elif channel_name in channels.keys():
            error = 'Channel already exists'

        # Create channel if no error
        if error is None:
            ch = Channel(channel_name)
            channels[f'{channel_name}'] = ch

            return redirect(url_for('index'))

        # Display error in form
        flash(error)

    return render_template('new_channel.html')
Exemplo n.º 48
0
 def open(self, channel):
     #logging.info("opened connection")
     self.board_name = 'board:' + channel
     publisher.subscribe(self.board_name, self.on_new_board_message)
     self.channel = Channel(self.board_name)
     # when client connects send all commands written
     for cmd in iter(self.channel.get_commands()):
        self.write_message(cmd)
Exemplo n.º 49
0
 def _initialize_channels_and_users(self):
   self.info('Loading channels and users...')
   channel_id_to_name_map, channel_name_to_id_map = \
       self.slack.channel_id_name_maps()
   with self.database_manager.transaction():
     for k, v in channel_id_to_name_map.items():
       is_direct = True if k.startswith('D0') else False
       try:
         channel = Channel.get(
             Channel.slack_id == k
         )
         channel.slack_name = v
         channel.is_direct = is_direct
         channel.save()
       except Channel.DoesNotExist:
         channel = Channel.create(
             slack_name=v,
             slack_id=k,
             is_direct=is_direct
         )
       except Exception as e:
         self.error(e)
       channel_members = self.slack.channel_members(channel.slack_name)
       for channel_member in channel_members:
         is_slackbot = True if channel_member[1] == 'USLACKBOT' else False
         try:
           user = User.get(
               User.slack_name == channel_member[1],
               User.slack_id == channel_member[0],
               User.is_slackbot == is_slackbot
           )
         except User.DoesNotExist:
           user = User.create(
               slack_name=channel_member[1],
               slack_id=channel_member[0],
               is_slackbot=is_slackbot
           )
         except Exception as e:
           self.error(e)
         try:
           ChannelUserRelationship.create(
               channel=channel,
               user=user
           )
         except:
           pass
Exemplo n.º 50
0
def list_channels():
    """List all channels"""
    channels = Channel.query()
    form = ChannelForm()
    if form.validate_on_submit():
        channel = Channel(
            id = form.id.data,
            name = form.name.data,
            token = form.token.data,
        )
        try:
            channel.put()
            flash(u'Channel %s successfully saved.' % channel.id, 'success')
            return redirect(url_for('qq.list_channels'))
        except CapabilityDisabledError:
            flash(u'App Engine Datastore is currently in read-only mode.', 'info')
            return redirect(url_for('qq.list_channels'))
    return render_template('list_channels.html', channels=channels, form=form)
 def get(self, op):
   if op == 'channels':
     channels = Channel.all().order('-num_members').fetch(self._MAX_CHANNELS)
     self.Render('channels.html', {
         'channels': channels,
         'max': min(len(channels), self._MAX_CHANNELS),
     })
   elif op == 'transcript':
     self.RenderTranscript()
Exemplo n.º 52
0
 def get(self, server, channel):
     key = db.Key.from_path(Channel.kind(), '%s/%s' % (unquote(channel), server))
     channel = Channel.get(key)
     date = self.request.GET.get('date')
     if date:
         start_date = datetime.strptime(date, '%Y-%m-%d').date()
     else:
         start_date = datetime.utcnow().date()
     end_date = start_date + timedelta(days=1)
     messages = Message.all().filter('channel =', channel) \
                 .filter('timestamp >= ', start_date) \
                 .filter('timestamp < ', end_date) \
                 .order('timestamp')
     # date based pagination
     next_day = start_date + timedelta(days=1)
     if next_day > datetime.utcnow().date():
         next_day = None
     previous_day = end_date - timedelta(days=2)
     self.response.out.write(render('templates/channel.html', locals()))
     
Exemplo n.º 53
0
    def get_channel(self, name):
        """
        Get channel information

        :param name: name of the channel

        """

        data = self._get('channels/{0}'.format(name))
        channel = Channel.object_from_dict(data)
        return channel
Exemplo n.º 54
0
def updateInfo(key, gogo_id):
    channel = Channel.get(key)
    programs = list(Program.gql("WHERE channel = :channel", channel = channel))
    for p in programs:
        p.delete()
    for day in range(1,8): #iterate week
        logging.info('updating info of ' + channel.name)
        try:
            updatePrograms(channel, day, gogo_id)
        except Exception, e:
            logging.error('error happened, while updating: ' + e.message)
Exemplo n.º 55
0
def create_channel(session, station_id, client_id=None, name="TestChannel"):
    channel = Channel()
    channel.station_id = station_id
    channel.name = name
    channel.ecc_id = 159
    channel.frequency = "00917"
    channel.pi = "C00F"
    channel.type_id = "fm"
    if client_id:
        channel.fk_client = client_id
    session.add(channel)
    session.commit()
    time.sleep(config.SPI_GENERATION_INTERVAL * 3)
    return channel
Exemplo n.º 56
0
    def post(self, hash):
        hash = hash.lower()
        target = Account.all().filter("hash =", hash).get()
        if not target:
            target = Account.all().filter("hashes =", hash).get()
        source = Account.all().filter("api_key =", self.request.get("api_key")).get()

        channel = Channel.all().filter("target =", target).filter("source =", source).get()
        approval_notice = None
        if not channel and source and target:
            channel = Channel(target=target, source=source, outlet=target.get_default_outlet())
            channel.put()
            approval_notice = channel.get_approval_notice()
            channel.send_activation_email()

        if channel:
            notice = Notification(channel=channel, text=strip_tags(self.request.get("text")), icon=source.source_icon)
            for arg in ["title", "link", "icon", "sticky", "tags"]:
                value = strip_tags(self.request.get(arg, None))
                if value:
                    setattr(notice, arg, value)
            notice.put()

            # Increment the counter on the channel to represent number of notices sent
            channel.count += 1
            channel.put()

            if channel.status == "enabled":
                notice.dispatch()
                self.response.out.write("OK\n")

            elif channel.status == "pending":
                self.response.set_status(202)
                if approval_notice:
                    approval_notice.dispatch()
                    self.response.out.write("OK\n")
                else:
                    self.response.out.write("202 Pending approval")
            elif channel.status == "disabled":
                self.response.set_status(202)
                self.response.out.write("202 Accepted but disabled")
        else:
            self.error(404)
            self.response.out.write("404 Target or source not found")
Exemplo n.º 57
0
 def post(self): 
     hash = self.request.path.split('/')[-1]
     target = Account.all().filter('hash =', hash).get()
     if not target:
         target = Account.all().filter('hashes =', hash).get()
     source = Account.all().filter('api_key =', self.request.get('api_key')).get()
     
     channel = Channel.all().filter('target =', target).filter('source =', source).get()
     approval_notice = None
     if not channel and source and target:
         channel = Channel(target=target, source=source, outlet=target.get_default_outlet())
         channel.put()
         approval_notice = channel.get_approval_notice()
         channel.send_activation_email()
         
     if channel:
         notice = Notification(channel=channel, text=strip_tags(self.request.get('text')), icon=source.source_icon)
         for arg in ['title', 'link', 'icon', 'sticky', 'tags']:
             value = strip_tags(self.request.get(arg, None))
             if value:
                 setattr(notice, arg, value)
         notice.put()
         
         # Increment the counter on the channel to represent number of notices sent
         channel.count += 1
         channel.put()
         
         if channel.status == 'enabled':
             self.response.out.write(notice.dispatch())
             
         elif channel.status == 'pending':
             self.response.set_status(202)
             if approval_notice:
                 self.response.out.write(":".join([channel.outlet.hash, approval_notice.to_json()]))
             else:
                 self.response.out.write("202 Pending approval")
         elif channel.status == 'disabled':
             self.response.set_status(202)
             self.response.out.write("202 Accepted but disabled")
     else:
         self.error(404)
         self.response.out.write("404 Target or source not found")
Exemplo n.º 58
0
  def get(self, channelid):
    """Handles a GET to the /channel/{id}/subscriber/submissionform resource
    """
    channel = Channel.get_by_id(int(channelid))
    if channel is None:
      self.response.out.write("Channel %s not found" % (channelid, ))
      self.response.set_status(404)
      return

    template_values = {
      'channel': channel,
      'channelsubscriberresource': '/channel/' + channelid + '/subscriber/',
    }
    path = os.path.join(os.path.dirname(__file__), 'subscribersubmissionform.html')
    self.response.out.write(template.render(path, template_values))
Exemplo n.º 59
0
class MessagesCatcher(tornado.websocket.WebSocketHandler):

    def __init__(self, *args, **kwargs):
        super(MessagesCatcher, self).__init__(*args, **kwargs)

    def open(self, channel):
        #logging.info("opened connection")
        self.board_name = 'board:' + channel
        publisher.subscribe(self.board_name, self.on_new_board_message)
        self.channel = Channel(self.board_name)
        # when client connects send all commands written
        for cmd in iter(self.channel.get_commands()):
           self.write_message(cmd)

    def on_new_board_message(self, result):
        """ called when other client draws """
        # publish in the channel
        try:
            self.write_message(result)   
        except IOError as e:
            # when client closes the page websocket is not closed
            # but connection do, so unsuscribe from channel
            self.close()

    def on_message(self, result):
        """ client message with draw command """
            # publish to other clients
        publisher.publish(self.board_name, result)
        self.channel.add_command(result)

    def close(self):
        publisher.unsubscribe(self.board_name, self.on_new_board_message)
        try:
            super(MessagesCatcher, self).close()
        except IOError:
            pass # java rocks
Exemplo n.º 60
0
 def start(self):
   self.database_manager.connect()
   self.database_manager.create_tables(Base)
   self._initialize_channels_and_users()
   self._create_slackotron_user()
   self.info('Users:')
   for user in User.select():
     self.info(user)
   self.info('Channels:')
   for channel in Channel.select():
     self.info(channel)
   self.plugin_manager.start_plugins()
   self.thread_manager.start_threads()
   self.dashboard_manager.start_dashboard()
   self.run()