def details(http_request, url):
"""
Show details for a selected website.
"""
page = 1
if url.isdigit():
website = get_object_or_404(Website, id=int(url))
if 'page' in http_request.GET:
page = int(http_request.GET['page'])
else:
if http_request.META['QUERY_STRING']:
url += '?' + http_request.META['QUERY_STRING']
url = normalize_url(url) # Replace ' ' with '%20' etc.
try:
website = Website.objects.get(url=url)
except Website.DoesNotExist:
return unknown_url(http_request, url)
# Use caching to reduce number of SQL queries
domain = website.domain
browsers = Browser.objects.all()
preload_foreign_keys(browsers, browser_group=True)
factories = Factory.objects.all()
preload_foreign_keys(factories, operating_system=True)
request_groups = list(website.requestgroup_set.all())
paginator = Paginator(request_groups, 5, orphans=2)
if page < 1 or page > paginator.num_pages:
raise Http404('Requested page out of range.')
request_group_list = paginator.page(page).object_list
pages_list = []
if paginator.num_pages > 1:
for number in range(1, paginator.num_pages + 1):
extra_classes = ''
if page == number:
extra_classes = ' current'
pages_list.append(
u'<a class="page%s" href="%s?page=%d">%d</a>' % (
extra_classes, website.get_numeric_url(), number, number))
user_has_priority = False
if 'shotserver04.priority' in settings.INSTALLED_APPS:
if not http_request.user.is_anonymous():
user_has_priority = http_request.user.userpriority_set.filter(
expire__gte=datetime.now()).count()
if not user_has_priority:
website_details_head_extra = """
<p class="admonition new">
<a href="/priority/">Support the Browsershots project!<br />
Get a month of priority processing for 10 Euros or 15 Dollars.</a>
</p>
""".strip()
for index, request_group in enumerate(request_groups):
request_group._http_request = http_request
request_group._index = len(request_groups) - index
request_group._browsers_cache = browsers
request_group._factories_cache = factories
request_group._website_cache = website
request_group._website_cache._domain_cache = domain
# Get other websites on the same domain
domain_website_list = domain.website_set.exclude(id=website.id)
return render_to_response('websites/details.html', locals(),
context_instance=RequestContext(http_request))
def details(http_request, url):
"""
Show details for a selected website.
"""
page = 1
if url.isdigit():
website = get_object_or_404(Website, id=int(url))
if 'page' in http_request.GET:
page = int(http_request.GET['page'])
else:
if http_request.META['QUERY_STRING']:
url += '?' + http_request.META['QUERY_STRING']
url = normalize_url(url) # Replace ' ' with '%20' etc.
try:
website = Website.objects.get(url=url)
except Website.DoesNotExist:
return unknown_url(http_request, url)
# Use caching to reduce number of SQL queries
domain = website.domain
browsers = Browser.objects.all()
preload_foreign_keys(browsers, browser_group=True)
factories = Factory.objects.all()
preload_foreign_keys(factories, operating_system=True)
request_groups = list(website.requestgroup_set.all())
paginator = Paginator(request_groups, 5, orphans=2)
if page < 1 or page > paginator.num_pages:
raise Http404('Requested page out of range.')
request_group_list = paginator.page(page).object_list
pages_list = []
if paginator.num_pages > 1:
for number in range(1, paginator.num_pages + 1):
extra_classes = ''
if page == number:
extra_classes = ' current'
pages_list.append(
u'<a class="page%s" href="%s?page=%d">%d</a>' % (
extra_classes, website.get_numeric_url(), number, number))
user_has_priority = False
if 'shotserver04.priority' in settings.INSTALLED_APPS:
if not http_request.user.is_anonymous():
user_has_priority = http_request.user.userpriority_set.filter(
expire__gte=datetime.now()).count()
if not user_has_priority:
website_details_head_extra = """
<p class="admonition new">
<a href="/priority/">Support the Browsershots project!<br />
Get a month of priority processing for 10 Euros or 15 Dollars.</a>
</p>
""".strip()
for index, request_group in enumerate(request_groups):
request_group._http_request = http_request
request_group._index = len(request_groups) - index
request_group._browsers_cache = browsers
request_group._factories_cache = factories
request_group._website_cache = website
request_group._website_cache._domain_cache = domain
# Get other websites on the same domain
domain_website_list = domain.website_set.exclude(id=website.id)
return render_to_response('websites/details.html', locals(),
context_instance=RequestContext(http_request))
def clean_url(self):
"""
Clean URL and attempt HTTP GET request.
"""
self.cleaned_data['url'] = normalize_url(self.cleaned_data['url'])
self.add_scheme()
self.split_url()
self.punycode_url()
self.check_server_disallowed()
self.add_slash()
self.robots_txt()
response = self.http_get()
self.cleaned_data['headers'] = response[0]
self.cleaned_data['content'] = response[1]
self.check_content_type()
self.check_content()
self.cleaned_data['domain'] = self.get_or_create_domain()
self.cleaned_data['website'] = self.get_or_create_website()
return self.cleaned_data['url']
def submit(http_request, username, encrypted_password, url, browsers):
"""
Submit a new group of screenshot requests.
Arguments
~~~~~~~~~
* username string (your user account on the server)
* encrypted_password string (lowercase hexadecimal, length 32)
* url string (request screenshots of this website)
* browsers list (platform, name and version for each browser)
Return value
~~~~~~~~~~~~
* id int (request group id)
You can use the returned request group id to check the progress of
the screenshot requests with requests.status.
"""
# Get user from database
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Fault(404, "User not found.")
# Verify authentication
nonces.verifyUser(http_request, user, encrypted_password)
# Check priority
priority = 0
if 'shotserver04.priority' in settings.INSTALLED_APPS:
from shotserver04.priority import user_priority
priority = user_priority(user)
if priority < 1:
raise Fault(402, "Priority processing is required.")
# Create domain and website if needed
url = normalize_url(url)
domain_name = extract_domain(url, remove_www=True)
domain = Domain.objects.get_or_create(name=domain_name)[0]
website = Website.objects.get_or_create(domain=domain, url=url)[0]
# Create request group
expire = datetime.now() + timedelta(minutes=30)
ip = http_request.META['REMOTE_ADDR']
request_group = RequestGroup.objects.create(website=website,
user=user,
ip=ip,
expire=expire,
priority=priority)
# Create browser requests
platforms = Platform.objects.all()
browser_groups = BrowserGroup.objects.all()
for name in browsers:
parts = name.split('_')
if len(parts) != 4:
continue
platform_name, browser_name, major, minor = parts
platform_name = platform_name.replace('-', ' ')
platform = find_by_name(platforms, platform_name)
if platform is None:
continue
browser_group = find_by_name(browser_groups, browser_name)
if browser_group is None:
continue
Request.objects.get_or_create(
request_group=request_group,
platform=platform,
browser_group=browser_group,
major=int_or_none(major),
minor=int_or_none(minor),
priority=priority,
)
return request_group.id
def submit(http_request, username, encrypted_password, url, browsers):
"""
Submit a new group of screenshot requests.
Arguments
~~~~~~~~~
* username string (your user account on the server)
* encrypted_password string (lowercase hexadecimal, length 32)
* url string (request screenshots of this website)
* browsers list (platform, name and version for each browser)
Return value
~~~~~~~~~~~~
* id int (request group id)
You can use the returned request group id to check the progress of
the screenshot requests with requests.status.
"""
# Get user from database
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Fault(404, "User not found.")
# Verify authentication
nonces.verifyUser(http_request, user, encrypted_password)
# Check priority
priority = 0
if 'shotserver04.priority' in settings.INSTALLED_APPS:
from shotserver04.priority import user_priority
priority = user_priority(user)
if priority < 1:
raise Fault(402, "Priority processing is required.")
# Create domain and website if needed
url = normalize_url(url)
domain_name = extract_domain(url, remove_www=True)
domain = Domain.objects.get_or_create(name=domain_name)[0]
website = Website.objects.get_or_create(domain=domain, url=url)[0]
# Create request group
expire = datetime.now() + timedelta(minutes=30)
ip = http_request.META['REMOTE_ADDR']
request_group = RequestGroup.objects.create(
website=website, user=user, ip=ip,
expire=expire, priority=priority)
# Create browser requests
platforms = Platform.objects.all()
browser_groups = BrowserGroup.objects.all()
for name in browsers:
parts = name.split('_')
if len(parts) != 4:
continue
platform_name, browser_name, major, minor = parts
platform_name = platform_name.replace('-', ' ')
platform = find_by_name(platforms, platform_name)
if platform is None:
continue
browser_group = find_by_name(browser_groups, browser_name)
if browser_group is None:
continue
Request.objects.get_or_create(
request_group=request_group,
platform=platform,
browser_group=browser_group,
major=int_or_none(major),
minor=int_or_none(minor),
priority=priority,
)
return request_group.id
