def item_create(form):
    record = db(db.geo_item.f_name == request.vars.f_name).select().first()
    if record.f_qrcode == None:
        arg = str(record.id)
        path = 'http://siri.pythonanywhere.com/byui_art/default/item_details?itemId=' + arg + '&qr=True'
        tiny = ""
        shortSuccess = False
        try:
            shortener = Shortener('Tinyurl')
            tiny = "{}".format(shortener.short(path))
            session.tinyCreateException = tiny
            shortSuccess = True
        except:
            session.tinyCreateException = "There was a problem with the url shortener. Please try again."

        if shortSuccess:
            code = qrcode.make(tiny)
        else:
            code = qrcode.make(path)
        qrName='geo_item.f_qrcode.%s.jpg' % (uuid.uuid4())
        code.save(request.folder + 'uploads/qrcodes/' + qrName, 'JPEG')
        record.update_record(f_qrcode=qrName)
        qr_text(qrName, record.f_name, record.f_alt5, tiny)
    try:
        imgPath = request.folder + 'uploads/' + record.f_image
        thumbName = 'geo_item.f_thumb.%s.%s.jpg' % (uuid.uuid4(), record.id)
        thumb = Image.open(request.folder + 'uploads/' + record.f_image)
        thumb.thumbnail((350, 10000), Image.ANTIALIAS)
        thumb.save(request.folder + 'uploads/thumbs/' + thumbName, 'JPEG')
        record.update_record(f_thumb=thumbName)
    except:
        session.itemCreateException = "there was a problem updating the image in item_create: " + record.f_name
    return dict()

def tweet_post(title, url, subid):
   
    #post found scores to twitter
    CONSUMERKEY = keys[0]
    CONSUMERSECRET = keys[1]
    ACCESSKEY = keys[2]
    ACCESSSECRET = keys[3]
    
    nonDuplicateFlag = True
    
    auth = tweepy.OAuthHandler(CONSUMERKEY, CONSUMERSECRET)
    auth.set_access_token(ACCESSKEY, ACCESSSECRET)
    api = tweepy.API(auth)

    #Clean link to prepare for tweeting
    title = tweet_cleanup(title)
   
    shortener = Shortener('TinyurlShortener')
    tinyurl = shortener.short(url)
    tweet = tweet_cleanup(title)
   
    if subid in postedTweets:
        nonDuplicateFlag = False
        return
    
    post = title + tinyurl

    try:
        api.update_status(post) #post the tweet
    except:
        print('Tweet not posted. Check Issue. Length= ', len(post))
        return

    postedTweets.append(subid)
    update_db()

def test_owly_bad_key():
    b = Shortener(shorteners.OWLY_SHORTENER)
    with pytest.raises(TypeError):
        b.short('http://www.test.com')

    with pytest.raises(TypeError):
        b.expand('http://www.test.com')

def coll_create(form):
    record = db(db.geo_collection.f_name == request.vars.f_name).select().first()
    arg = str(record.id)
    path = 'http://siri.pythonanywhere.com/byui_art/default/collection_details?collectionId=' + arg + '&qr=True'
    tiny = ""
    #######################################################################
    ################## TESTING PYSHORTENERS : TINYURL #####################
    #######################################################################
    
    try:
        shortener = Shortener('TinyurlShortener')
        tiny = "{}".format(shortener.short(path))
    except:
        session.tinyCreateException = "There was a problem with the url shortener. Please try again."
    
    #######################################################################
    ###################### END PYSHORTENERS : TINYURL #####################
    #######################################################################
    

    
    code = qrcode.make(tiny)
    qrName='geo_collection.f_qrcode.%s.jpg' % (uuid.uuid4())
    code.save(request.folder + 'uploads/qrcodes/' + qrName, 'JPEG')
    qr_text(qrName, record.f_name, record.f_location, tiny)
    record.update_record(f_qrcode=qrName)
    return dict()

def test_owly_bad_key():
    b = Shortener('OwlyShortener')
    with pytest.raises(TypeError):
        b.short('http://www.test.com')

    with pytest.raises(TypeError):
        b.expand('http://www.test.com')

    def get_item_str(self, item):
        global api_key
        global cache
        global shortener_service

        if api_key:
            shortener = Shortener(shortener_service, api_key=api_key)
        else:
            shortener = None

        short_url = None
        if cache is not None:
            short_url = cache.get(item['link'])
        if short_url is None:
            # Retry 3 times for goo.gl API
            for i in range(0,3):
                try:
                    short_url = shortener.short(item['link'])
                    if short_url is not None:
                        logger.debug("Saving short url to cache")
                        cache.put(item['link'], short_url)
                except Exception as e:
                    logger.debug("Shortener threw exception {}".format(e.message))
                    continue
                break
        else:
            logger.debug("Short url cache hit")
        if short_url is None:
            url = item['link']
        else:
            url = short_url
        return '[%s] %s <%s>' % (''.join([c for c in self.name][0:18]), item['title'], url)

