Exemplo n.º 1
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.º 2
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()
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 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.º 5
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.º 6
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.º 7
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.º 8
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.º 9
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.º 10
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.º 11
0
    def add_channel(self, channel_id):
        #GET https://www.googleapis.com/youtube/v3/channels?part=snippet&id=UCskcws9RtJPRM02UVe43BQA&key={YOUR_API_KEY}
        head = {'referer': 'http://' + 'www.hominem.se'}
        payload = {'key': settings.APIKEY, 'part': 'snippet', 'id': channel_id}
        try:
            log.info("sending request")
            r = requests.get('https://www.googleapis.com/youtube/v3/channels',
                             headers=head,
                             params=payload)
            data = json.loads(r.text)
            log.info("got result " + str(data))
            if 'items' not in data:
                log.error("bad channel id?")
                return
            for channel in data['items']:
                log.info("Channel data: " + str(channel))
                if channel['kind'] != 'youtube#channel':
                    log.error('kind is not youtube channel')
                    continue

                s = channel['snippet']
                title = s['title']
                channelId = channel_id
                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)
                    self.update_videos(q)
                else:
                    log.info("Channel " + title + "already exists")

        except requests.RequestException as e:
            log.error("Exception in requests.get when searching: " + str(e))
        return
Exemplo n.º 12
0
def _get_new_posts(self, channel: Channel) -> list:
    """
    Grabs all the new posts from a channel

    :param channel: document from the Channel collection
    :return: a list of messages (posts)
    """
    # ensure the channel is resolved
    # TODO: this might need to be improved due to flood limits.
    _ = self.client.get_chat(channel.username)

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

    if last_message_id == channel.last_entry_id:
        return []

    posts = []

    # prevents from users flooding the bot, so we just grab at most last
    # 15 messages from the channel.
    for message in self.client.iter_history(channel.channel_id, limit=15):
        if message.message_id <= channel.last_entry_id:
            break

        posts.append(message)

    # the list needs to be reversed as posts go from new to old, and
    # users need to be served chronologically.
    posts.reverse()

    # update the last_message_id as new data has been fetched.
    channel.last_entry_id = last_message_id
    channel.save()

    return posts
