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()

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()

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

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)

 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())

 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")

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)

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)

 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)

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

 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'))

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

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.'

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

  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)

 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())

def send(event, message):
    from models import Channel
    for channel in Channel.query():
        channel.send({
            'event': event,
            'data': message
        })

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

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)