Esempio n. 1
0
def url(name):

    form = UrlForm()
    urls = mongo.db[name]
    mssg=''
    if session['username']:
        if request.method == 'POST':
            existing_url = urls.find_one({'original':form.urls.data})

            if existing_url:
                mssg = 'URL already shortened'
                hi = urls.find()
                return render_template('shortner.html', form=form, name=name, hi=hi, mssg=mssg)

            else:
                if form.validate_on_submit():
                    rand = random.randint(0, pow(10, 5))
                    temp = "http://127.0.0.1:5000/"+name+"/"+ str(rand)
                    urls.insert({'original':form.urls.data,'short':temp})
                    return redirect(url_for('url', name=name))

        else:
            hi = urls.find()
            return render_template('shortner.html', form=form, name=name, hi=hi,mssg=mssg)

    return redirect(url_for('login'))
Esempio n. 2
0
def main(request, **kwargs):
    if request.method == "POST":
        form = UrlForm(request.POST)
        if form.is_valid():
            url = Url()
            url.original_url = form.cleaned_data['url']
            url.save()
            c = {
                "form": form,
                "url": url,
            }
            return render_to_response("main.html",
                                      c,
                                      context_instance=RequestContext(request))
        else:
            c = {
                "form": form,
            }
            return render_to_response("main.html",
                                      c,
                                      context_instance=RequestContext(request))
    else:
        form = UrlForm()
        c = {
            "form": form,
        }
        return render_to_response("main.html",
                                  c,
                                  context_instance=RequestContext(request))
Esempio n. 3
0
def index():
    #PPP: brings the form for the URL
    #PPP: trae el formulario correspondiente a la url.
    urlForm = UrlForm(request.form)

    if request.method == 'POST':
        if urlForm.validate():
            #PPP: extraction the content associated this url
            #PPP: se extrae la url contenida en el campo input del formulario
            url = urlForm.url.data
            status, data = core(url)
            if (status == 1):  #PPP: 1 = without errors and data have info
                aux = request.form
                results = callEvaluations(aux, data)
                #PPP: "pop" extract, removing from the list, the last element
                #PPP: "pop" extrae (lo elimina de la lista) el ultimo elemento
                tagsInContent = results.pop()['tagsInContent']
                percentFinalFailed = results.pop()['finalPercent']
                return render_template('result.html',
                                       percentFinalFailed=percentFinalFailed,
                                       tagsInContent=tagsInContent,
                                       results=results,
                                       url=url)
            else:
                return render_template('error.html')
    else:
        return render_template('index.html',
                               form=urlForm,
                               option_list=activeServices())
Esempio n. 4
0
def save_url(request):
    form = UrlForm(request.POST)
    if form.is_valid():
        long_u = request.POST.get('long_url').strip().strip('/')
        short_url = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(6))
        while Urls.objects.filter(short_url=short_url):
            short_url = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(6))

        used_protocol = 'http://'
        protocols = ['http://', 'https://', 'ftp://']
        for p in protocols:
            if p in long_u:
                used_protocol = p
                long_u = long_u.replace(used_protocol, '')

        Urls.objects.create(protocol=used_protocol,
                        long_url = long_u,
                        create_date=time.strftime("%Y %b %d"),
                        short_url=short_url)

        return redirect(index)

    else:
        context = {'urls_data': Urls.objects.filter().order_by('-id'),
                   'server_url': '127.0.0.1:8000?s=',
                   'message': 'Oops, Your URL is not valid. Please, try again...'}
        return render(request, 'index.html', context)
Esempio n. 5
0
 def home():
     form = UrlForm()
     if form.validate_on_submit():
         boolIsExist = checkIfExistInDatabase(form['urlFromUser'].data)
         if boolIsExist is False:
             shortUrl = randomStringDigits(5)
             create_SUrl(shortUrl, form['urlFromUser'].data)
             flash('You are enter a good URL: ' + form['urlFromUser'].data)
             session['shortUrl'] = shortUrl
             return redirect(url_for('shortener'))
         else:
             shortUrl = getShortUrlFromDatabase(form['urlFromUser'].data)
             session['shortUrl'] = shortUrl
             return redirect(url_for('shortener'))
     return render_template('home.html', title='home', form=form)