def test_google_bad_params():
    s = Shortener(Shorteners.GOOGLE)

    with pytest.raises(TypeError):
        s.short(expanded)

    with pytest.raises(TypeError):
        s.expand(expanded)

def test_custom_shortener():
    class MyShortenerWithBlackJackAndHookers(BaseShortener):
        def short(self, url):
            return url

    s = Shortener(MyShortenerWithBlackJackAndHookers)
    url = 'http://www.test.com'
    assert s.short(url) == url

def hello():
    short = Shortener('Tinyurl')
    print("""
Hello World! Testing TinyurlShortener with www.google.com URL
Shorten url: {}
Expanded: {}
    """.format(short.short('http://www.google.com'),
               short.expand('http://goo.gl/fbsS')))

def hello():
    googl = Shortener('GoogleShortener')

    return """
    Hello World! Testing www.google.com
    Shorten url:{} - Expanded:{}
    """.format(googl.short('http://www.google.com'),
               googl.expand('http://goo.gl/fbsS')),

def test_bitly_bad_keys():
    s = Shortener(Shorteners.BITLY)

    with pytest.raises(TypeError):
        s.short(expanded)

    with pytest.raises(TypeError):
        s.expand(shorten)

def tweet():
  args = get_args()
  creds = load_credentials()
  
  shortener = Shortener('Google', api_key=creds[0])
  tweet = Twitter(auth=OAuth(creds[1], creds[2], creds[3], creds[4]))
        
  url = "http://127.0.0.1:" + str(args.port) + "/raw_data"
  response = urllib.urlopen(url)
  dump = json.loads(response.read())
  new = copy.deepcopy(dump)
  old = {
    'pokemons': []
  }
  
  if os.path.isfile('data.json'):
    with open('data.json') as data_file:
      old = json.load(data_file)

  # Deletes encounter id for next step
  for e_new in new['pokemons']:
    for e_old in old['pokemons']:
      if e_new['encounter_id'] == e_old['encounter_id']:
        del e_new['encounter_id']
        break

  # Existing encounter ids are rare pokemon
  # This entire step is to parse the data for a tweet
  for e_new in new['pokemons']:
    if e_new['pokemon_id'] in rares:
      if 'encounter_id' in e_new:
        location = str(Geocoder.reverse_geocode(e_new['latitude'], e_new['longitude'])[0]).split(',')
        destination = location[0]
        if len(location) == 5:
          destination += ", " + location[1]
        time = datetime.datetime.fromtimestamp(e_new['disappear_time']/1000)
        ampm = "AM"
        hour = time.hour
        gmap = 'https://www.google.com/maps/dir/Current+Location/' \
                + str(e_new['latitude']) + ',' + str(e_new['longitude'])
        if hour > 12:
          hour -= 12
          ampm = "PM"
        elif hour == 12:
          ampm = "PM"
        elif hour == 0:
          hour = 12
        tweeting = "{} at {} until {}:{}:{} {}. #PokemonGo {}".format( \
          e_new['pokemon_name'], destination, \
          hour, str(time.minute).zfill(2), str(time.second).zfill(2), ampm, \
          shortener.short(gmap))
        tweet.statuses.update(status=tweeting)
        print tweeting
        # Google api timeout
        t.sleep(0.5)
    
  with open('data.json', 'w') as outfile:
    json.dump(dump, outfile)

def test_qrcode():
    s = Shortener('TinyurlShortener')
    url = 'http://www.google.com'
    mock_url = '{}?url={}'.format(s.api_url, url)
    shorten = 'http://tinyurl.com/test'
    responses.add(responses.GET, mock_url, body=shorten,
                  match_querystring=True)
    s.short(url)
    # flake8: noqa
    assert s.qrcode() == 'http://chart.apis.google.com/chart?cht=qr&chl={0}&chs=120x120'.format(shorten)

