Example #1
0
def post(handler, response):
  edit = handler.get_edit(required=True)
  if not edit.can_edit():
    return handler.redirect(edit.permalink())
  # post params
  url = handler.request.get('url').strip()
  original = handler.request.get('original').strip()
  proposal = handler.request.get('proposal').strip()
  # copy params for error case
  response.url = url
  response.original = original
  response.proposal = proposal
  # parse url
  domain = urlparse(url).netloc
  if not domain:
    # fix URL by prefixing with default scheme
    url = "http://%s" % url
    domain = urlparse(url).netloc
  # error cases
  if not domain:
    handler.form_error(url="Invalid URL")
  if not original:
    handler.form_error(original="Original required")
  if not proposal:
    handler.form_error(proposal="Proposal required")
  # check that the site didn't change
  key_name = Site.key_name_from_domain(domain)
  if edit.site.key().name() != key_name:
    handler.form_error(url="Cannot change domain")
  # exit if errors occured
  if handler.has_errors():
    return
  # update the edit
  edit.url = url
  edit.original = original
  edit.proposal = proposal
  edit.put()
  # redirect
  handler.redirect(edit.permalink())
Example #2
0
 # check for valid response from URL
 try:
   response = fetch(url)
   if response.status_code != 200:
     handler.form_error(url="Unexpected response: %s" % response.status_code)
 except DownloadError:
   handler.form_error(url="Connection refused")
 except Exception, e:
   handler.form_error(url="Error, %s" % e);
 
 # exit if errors occured
 if handler.has_errors():
   return
 
 # get site
 key_name = Site.key_name_from_domain(domain)
 site = Site.get_or_insert(key_name, domain=domain)
 
 # check for an existing instance of this edit
 existing = Edit.all()\
   .ancestor(site)\
   .filter('original =', original)\
   .filter('proposal =', proposal)\
   .filter('url =', url)\
   .get()
 
 if existing:
   handler.redirect(existing.permalink())
   return
 
 def put_edit():
Example #3
0
 def test_domain_key(self):
     """foo.com and www.foo.com should map to foo.com"""
     prefix = "test_prefix"
     self.assertEquals(Site.key_name_from_domain("foo.com", prefix=prefix), "%s:foo.com" % prefix)
     self.assertEquals(Site.key_name_from_domain("www.foo.com", prefix=prefix), "%s:foo.com" % prefix)
Example #4
0
def get(handler, response):
    from_domain = handler.request.get("from")
    to_domain = handler.request.get("to")

    from_site, to_site = None, None

    if to_domain:
        to_key_name = Site.key_name_from_domain(to_domain)
        to_site = Site.get_by_key_name(to_key_name)

    if from_domain:
        from_key_name = Site.key_name_from_domain(from_domain)
        from_site = Site.get_by_key_name(from_key_name)

    # fetch sites
    if to_site:
        sites = (
            Site.all()
            .filter("open =", to_site.open)
            .filter("domain <=", to_site.domain)
            .order("-domain")
            .fetch(PAGE_SIZE + 2)
        )
        sites.reverse()
        if len(sites) < PAGE_SIZE + 2:
            pad = (
                Site.all()
                .filter("open >", to_site.open)
                .order("open")
                .order("-domain")
                .fetch(PAGE_SIZE + 2 - len(sites))
            )
            pad.reverse()
            sites = pad + sites
        if len(sites) > PAGE_SIZE + 1:
            response.sites = sites[1 : PAGE_SIZE + 1]
        else:
            response.sites = sites[:PAGE_SIZE]
    elif from_site:
        sites = (
            Site.all()
            .filter("open =", from_site.open)
            .filter("domain >=", from_site.domain)
            .order("domain")
            .fetch(PAGE_SIZE + 1)
        )
        if len(sites) < PAGE_SIZE + 1:
            sites += (
                Site.all()
                .filter("open <", from_site.open)
                .order("-open")
                .order("domain")
                .fetch(PAGE_SIZE + 1 - len(sites))
            )
        response.sites = sites[:PAGE_SIZE]
    else:
        sites = Site.all().order("-open").order("domain").fetch(PAGE_SIZE + 1)
        response.sites = sites[:PAGE_SIZE]

    # pagination
    if to_site:
        response.next.url = "%s?from=%s" % (handler.base_path(), to_site.domain)

        if len(sites) > PAGE_SIZE + 1:
            response.previous.url = "%s?to=%s" % (handler.base_path(), sites[1].domain)
    else:
        if from_site:
            response.previous.url = "%s?to=%s" % (handler.base_path(), from_site.domain)

        if len(sites) > PAGE_SIZE:
            response.next.url = "%s?from=%s" % (handler.base_path(), sites[PAGE_SIZE].domain)