Esempio n. 6
0
def photocraig(request):
    if request.method == 'POST':
        form = UrlForm(request.POST)
        if form.is_valid():
            try:
                if not("craigslist.org" in str(request.POST['url'])):
                    return HttpResonse("Bad url")
                response = craigslist.parseListings(request.POST['url'])
                form = UrlForm()
                print 'NEXT: ' + str(response['next'])
                return render_to_response('janklist.html', {'form': form, 'listings': response['listings'], 'next': response['next']},  context_instance=RequestContext(request))
            except Exception, e:
                print e
                return HttpResponse("Bad url")
        else:
            return HttpResponse("Bad form data")
Esempio n. 7
0
def home(request):
    #Home page

    context = {}
    if not check_words_load():
        context['msg'] = 'First, load the words.'
    if request.method == 'POST' and check_words_load():
        form = UrlForm(request.POST)
        if form.is_valid():
            short_url = generate_url(form.cleaned_data['url'])
            context['short_url'] = short_url
            context['result'] = True
    else:
        form = UrlForm()
    context['form'] = form
    return render(request, 'home.html', context)
Esempio n. 8
0
    def post(self, request, *args, **kwargs):
        data = {
            "start_url": request.POST.get('start_url'),
            "end_url": request.POST.get('end_url')
        }
        f = UrlForm(data)

        if f.is_valid():
            f.send_maze_doors(data)
            return HttpResponseRedirect(self.success_url)

        errors = {
            'start_url': f.errors.get('start_url', ''),
            'end_url': f.errors.get('end_url', '')
        }

        return render(request, self.template_name, {"errors": errors})
Esempio n. 9
0
def add_url():
    form = UrlForm()
    if form.validate_on_submit():
        # create a unique slug
        while True:
            slug = uuid.uuid4().hex[:6]
            link = Link.query.filter_by(slug=slug).first()
            if not link:
                break

        # enter the data into database with count = 0
        link = Link(url=form.url.data, slug=slug, count=0)
        db.session.add(link)
        db.session.commit()
        
        return redirect(url_for('home'))
    return render_template('add_url.html', form=form)
Esempio n. 10
0
def index(request):
    if request.method == 'POST':  # обрабатываем POST запрос, т.е. добавления url
        raw_data = UrlForm(request.POST)
        if raw_data.is_valid():
            data = raw_data.cleaned_data

            timestamp = timezone.now()  # отметка времени
            original_url = data['original_url']  # получаем введенный в форму url
            url_add = UrlList.objects.create(original_url=original_url, date_add=timestamp, clicks=0)  # пишем в базу введенный url, время добавления и количество кликов, которые пока равны нулю

            request_url = request.get_raw_uri()  # получаем url запроса
            short_url = '{0}?s={1}'.format(request_url, encode(url_add.id))  # формируем короткий url из url запроса и закодированного id записи
            url_add.shorten_url = short_url  # добавляем короткий url в базу
            url_add.save()  # сохраняем

            return redirect(index)  # добавление url в базу окончена, перенаправляем на заглавную страницу

        # если введенный url прошел валидацию на форме html, но не прошел в обработке POST запроса, то выводим сообщение пользователю о некорректном url
        urls = UrlList.objects.filter()
        context = {'url_form': UrlForm(), 'urls': urls, 'message': 'You pasted a bad URL'}
        return render(request, 'form.html', context)
    else:  # обрабатываем GET запрос
        if request.GET.get('s'):  # если в GET запросе существет ключ s, значит пользователь нажал на короткий url - обрабатываем его
            s = request.GET.get('s')  # получаем закодированный id
            '''
            Если пользователь вручную введет GET запрос в адресной строке браузера с произвольным 's',
            то приложение может обратиться к базе с несуществующим id, что вызовет exception.
            Ловим такие обращения с помощью try-except и выводим соответствующее сообщение.
            '''
            try:
                url_id = decode(s)  # декодируем id
                url = UrlList.objects.get(id=url_id)  # получаем объект url из базы

                timestamp = timezone.now()  # отметка времени
                url.date_click = timestamp  # дата и время клика по короткому url
                url.clicks += 1  # увеличиваем счетчик кликов по короткому url
                url.save()  # сохраняем изменения в базу
            except Exception:  # ловим ошибки обращения к несуществующему id в базе
                request_url = request.get_raw_uri()  # получаем url запроса
                return HttpResponse('Page "{0}" does not exist.'.format(request_url))  # возвращаем пользователю сообщение, что такого url нет
            return redirect(url.original_url)  # выносим редирект на оригинальный url из try блока, т.к. в нем не считаются клики и timestamps
        else:  # если в GET запросе нет ключа s, значит пользователь заходит на заглавную страницу
            urls = UrlList.objects.filter()  # получаем все записи в базе
            context = {'url_form': UrlForm(), 'urls': urls}
            return render(request, 'form.html', context)  # рисуем пользователю заглавную страницу