Exemplo n.º 13
0
def insertChannel(ytUserID_, tags_, comment_):
    ytUserID_ = ytUserID_

    #attempt to change username to channel ID
    client = build(API_SERVICE_NAME, API_VERSION, developerKey=DEVELOPER_KEY)

    results = client.channels().list(part="snippet,contentDetails,statistics",
                                     forUsername=ytUserID_).execute()
    responseList = results.get('items', [])
    if len(responseList) > 0:
        ytUserID_ = responseList[0]['id']
    try:
        URL = "https://socialblade.com/youtube/channel/" + ytUserID_
        req = requests.get(URL)
        soup = BeautifulSoup(req.text, 'html.parser')
        ##SCRAPE
        ytURL_ = soup.find_all('a', href=True)[121]['href']
        subscriberCount_ = soup.find(
            id="youtube-stats-header-subs").contents[0]
        country_ = soup.find(id="youtube-stats-header-country").contents[0]
        sd = soup.find_all(style="font-weight: bold;")[5].contents[0]
        sd = sd.replace("st", "")
        sd = sd.replace("nd", "")
        sd = sd.replace("rd", "")
        sd = sd.replace("th", "")
        startdate_ = datetime.datetime.strptime(sd, "%b %d, %Y")
        earnings_ = soup.find(
            style=
            "font-size: 1.4em; color:#41a200; font-weight: 600; padding-top: 20px;"
        ).contents[0]
        eList = earnings_.split("$")
        eList[1] = eList[1].replace(" - ", "")
        eList = eList[1:3]
        for t in range(len(eList)):
            if eList[t].find("K") != -1:
                eList[t] = 1000 * float(eList[t].replace("K", ""))
            elif eList[t].find("M") != -1:
                eList[t] = 1000000 * float(eList[t].replace("M", ""))
        minMonthEarnings_ = int(float(eList[0]))
        maxMonthEarnings_ = int(float(eList[1]))
        subscriberRank_ = soup.find(
            style=
            "font-size: 1.6em; color:#41a200; padding-top: 10px; font-weight: 600;"
        ).contents[0].replace(",", "")
        subscriberRank_ = int(subscriberRank_[0:len(subscriberRank_) - 2])
        viewRank_ = soup.find(
            id="afd-header-videoview-rank").contents[0].replace(",", "")
        viewRank_ = int(viewRank_[0:len(viewRank_) - 2])
        title_ = soup.find(
            style=
            "float: left; font-size: 1.4em; font-weight: bold; color:#333; margin: 0px; padding: 0px; margin-right: 5px;"
        ).contents[0]
        ##IF CHANNEL ALREADY IN DATABASE UPDATE IT, OTHERWISE INSERT IT
        if (Channel.objects(ytUserID=ytUserID_)
                or Channel.objects(URL=ytURL_)):
            channel = Channel.objects(ytUserID=ytUserID_)
            channel.update_one(set__title=title_)
            channel.update_one(set__URL=ytURL_)
            channel.update_one(set__socialblade=URL)
            channel.update_one(set__minMonthEarnings=minMonthEarnings_)
            channel.update_one(set__maxMonthEarnings=maxMonthEarnings_)
            channel.update_one(set__subscriberCount=subscriberCount_)
            channel.update_one(set__subscriberRank=subscriberRank_)
            channel.update_one(set__viewRank=viewRank_)
            channel.update_one(push_all__tags=tags_)
            if (comment_ != ""): channel.update_one(push__comments=comment_)
        else:
            # print(title_)
            # print(startdate_)
            # print(subscriberCount_)
            # print(country_ )
            # print(URL)
            # print(ytURL_)
            # print(minMonthEarnings_)
            # print(maxMonthEarnings_)
            # print(subscriberRank_)
            # print(viewRank_)
            # init Channel object
            channel = Channel(title=title_,
                              ytUserID=ytUserID_,
                              startdate=startdate_,
                              country=country_,
                              URL=ytURL_,
                              tags=tags_,
                              comments=[comment_],
                              socialblade=URL,
                              minMonthEarnings=minMonthEarnings_,
                              maxMonthEarnings=maxMonthEarnings_,
                              subscriberRank=subscriberRank_,
                              subscriberCount=subscriberCount_,
                              viewRank=viewRank_)
            channel.save()
            print("entry updated/made")
    except (AttributeError, IndexError) as e:
        print("INVALID TARGET CHANNEL ID: " + ytUserID_)
        pass