def make_link(group_name, event_id, shorten=True):
    url = "https://meetup.com/{group_name}/events/{event_id}".format(
        group_name=group_name,
        event_id=event_id)
    if shorten:
        shortener = Shortener('Tinyurl')
        try:
            url =  shortener.short(url)
        except ReadTimeout:
            pass
    return url

	def make_short(url, service):
		if service == "google":
			shortener = Shortener("Google", api_key=api_key)
		elif service == "bitly":
			shortener = Shortener("Bitly", bitly_token=access_token)
		elif service == "owly":
			shortener = Shortener("Owly", api_key=api_key)
		elif service == "tinyurl":
			shortener = Shortener("Tinyurl")
		new_url = shortener.short(url)
		return new_url

    def sensu_event(self, kwargs):
        host_params = ['action', 'client', 'check', 'occurrences', 'timestamp']
        params = {
            param: kwargs.get(param, None)
            for param in host_params
        }

        logging.info("Received request on host endpoint: " + str(params))
        logging.debug("Unpacked parameters:" + str(kwargs))

        hostname = params['client']['name']
        check = params['check']['name']
        output = self._truncate_string(params['check']['output'], length=250)

        # Custom attributes
        # broadcast is a custom check attribute to know where to send IRC notifications
        try:
            if 'broadcast' in params['check']:
                broadcast = params['check']['broadcast']
            elif 'custom' in params['check'] and 'broadcast' in params['check']['custom']:
                broadcast = params['check']['custom']['broadcast']
            else:
                logging.info("This notification does not have a broadcast assigned, not doing anything with it.")
                return False
        except KeyError as e:
            logging.info("KeyError when trying to set broadcast config: " + str(e))
            return False

        dashboard = self.bot_config.MONITORING_DASHBOARD
        check_url = "{0}/#/client/uchiwa/{1}?check={2}".format(dashboard,
                                                               hostname,
                                                               check)
        shortener = Shortener('Tinyurl')
        check_url = shortener.short(check_url)

        msg_type = {
            'create': "NEW: {0} - {1} @ {2} |#| {3}",
            'resolve': "RESOLVED: {0} - {1} @ {2} |#| {3}",
            'flapping': "FLAPPING: {0} - {1} @ {2} |#| {3}",
            'unknown': "UNKNOWN: {0} - {1} @ {2} |#| {3}"
        }

        if params['action'] in msg_type:
            msg = msg_type[params['action']].format(hostname, check, check_url,
                                                    output)
        else:
            msg = msg_type['unknown'].format(hostname, check, check_url,
                                             output)

        self._monitoring_broadcast(msg, broadcast=broadcast)

def tinyurlShort(self):
    # Determine if URL is absolute or relative
    tof = bool(urllib.parse.urlparse(self).netloc)
    if tof is True:
        return(self)
    else:
        self = (urllib.parse.urljoin('http://www.autotrader.com/', self))

    # Shorten URL or catch exceptions
    try:
        shortener = Shortener('TinyurlShortener', timeout=9000)
        autotraderFile.write((shortener.short(self)) + '\n\n')
    except Exception as err:
        autotraderFile.write('ERROR: Check the log.' + '\n\n')
        logging.error(str(err) + '\n')

def url_shorten(service, url):

    supported_services = ['Isgd']
    url = url if url.startswith('http') else ('http://%s' % url)

    if service not in supported_services:
        print 'Service "{}" is not supported, supported services are: {}'\
            .format(service, supported_services)
        return
    try:
        shortener = Shortener(service)
        print shortener.short(url)
    except ValueError:
        print 'Invalid url given'
    except Exception as e:
        print 'Unable to shorten the url'

def exhi_create(form):
    record = db(db.geo_exhibit.f_name == request.vars.f_name).select().first()
    arg = str(record.id)
    path = 'http://siri.pythonanywhere.com/byui_art/default/exhibit_details?exhibitId=' + arg + '&qr=True'
    tiny = ""
    try:
        shortener = Shortener('TinyurlShortener')
        tiny = "{}".format(shortener.short(path))
    except:
        session.tinyCreateException = "There was a problem with the url shortener. Please try again."
    
    code = qrcode.make(tiny)
    qrName='geo_exhibit.f_qrcode.%s.jpg' % (uuid.uuid4())
    code.save(request.folder + 'uploads/qrcodes/' + qrName, 'JPEG')
    qr_text(qrName, record.f_name, '', tiny)
    record.update_record(f_qrcode=qrName)

def generateText(match):
	report = ""
	report += "Update: "
	report += getTeamAlliance(match)
	if (didTeamWin(match) == 1):
		report += (" won " + getMatchTitle(match) + " against ")
	elif (didTeamWin(match) == -1):
		report += (" lost " + getMatchTitle(match) + " to ")
	elif (didTeamWin(match) == 0):
		report += (" tied " + getMatchTitle(match) + " with ")
	report += (getOpposingAlliance(match) + ", " + getScore(match))
	report += ". Full Tournament Results: "
	shortener = Shortener('GoogleShortener', api_key=shortenerAPIKey)
	robotEventsURL = "http://www.robotevents.com/%s.html#tabs-results" % eventSKU
	report += shortener.short(robotEventsURL)
	return report