Esempio n. 11
0
def index():
    form = UrlForm()
    if request.method == "POST":
        original_url = request.form['original_url']
        link = Link(original_url=original_url, user=current_user)
        db.session.add(link)
        db.session.commit()
        short = link.short_url
        flash(short, "success")
        return redirect(url_for('index'))
    return render_template('index.html', form=form)
Esempio n. 12
0
def main(request, **kwargs):
    if request.method == "POST":
        form = UrlForm(request.POST)
        if form.is_valid():
            url = Url()
            url.original_url = form.cleaned_data['url']
            url.save()
            c = {
                 "form": form,
                 "url": url,
                 }
            return render_to_response("main.html", c, context_instance=RequestContext(request))
        else:
            c = {
                 "form": form,
                 }
            return render_to_response("main.html", c, context_instance=RequestContext(request))
    else:
        form = UrlForm()
        c = {
                 "form": form,
                 }
        return render_to_response("main.html", c, context_instance=RequestContext(request))
Esempio n. 13
0
def shortener():

    form = UrlForm()
    bijective_obj = bijective.ShortURL()

    if form.validate_on_submit():
        change_key = "~ck" + str(
            bijective_obj.encode(randint(100000000, 99999999999)))

        if form.custom_alias.data == '':  #No custom alias given
            form.custom_alias.data = str(
                bijective_obj.encode(randint(100000000000, 999999999999)))

        if db_crud.add_url_record(form.custom_alias.data,
                                  f.validate_urls(form.long_url.data),
                                  change_key) == "inserted":
            flash('Great ! Go checkout ' + home_url + '/%s' %
                  (form.custom_alias.data))
            return render_template('form.html',
                                   form=form,
                                   home_url=home_url,
                                   custom_alias=form.custom_alias.data,
                                   link_to="http://" + home_url + "/" +
                                   form.custom_alias.data,
                                   short_url_creation=True,
                                   changekey=change_key)
        else:
            flash('Woops! The custom alias ' + home_url +
                  '/%s  is taken. Try a different one. ' %
                  (form.custom_alias.data))
            return render_template('form.html',
                                   form=form,
                                   home_url=home_url,
                                   link_to="http://" + home_url + "/shorten",
                                   short_url_creation=False)

    return render_template('form.html', form=form, home_url=home_url)
Esempio n. 14
0
def home(request):
  form = UrlForm()
  if request.method=="POST": 
    form = UrlForm(request.POST)
    if form.is_valid():
      if form.is_valid():
        url = form.cleaned_data['original_url']
        url_set = UrlTable.objects.filter(original_url = url)
        if not url_set:
        	short_url=str(random_string(5))
        	p = UrlTable(original_url = url,shortened_url = short_url)
        	p.save()
  
  url_set = UrlTable.objects.all()
  return render(request,'url.html',{ 'form': form , 'urlset': url_set } )