def display(request, id):
actual_id = int(id) - 1
client = MatrixClient(SERVER_HOST, SERVER_PORT)
try:
config = client.get_config(displays=(actual_id, ))[str(actual_id)]
message = client.get_message(displays=(actual_id, ))[str(actual_id)]
except (ConnectionRefusedError, socket.timeout):
return ExtendedTemplateResponse(request, "displays/unavailable.html",
NAV_DATA)
settings_form = DisplaySettingsForm(initial=config)
text_message_form = TextMessageForm()
if not message:
message_list = []
else:
if message['type'] == 'sequence':
message_list = message['data']
for index, message in enumerate(message_list):
# Move the duration field down one level
message_list[index]['data']['duration'] = message.pop(
'duration', None)
else:
message_list = [message]
_message_list = []
for message in message_list:
if message['type'] == 'text':
name = message['data']['text']
elif message['type'] == 'bitmap':
name = "Bitmap name placeholder"
_message_list.append({'name': name, 'json': json.dumps(message)})
return ExtendedTemplateResponse(
request,
"displays/display.html",
NAV_DATA, {
'message_list': enumerate(_message_list),
'settings_form': settings_form,
'text_message_form': text_message_form,
'display_id': id
},
page_title=_("Display %s") % id,
active_view_include_params=True)
def search(request):
data = {}
if request.method == "POST":
query = request.POST.get('query').strip()
if query:
data['query'] = query
data['results'] = Item.objects.filter(
Q(name__icontains=query)
| Q(details__icontains=query)).order_by('name')
return ExtendedTemplateResponse(request,
"storeman/search.html",
NAV_DATA,
data,
page_title=_("Search"))
def location_detail(request, id, slug):
location = get_object_or_404(Location, pk=id)
qs = Item.objects.filter(location=location).order_by('name')
return ExtendedTemplateResponse(
request,
"storeman/location_detail.html",
NAV_DATA, {'location': location},
page_title=_("Location: %s") % str(location),
sidebar_title=_("Items in %s") % location.name,
sidebar_queryset=qs,
qs_display_name_func=lambda item: _("%(amount)i× %(name)s") % {
'amount': item.amount,
'name': item.name
})
def locations_paged(request, page=1):
qs = Location.objects.all().order_by('-id')
paginator = Paginator(qs, per_page=10, orphans=3)
try:
locations = paginator.page(page)
except PageNotAnInteger:
locations = paginator.page(1)
except EmptyPage:
locations = paginator.page(paginator.num_pages)
return ExtendedTemplateResponse(request,
"storeman/locations_paged.html",
NAV_DATA, {'locations': locations},
page_title=_("All Locations"))
def items_paged(request, page=1):
qs = Item.objects.all().order_by('-id')
paginator = Paginator(qs, per_page=10, orphans=3)
try:
items = paginator.page(page)
except PageNotAnInteger:
items = paginator.page(1)
except EmptyPage:
items = paginator.page(paginator.num_pages)
return ExtendedTemplateResponse(request,
"storeman/items_paged.html",
NAV_DATA, {'items': items},
page_title=_("All Items"))
def index(request):
client = MatrixClient(SERVER_HOST, SERVER_PORT)
try:
config = client.get_config(keys=('power_state', 'stop_indicator'))
messages = client.get_message()
except (ConnectionRefusedError, socket.timeout):
return ExtendedTemplateResponse(request, "displays/unavailable.html",
NAV_DATA)
data = {0: {}, 1: {}, 2: {}, 3: {}}
for i in range(4):
data[i]['config'] = config[str(i)]
message = messages[str(i)]
if message is None:
data[i]['message'] = ""
elif message['type'] == 'sequence':
data[i]['message'] = "\n".join(
[msg['data']['text'] for msg in message['data']])
else:
data[i]['message'] = message['data']['text']
return ExtendedTemplateResponse(request, "displays/index.html", NAV_DATA,
{'overview': data})
def item_detail(request, id, slug):
item = get_object_or_404(Item, pk=id)
qs = Item.objects.filter(location=item.location).exclude(
id=item.id).order_by('name')
return ExtendedTemplateResponse(
request,
"storeman/item_detail.html",
NAV_DATA, {'item': item},
page_title=_("Item: %s") % str(item),
sidebar_title=_("Other Items in %s") % item.location.name,
sidebar_queryset=qs,
qs_display_name_func=lambda item: _("%(amount)i× %(name)s") % {
'amount': item.amount,
'name': item.name
})
def text_converters(request):
def _convert_text(text, charmap, separator=""):
text = text.strip()
result_chars = [charmap.get(char, char) for char in text]
result = multiline_join(result_chars, separator)
return result
def _mess_up(text, amount=1.0):
MODIFIERS = (
# Going up
'\u030d',
'\u030e',
'\u0304',
'\u0305',
'\u033f',
'\u0311',
'\u0306',
'\u0310',
'\u0352',
'\u0357',
'\u0351',
'\u0307',
'\u0308',
'\u030a',
'\u0342',
'\u0343',
'\u0344',
'\u034a',
'\u034b',
'\u034c',
'\u0303',
'\u0302',
'\u030c',
'\u0350',
'\u0300',
'\u0301',
'\u030b',
'\u030f',
'\u0312',
'\u0313',
'\u0314',
'\u033d',
'\u0309',
'\u0363',
'\u0364',
'\u0365',
'\u0366',
'\u0367',
'\u0368',
'\u0369',
'\u036a',
'\u036b',
'\u036c',
'\u036d',
'\u036e',
'\u036f',
'\u033e',
'\u035b',
'\u0346',
'\u031a',
# Going down
'\u0316',
'\u0317',
'\u0318',
'\u0319',
'\u031c',
'\u031d',
'\u031e',
'\u031f',
'\u0320',
'\u0324',
'\u0325',
'\u0326',
'\u0329',
'\u032a',
'\u032b',
'\u032c',
'\u032d',
'\u032e',
'\u032f',
'\u0330',
'\u0331',
'\u0332',
'\u0333',
'\u0339',
'\u033a',
'\u033b',
'\u033c',
'\u0345',
'\u0347',
'\u0348',
'\u0349',
'\u034d',
'\u034e',
'\u0353',
'\u0354',
'\u0355',
'\u0356',
'\u0359',
'\u035a',
'\u0323',
# Staying in the middle
'\u0315',
'\u031b',
'\u0340',
'\u0341',
'\u0358',
'\u0321',
'\u0322',
'\u0327',
'\u0328',
'\u0334',
'\u0335',
'\u0336',
'\u034f',
'\u035c',
'\u035d',
'\u035e',
'\u035f',
'\u0360',
'\u0362',
'\u0338',
'\u0337',
'\u0361',
'\u0489',
)
if amount >= 1.0:
result = "".join([
char +
"".join([random.choice(MODIFIERS) for i in range(int(amount))])
for char in text
])
else:
result = "".join([
text[x] + random.choice(MODIFIERS)
if divmod(x, (1 / amount))[1] == 0.0 else text[x]
for x in range(len(text))
])
return result
template_vars = {}
if request.method == "POST" and 'text' in request.POST and 'type' in request.POST:
t = request.POST.get('type')
text = request.POST.get('text')
template_vars['text'] = text
if t == 'big':
result = _convert_text(text.upper(), CHARMAP_BIG, separator=" ")
elif t == 'flip':
result = _convert_text(text[::-1], CHARMAP_FLIP)
elif t == 'elegant':
result = _convert_text(text, CHARMAP_ELEGANT)
elif t == 'elegant-bold':
result = _convert_text(text, CHARMAP_ELEGANT_BOLD)
elif t == 'gothic':
result = _convert_text(text, CHARMAP_GOTHIC)
elif t == 'gothic-bold':
result = _convert_text(text, CHARMAP_GOTHIC_BOLD)
elif t == 'sans':
result = _convert_text(text, CHARMAP_SANS)
elif t == 'sans-bold':
result = _convert_text(text, CHARMAP_SANS_BOLD)
elif t == 'sans-italic':
result = _convert_text(text, CHARMAP_SANS_ITALIC)
elif t == 'sans-italic-bold':
result = _convert_text(text, CHARMAP_SANS_ITALIC_BOLD)
elif t == 'mono':
result = _convert_text(text, CHARMAP_MONO)
elif t == 'serif-bold':
result = _convert_text(text, CHARMAP_SERIF_BOLD)
elif t == 'serif-italic':
result = _convert_text(text, CHARMAP_SERIF_ITALIC)
elif t == 'serif-italic-bold':
result = _convert_text(text, CHARMAP_SERIF_ITALIC_BOLD)
elif t == 'doublestruck':
result = _convert_text(text, CHARMAP_DOUBLESTRUCK)
elif t == 'fullwidth':
result = _convert_text(text, CHARMAP_FULLWIDTH)
elif t == 'messed-up-low':
result = _mess_up(text, amount=1.0)
elif t == 'messed-up-medium':
result = _mess_up(text, amount=5.0)
elif t == 'messed-up-high':
result = _mess_up(text, amount=10.0)
elif t == 'messed-up-insane':
result = _mess_up(text, amount=100.0)
elif t == 'strikethrough-horizontal':
result = "".join(["\u0336" + c for c in text])
elif t == 'strikethrough-diagonal':
result = "".join(["\u0338" + c for c in text])
template_vars['result'] = result
return ExtendedTemplateResponse(request,
"funtools/text_converters.html",
NAV_DATA,
template_vars,
page_title=_("Text Converters"))
def index(request):
return ExtendedTemplateResponse(request,
"funtools/index.html",
NAV_DATA,
page_title=_("Index"))
def process_response(self, request, response):
if response.status_code != 404:
# Only look for static pages when no view could be found
return response
try:
try:
# First look for standalone pages only (no group members)
# Only get pages for the current site or universal pages (with no site specified)
potential_pages = StaticPage.objects.filter(
Q(group=None) & (Q(site=request.site) | Q(site=None)))
if not potential_pages: raise ValueError
# Filter out pages with no matching path
potential_pages = [
page for page in potential_pages
if re.match(page.path_regex, request.path)
]
if not potential_pages: raise ValueError
# Filter out pages with no matching subdomain
potential_pages = [
page for page in potential_pages
if re.match(page.subdomain_regex, request.subdomain or "")
]
if not potential_pages: raise ValueError
except ValueError:
# Look for groups for the current site or universal groups (with no site specified)
potential_groups = StaticPageGroup.objects.filter(
Q(site=request.site) | Q(site=None))
if not potential_groups: raise ValueError
# Filter out groups with no matching base path
potential_groups = [
group for group in potential_groups
if re.match(group.base_path_regex, request.path)
]
if not potential_groups: raise ValueError
# Filter out groups with no matching subdomain
potential_groups = [
group for group in potential_groups
if re.match(group.subdomain_regex, request.subdomain or "")
]
if not potential_groups: raise ValueError
# Get all pages in the potential groups
potential_pages = StaticPage.objects.filter(
group__in=potential_groups)
if not potential_pages: raise ValueError
# Get all pages with matching path
potential_pages = [
page for page in potential_pages
if re.search(page.path_regex, request.path)
]
if not potential_pages: raise ValueError
except ValueError:
# No page found, just return the original response
return response
# We have at least one potential page, now filter by language
lang_matching_pages = [
page for page in potential_pages
if page.lang == request.LANGUAGE_CODE
]
if not lang_matching_pages:
# No page found in the desired language, fall back to the default language
lang_matching_pages = [
page for page in potential_pages
if page.lang == settings.LANGUAGE_CODE
]
if not lang_matching_pages:
# Still no page found, so just use what's available
lang_matching_pages = potential_pages
# Now just take the highest ranked page out of the remaining candidates
page = sorted(lang_matching_pages, key=lambda p: p.rank,
reverse=True)[0]
# Okay, we have our page. Now serve it
if page.copy_of:
# We have a copied page
page = page.copy_of
if page.redirect_url:
# We have a redirect
if page.redirect_permanent:
return HttpResponsePermanentRedirect(page.redirect_url)
else:
return HttpResponseRedirect(page.redirect_url)
if not page.template:
# Return a bare HttpResponse
return HttpResponse(page.content, content_type=page.mimetype)
if page.parse:
page.content = Template(page.content).render(
RequestContext(request))
variables = yaml.load(page.variables) if page.variables else {}
variables.update({'page': page})
return ExtendedTemplateResponse(
request,
"staticpages/%s.html" % page.template,
nav_data=yaml.load(page.group.nav_data) if page.group else None,
context=variables,
page_title=page.page_title,
nav_data_resolve_views=False).render()