Exemplo n.º 14
0
class DreamcraftHandler():
    """
    DreamcraftHandler class for parsing commands and assigning execution
    """

    def __init__(self, ctx, args):
        """
        Command handler for .d, the Dreamcraft Bot command

        Parameters
        ----------
        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

        Returns
        -------
        DreamcraftHandler - object for processing Context object and args (list of strings in a command)
        """
        self.ctx = ctx
        self.setup(ctx, args)

    def setup(self, ctx, args):
        """
        Setup the Dreamcraft Handler with new args

        Parameters
        ----------
        args : array(str)
            The arguments sent to the bot to parse and evaluate
        """

        self.new = False
        if len(args) and args[0].lower() == 'new':
            self.new = True
            args = args[1:] if len(args) > 1 else args
        self.delete = False
        if len(args) and args[0].lower() == 'delete':
            self.delete = True
            args = args[1:] if len(args) > 1 else args
        self.args = args
        self.guild = ctx.guild if ctx.guild else ctx.author
        self.user = User().get_or_create(ctx.author.name, self.guild.name, ctx.author.discriminator, ctx.author.display_name)
        # The 'channel' variable can either be the name of the channel on a server or 'private' if Direct Message
        channel = 'private' if ctx.channel.type.name == 'private' else ctx.channel.name
        self.channel = Channel().get_or_create(channel, self.guild.name, self.user)
        # Add the user to the list of channel users
        if str(self.user.name) not in self.channel.users:
            self.channel.users.append(str(self.user.name))
            self.channel.updated_by = str(self.user.id)
            self.channel.updated = T.now()
            self.channel.save()
        self.char = Character().get_by_id(self.user.active_character) if self.user and self.user.active_character else None
        self.module = self.char.category if self.char else None
        self.command = self.args[0].lower()
        self.alias_commands = []
        self.func = None
        self.messages = []
        self.image = ''

    def get_messages(self):
        """
        Processes Context and args through command string parsing

        Returns
        -------
        tuple(title: str, message: str)
            title : str
                The title of the response message
            message : str
                The string for the response message content
            image : str
                The string for the response message image
        """

        try:

            modules = {
                'Channel': ChannelCommand,
                'Scenario': ScenarioCommand,
                'Scene': SceneCommand,
                'Character': CharacterCommand,
                'Undo': UndoCommand,
                'User': UserCommand,
                'Zone': ZoneCommand,
                'Session': SessionCommand,
                'Engagement': EngagementCommand,
                'Revision': RevisionCommand,
                'Suggestion': SuggestionCommand
            }
            switcher = {
                'cheat': CheatCommand,
                'undo': UndoCommand,
                'redo': UndoCommand,
                'log': UndoCommand,
                'l': UndoCommand,
                'revision': RevisionCommand,
                'rev': RevisionCommand,
                'suggestion': SuggestionCommand,
                'suggest': SuggestionCommand,
                'user': UserCommand,
                'u': UserCommand,
                'alias': UserCommand,
                'channel': ChannelCommand,
                'chan': ChannelCommand,
                'character': CharacterCommand,
                'char': CharacterCommand,
                'c': CharacterCommand,
                'stats': CharacterCommand,
                'scenario': ScenarioCommand,
                'scene': SceneCommand,
                's': SceneCommand,
                'connect': SceneCommand,
                'zone': ZoneCommand,
                'z': ZoneCommand,
                'session': SessionCommand,
                'engagement': EngagementCommand,
                'engage': EngagementCommand,
                'e': EngagementCommand,
                'caa': RollCommand,
                'create': RollCommand,
                'advantage': RollCommand,
                'attack': RollCommand,
                'att': RollCommand,
                'defend': RollCommand,
                'def': RollCommand,
                'overcome': RollCommand,
                'boost': RollCommand,
                'takeout': RollCommand,
                'out': RollCommand,
                'freeinvoke': RollCommand,
                'roll': RollCommand,
                'r': RollCommand,
                'reroll': RollCommand,
                're': RollCommand,
                'clear': RollCommand,
                'erase': RollCommand,
                'invoke': RollCommand,
                'i': RollCommand,
                'compel': RollCommand,
                'available': RollCommand,
                'avail': RollCommand,
                'av': RollCommand,
                'stress': CharacterCommand,
                'st': CharacterCommand,
                'consequence': CharacterCommand,
                'con': CharacterCommand
                # 'assist': RollCommand,
                # 'concede': RollCommand
            }
            self.messages = []
            self.search = str(self.args[0])

            # Handle new syntax errors
            if 'new' in [a.lower() for a in self.args] or (self.new and (len(self.args) < 2 or self.new and len(self.args) > 0 and self.args[0] in ['h', 'help'])):
                return 'New', SETUP.new_help, self.image

            # Handle delete syntax errors
            if 'help' in [a.lower() for a in self.args] and (self.delete or 'delete' in [a.lower() for a in self.args]):
                return 'Delete', SETUP.delete_help, self.image

            # Handle alias commands
            self.get_alias()
            if self.alias_commands:
                alias_messages = []
                alias_image = ''
                for ac in self.alias_commands:
                    self.setup(self.ctx, tuple(ac.split(' ')))
                    module, messages, image = self.get_messages()
                    alias_messages.append(messages)
                    alias_image = image if not alias_image else alias_image
                return 'Alias', 'COMMAND_SPLIT'.join(alias_messages), alias_image

            # Handle dialog answers
            self.get_answer()

            # Get image to embed
            self.get_image()

            if not self.messages:
                self.shortcuts()
                # Get the function from switcher dictionary
                if switcher.get(self.command, None):
                    self.func = switcher.get(self.command, None)
                    self.module = re.sub(r'commands\.|_command', '', self.func.__module__).title()
                    if self.module != self.user.module:
                        self.user.module = self.module
                        self.user.updated_by = str(self.user.id)
                        self.user.updated = T.now()
                        self.user.save()
                # Get the function from User object
                if self.func is None and self.user.module in modules:
                    self.module = self.user.module
                    self.func = modules.get(self.module, None)
                    self.args = (self.module.lower(),) + self.args
                # Get the function from Character object
                if self.func is None and self.module in modules:
                    self.func = modules.get(self.module, None)
                    self.args = (self.module.lower(),) + self.args
                # Log every comand
                base_svc.log(str(self.user.id), self.user.name, str(self.user.id), self.guild.name, 'Command', {
                    'command': self.command,
                    'module': self.module,
                    'args': self.args
                }, 'created')
                if self.func:
                    # Execute the function and store the returned messages
                    instance = self.func(ctx=self.ctx, args=self.args, guild=self.guild, user=self.user, channel=self.channel, parent=self)
                    # Call the run() method for the command
                    self.messages = instance.run()
                else:
                    self.messages = [f'Unknown command: {self.command}']

            # Warn user of missing time zone setting
            if not self.user.time_zone:
                self.messages = ['No time zone defined```css\n.d user timezone America/New_York\n.d user timezone list Europe```\n'] + self.messages

            # Concatenate messages and send
            if self.command == 'cheat':
                return self.module, [f'{m}\n' for m in self.messages], self.image
            else:
                return self.module, '\n'.join(self.messages), self.image

        except Exception as err:
            traceback.print_exc()    
            # Log every error
            base_svc.log(
                str(self.user.id),
                self.user.name,
                str(self.user.id),
                self.guild.name,
                'Error',
                {
                    'command': self.command,
                    'args': self.args,
                    'traceback': traceback.format_exc()
                }, 'created')
            return 'Oops!', 'Hey, bugs happen! We\'re working on it...'

    def get_alias(self):
        """
        Check the list of user aliases for a match and prepare them for execution
        """

        if self.user and self.user.aliases:
            args = self.args[1:] if len(self.args) > 1 else tuple()
            for a in self.user.aliases:
                if self.command == a:
                    aliases = self.user.aliases[a]
                    for alias in aliases:
                        # Find all instances of '{}'
                        mataches = re.finditer(r'\[\]|\[([^\]]+)\]|\(\)|\(([^\)]+)\)|\{\}|\{([^\}]+)\}', alias)
                        for x in mataches:
                            if len(args):
                                alias = alias.replace(x.group(0), args[0])
                                args = args[1:] if len(args) > 1 else tuple()
                        self.alias_commands.append(alias)

    def get_answer(self):
        """
        Check for an answer if a dialog has been recorded in the user's record

        A dialog records the original command, the question string, and the answer.
        The command will track the previous command that started the dialog.
        The question will store the current state of the dialog.
        The answer is stored for processing by the command handler.
        """

        guild = self.ctx.guild if self.ctx.guild else self.ctx.author
        self.user = User().find(self.ctx.author.name, guild.name)
        if self.user and self.user.command:
            answer = ' '.join(self.args[0:])
            self.args = tuple(self.user.command.split(' '))
            if len(self.args) and self.args[0].lower() == 'new':
                self.new = True
                self.args = self.args[1:]
            if len(self.args) and self.args[0].lower() == 'delete':
                self.delete = True
                self.args = self.args[1:]
            self.command = self.args[0].lower()
            self.user.answer = answer
            self.user.updated_by = str(self.user.id)
            self.user.updated = T.now()
            self.user.save()

    def get_image(self):
        """
        Check for an action that should include an image to embed
        """

        image_switcher = {
            'caa': SETUP.action_caa_image,
            'create': SETUP.action_caa_image,
            'advantage': SETUP.action_caa_image,
            'attack': SETUP.action_attack_image,
            'att': SETUP.action_attack_image,
            'defend': SETUP.action_defend_image,
            'def': SETUP.action_defend_image,
            'overcome': SETUP.action_overcome_image
        }
        self.image = image_switcher.get(self.command, '')

    def shortcuts(self):
        """
        Check for standard approach names and skill names to update the active character

        Approach and skill names must be completely spelled out in order to trigger the shortcut feature.
        """
        # shortcut for updating approaches on a character (must enter full name)
        approach = [s for s in APPROACHES if self.search.lower() == s.split(' - ')[0].lower()] if len(self.args) > 0 else None
        if approach:
            self.command = 'c'
            self.args = ('c', 'app', approach[0].split(' - ')[0]) + (self.args[1:] if len(self.args) > 1 else tuple())
        # shortcut for updating skills on a character (must enter full name)
        skill = [s for s in SKILLS if self.search.lower() == s.split(' - ')[0].lower()] if len(self.args) > 0 else None
        if skill:
            self.command = 'c'
            self.args = ('c', 'sk', skill[0].split(' - ')[0]) + (self.args[1:] if len(self.args) > 1 else tuple())
Exemplo n.º 15
0
def channel_new():
    c = Channel(request.form)
    c.save()
    # print('channel_new: ', c)
    return render_template('new_channel.html')