def cleanup_email_addresses(request, addresses):
"""
Takes a list of EmailAddress instances and cleans it up, making
sure only valid ones remain, without multiple primaries etc.
Order is important: e.g. if multiple primary e-mail addresses
exist, the first one encountered will be kept as primary.
"""
from .models import EmailAddress
adapter = get_adapter()
# Let's group by `email`
e2a = SortedDict() # maps email to EmailAddress
primary_addresses = []
verified_addresses = []
primary_verified_addresses = []
for address in addresses:
# Pick up only valid ones...
email = valid_email_or_none(address.email)
if not email:
continue
# ... and non-conflicting ones...
if (app_settings.UNIQUE_EMAIL
and EmailAddress.objects
.filter(email__iexact=email)
.exists()):
continue
a = e2a.get(email.lower())
if a:
a.primary = a.primary or address.primary
a.verified = a.verified or address.verified
else:
a = address
a.verified = a.verified or adapter.is_email_verified(request,
a.email)
e2a[email.lower()] = a
if a.primary:
primary_addresses.append(a)
if a.verified:
primary_verified_addresses.append(a)
if a.verified:
verified_addresses.append(a)
# Now that we got things sorted out, let's assign a primary
if primary_verified_addresses:
primary_address = primary_verified_addresses[0]
elif verified_addresses:
# Pick any verified as primary
primary_address = verified_addresses[0]
elif primary_addresses:
# Okay, let's pick primary then, even if unverified
primary_address = primary_addresses[0]
elif e2a:
# Pick the first
primary_address = e2a.keys()[0]
else:
# Empty
primary_address = None
# There can only be one primary
for a in e2a.values():
a.primary = primary_address.email.lower() == a.email.lower()
return list(e2a.values()), primary_address
class Servers(object):
def __init__(self):
self.servers = SortedDict()
fp = open(settings.CONFIG_FILE)
index = 0
for line in fp:
sid = str(index)
server = Server(line.strip(), sid=sid)
self.servers[sid] = server
index += 1
fp.close()
def refresh(self):
for s in self.servers.values():
s.refresh()
def stop(self, name):
for s in self.servers.values():
s.stop(name)
def start(self, name):
for s in self.servers.values():
s.start(name)
def restart(self, name):
for s in self.servers.values():
s.restart(name)
def start_all(self):
for s in self.servers.values():
s.start_all()
class Servers(object):
def __init__(self):
self.servers = SortedDict()
fp = open(settings.CONFIG_FILE)
index = 0
for line in fp:
sid = str(index)
server = Server(line.strip(), sid=sid)
self.servers[sid] = server
index += 1
fp.close()
def refresh(self):
for s in self.servers.values():
s.refresh()
def stop(self, name):
for s in self.servers.values():
s.stop(name)
def start(self, name):
for s in self.servers.values():
s.start(name)
def restart(self, name):
for s in self.servers.values():
s.restart(name)
def start_all(self):
for s in self.servers.values():
s.start_all()
def cleanup_email_addresses(request, addresses):
"""
Takes a list of EmailAddress instances and cleans it up, making
sure only valid ones remain, without multiple primaries etc.
Order is important: e.g. if multiple primary e-mail addresses
exist, the first one encountered will be kept as primary.
"""
from .models import EmailAddress
adapter = get_adapter()
# Let's group by `email`
e2a = SortedDict() # maps email to EmailAddress
primary_addresses = []
verified_addresses = []
primary_verified_addresses = []
for address in addresses:
# Pick up only valid ones...
email = valid_email_or_none(address.email)
if not email:
continue
# ... and non-conflicting ones...
if (app_settings.UNIQUE_EMAIL
and EmailAddress.objects
.filter(email__iexact=email)
.exists()):
continue
a = e2a.get(email.lower())
if a:
a.primary = a.primary or address.primary
a.verified = a.verified or address.verified
else:
a = address
a.verified = a.verified or adapter.is_email_verified(request,
a.email)
e2a[email.lower()] = a
if a.primary:
primary_addresses.append(a)
if a.verified:
primary_verified_addresses.append(a)
if a.verified:
verified_addresses.append(a)
# Now that we got things sorted out, let's assign a primary
if primary_verified_addresses:
primary_address = primary_verified_addresses[0]
elif verified_addresses:
# Pick any verified as primary
primary_address = verified_addresses[0]
elif primary_addresses:
# Okay, let's pick primary then, even if unverified
primary_address = primary_addresses[0]
elif e2a:
# Pick the first
primary_address = e2a.keys()[0]
else:
# Empty
primary_address = None
# There can only be one primary
for a in e2a.values():
a.primary = primary_address.email.lower() == a.email.lower()
return list(e2a.values()), primary_address
def get_nav_menu(self):
nav_menu = self.get_site_menu()
if nav_menu:
return nav_menu
nav_menu = SortedDict()
for model, model_admin in self.admin_site._registry.items():
app_label = model._meta.app_label
model_dict = {
'title': unicode(capfirst(model._meta.verbose_name_plural)),
'url': self.get_model_url(model, "changelist"),
'perm': self.get_model_perm(model, 'change')
}
app_key = "app:%s" % app_label
if app_key in nav_menu:
nav_menu[app_key]['menus'].append(model_dict)
else:
nav_menu[app_key] = {
'title': unicode(app_label.title()),
'menus': [model_dict],
}
for menu in nav_menu.values():
menu['menus'].sort(key=lambda x: x['title'])
nav_menu = nav_menu.values()
nav_menu.sort(key=lambda x: x['title'])
return nav_menu
class ChoicesNumEnum(AbstractChoicesEnum, AbstractEnum):
def __init__(self, *items):
self.container = SortedDict()
super(ChoicesNumEnum, self).__init__()
i = 0
for item in items:
if len(item) == 3:
key, val, i = item
if not isinstance(i, int):
raise ValueError('Last value of item must by integer')
elif len(item) == 2:
key, val = item
i += 1
else:
raise ValueError('Wrong input data format')
if i in (j for j, _ in self.container.values()):
raise ValueError('Index %s already exists, please renumber choices')
self.container[key] = (i, val)
def _get_attr_val(self, name):
return self.container[name][0]
def _get_choices(self):
return self.container.values()
def model_factory(model, *args, **kwargs):
''' Simple object fabric for tests '''
save = kwargs.pop('save', False)
num = kwargs.pop('num', 1)
kwargs = SortedDict(kwargs)
if kwargs and not isinstance(kwargs.values()[0], list):
for key in kwargs:
kwargs[key] = [kwargs[key]]
def _create_model_obj(**_kwargs):
''' Create or build object '''
if save:
return model.objects.create(*args, **_kwargs)
return model(*args, **_kwargs)
models = DebugList(fields=kwargs.keys())
if kwargs:
model_kwargs = map(lambda value: dict(zip(kwargs.keys(), value)),
zip(*kwargs.values()))
for model_kw in model_kwargs * num:
models.append(_create_model_obj(**model_kw))
elif num:
for counter in range(num):
models.append(_create_model_obj())
else:
models.append(_create_model_obj())
if len(models) == 1:
return models[0]
return models
class ZipCodeFilterSpec(FilterSpec):
def __init__(self, request, params, model, model_admin):
super(ZipCodeFilterSpec, self).__init__(request, params, model, model_admin)
self.links = SortedDict((("Any", "zip_any"), ("90***", "zip_90"), ("75***", "zip_75")))
def consumed_params(self):
return self.links.values()
def choices(self, cl):
selected = [v for v in self.links.values() if self.params.has_key(v)]
for title, key in self.links.items():
yield {
"selected": (self.params.has_key(key) or (key == "zip_any" and selected == [])),
"query_string": cl.get_query_string({key: 1}, selected),
"display": title,
}
def get_query_set(self, cl, qs):
if self.params.has_key("zip_90"):
return qs.filter(locations__zip_code__startswith="90").distinct()
if self.params.has_key("zip_75"):
return qs.filter(locations__zip_code__startswith="75").distinct()
return qs
def title(self):
return u"Zip code"
class CompanyOpenFilterSpec(FilterSpec):
def __init__(self, request, params, model, model_admin):
super(CompanyOpenFilterSpec, self).__init__(request, params, model, model_admin)
self.links = SortedDict((("Any", "open_any"), ("Weekdays", "open_weedays"), ("Weekends", "open_weekends")))
def consumed_params(self):
return self.links.values()
def choices(self, cl):
selected = [v for v in self.links.values() if self.params.has_key(v)]
for title, key in self.links.items():
yield {
"selected": (self.params.has_key(key) or (key == "open_any" and selected == [])),
"query_string": cl.get_query_string({key: 1}, selected),
"display": title,
}
def get_query_set(self, cl, qs):
if self.params.has_key("open_weedays"):
return qs.filter(locations__open_days__contains="12345").distinct()
if self.params.has_key("open_weekends"):
return qs.filter(locations__open_days__contains="67").distinct()
return qs
def title(self):
return u"Locations open?"
def get_nav_menu(self):
site_menu = list(self.get_site_menu() or [])
had_urls = []
def get_url(menu, had_urls):
if 'url' in menu:
had_urls.append(menu['url'])
if 'menus' in menu:
for m in menu['menus']:
get_url(m, had_urls)
get_url({'menus': site_menu}, had_urls)
nav_menu = SortedDict()
for model, model_admin in self.admin_site._registry.items():
if getattr(model_admin, 'hidden_menu', False):
continue
app_label = model._meta.app_label
model_dict = {
'title': unicode(capfirst(model._meta.verbose_name_plural)),
'url': self.get_model_url(model, "changelist"),
'icon': self.get_model_icon(model),
'perm': self.get_model_perm(model, 'view'),
'order': model_admin.order,
}
if model_dict['url'] in had_urls:
continue
app_key = "app:%s" % app_label
if app_key in nav_menu:
nav_menu[app_key]['menus'].append(model_dict)
else:
nav_menu[app_key] = {
'title':
self.apps_label_title.get(app_label.lower(),
unicode(app_label.title())),
'menus': [model_dict],
}
app_menu = nav_menu[app_key]
if ('first_icon' not in app_menu or app_menu['first_icon']
== self.default_model_icon) and model_dict.get('icon'):
app_menu['first_icon'] = model_dict['icon']
if 'first_url' not in app_menu and model_dict.get('url'):
app_menu['first_url'] = model_dict['url']
for menu in nav_menu.values():
menu['menus'].sort(key=sortkeypicker(['order', 'title']))
nav_menu = nav_menu.values()
nav_menu.sort(key=lambda x: x['title'])
site_menu.extend(nav_menu)
return site_menu
def get_nav_menu(self):
site_menu = list(self.get_site_menu() or [])
had_urls = []
def get_url(menu, had_urls):
if 'url' in menu:
had_urls.append(menu['url'])
if 'menus' in menu:
for m in menu['menus']:
get_url(m, had_urls)
get_url({'menus': site_menu}, had_urls)
nav_menu = SortedDict()
for model, model_admin in self.admin_site._registry.items():
if getattr(model_admin, 'hidden_menu', False):
continue
app_label = model._meta.app_label
model_dict = {
'title': unicode(capfirst(model._meta.verbose_name_plural)),
'url': self.get_model_url(model, "changelist"),
'icon': self.get_model_icon(model),
'perm': self.get_model_perm(model, 'view'),
'order': model_admin.order,
}
if model_dict['url'] in had_urls:
continue
app_key = "app:%s" % app_label
if app_key in nav_menu:
nav_menu[app_key]['menus'].append(model_dict)
else:
nav_menu[app_key] = {
'title': self.apps_label_title.get(app_label.lower(), unicode(app_label.title())),
'menus': [model_dict],
}
app_menu = nav_menu[app_key]
if ('first_icon' not in app_menu or
app_menu['first_icon'] == self.default_model_icon) and model_dict.get('icon'):
app_menu['first_icon'] = model_dict['icon']
if 'first_url' not in app_menu and model_dict.get('url'):
app_menu['first_url'] = model_dict['url']
for menu in nav_menu.values():
menu['menus'].sort(key=sortkeypicker(['order', 'title']))
nav_menu = nav_menu.values()
nav_menu.sort(key=lambda x: x['title'])
site_menu.extend(nav_menu)
return site_menu
class PhotosBag(object):
def __init__(self, min_photos, max_photos, collectors=None):
self._photos = SortedDict()
self.min = min_photos
self.max = max_photos
self.collectors = collectors or []
def add_collector(self, collector):
"""A collector is a callable return an iterator of photos.
When the PhotosBag calls the collector it passes two arguments:
- the destination object
- the number of photos that can be added at this point
"""
self.collectors.append(collector)
def get_photos(self):
size = len(self._photos)
if size < self.min:
photos = []
elif size > self.max:
photos = self._photos.values()[:self.max]
else:
photos = self._photos.values()
return photos
def collect_photos(self, *args, **kwargs):
def photos_fetcher(max_photos):
n_photos_collected = 0
for collector in self.collectors:
n_photos_remaining = max_photos - n_photos_collected
for photo_info in collector(n_photos_remaining, *args, **kwargs):
photo_key = photo_info['photo_url']
if photo_key in self._photos:
continue
yield photo_key, photo_info
n_photos_collected += 1
if n_photos_collected > max_photos:
return
for photo_key, photo_info in photos_fetcher(self.max):
self._photos[photo_key] = photo_info
return self.get_photos()
class PhotosBag(object):
def __init__(self, min_photos, max_photos, collectors=None):
self._photos = SortedDict()
self.min = min_photos
self.max = max_photos
self.collectors = collectors or []
def add_collector(self, collector):
"""A collector is a callable return an iterator of photos.
When the PhotosBag calls the collector it passes two arguments:
- the destination object
- the number of photos that can be added at this point
"""
self.collectors.append(collector)
def get_photos(self):
size = len(self._photos)
if size < self.min:
photos = []
elif size > self.max:
photos = self._photos.values()[:self.max]
else:
photos = self._photos.values()
return photos
def collect_photos(self, *args, **kwargs):
def photos_fetcher(max_photos):
n_photos_collected = 0
for collector in self.collectors:
n_photos_remaining = max_photos - n_photos_collected
for photo_info in collector(n_photos_remaining, *args,
**kwargs):
photo_key = photo_info['photo_url']
if photo_key in self._photos:
continue
yield photo_key, photo_info
n_photos_collected += 1
if n_photos_collected > max_photos:
return
for photo_key, photo_info in photos_fetcher(self.max):
self._photos[photo_key] = photo_info
return self.get_photos()
def __new__(cls, name, bases, attrs):
super_new = super(PistonViewMetaclass, cls).__new__
parents = [b for b in bases if isinstance(b, PistonViewMetaclass)]
if not parents:
# If this isn't a subclass of PistonViewMetaclass, don't do anything special.
return super_new(cls, name, bases, attrs)
base_fields = SortedDict()
for parent_cls in parents:
for field in getattr(parent_cls, 'base_fields', []):
# if the superclass has defined a field, don't add
# that field from the base class since inspect.getmro
# lists classes in order from super to base
if field.destination not in base_fields:
base_fields[field.destination] = field
for field in attrs.get('fields', []):
if isinstance(field, basestring):
field = Field(field)
base_fields[field.destination] = field
attrs['base_fields'] = base_fields.values()
new_class = super_new(cls, name, bases, attrs)
return new_class
def create_report_criteria_form(report, jsonform=False, **kwargs):
""" Create a form for this report.
Any TableCriteria objects linked to this report or it's
widgets are passed to the initialization method for a
ReportCriteriaForm.
If the report has no associated TableCriteria, nothing
special will occur, and a nominal form will be returned.
Only criteria objects which have no 'parent' will be included,
'parent' objects will later provide the form values
to all children criteria during processing.
"""
# use SortedDict to limit to unique criteria objects only
extra = SortedDict()
# Collect all criteria objects tied to this report
for c in report.criteria.all():
if not c.parent:
extra[c.id] = c
# Collect all criteria objects tied to any widgets associated with report
for widget in Widget.objects.filter(report=report):
for table in widget.tables.all():
for tc in table.criteria.all():
if not tc.parent:
extra[tc.id] = tc
kwargs['extra'] = extra.values()
if jsonform:
return ReportCriteriaJSONForm(**kwargs)
else:
return ReportCriteriaForm(**kwargs)
def make_basic_chart_json(
values,
chart_type='pie',
chart_tip='#val#',
chart_nolabels=True,
chart_make_value=default_make_value,
chart_params=None,
elements_params=None,
):
# Sorts from biggest to smallest
values = values.items()
values.sort(lambda a,b: cmp(b[1], a[1]))
values = SortedDict([(k,v) for k,v in values if v])
data = {"bg_colour": "#ffffff",
"elements": [{
"type": chart_type,
"tip": _(chart_tip),
"no-labels": chart_nolabels,
"colours": [random_color() for i in values.values()],
"values": [chart_make_value(num, i) for num, i in enumerate(values.items())],
"alpha": 0.7,
}],
}
if chart_params:
data.update(chart_params)
if elements_params:
for e in data['elements']:
e.update(elements_params)
return HttpResponse(simplejson.dumps(data, cls=BIEncoder), mimetype="text/javascript")
def _build_keys(self, slug, date=None, granularity="all"):
"""Builds redis keys used to store metrics.
* ``slug`` -- a slug used for a metric, e.g. "user-signups"
* ``date`` -- (optional) A ``datetime.date`` or ``datetime.datetime``
objects used to generate the time period for the metric. If omitted,
the current date will be used.
* ``granularity`` -- Must be one of: "all" (default), "daily",
"weekly", "monthly", "yearly".
Returns a list of strings.
"""
slug = slugify(slug) # Make sure our slugs have a consistent format
if date is None:
date = datetime.date.today()
# we want to keep the order, here: daily, weekly, monthly, yearly
patterns = SortedDict()
patterns.insert(0, "daily", "m:{0}:{1}".format(slug, date.strftime("%Y-%m-%d")))
patterns.insert(1, "weekly", "m:{0}:w:{1}".format(slug, date.strftime("%U")))
patterns.insert(2, "monthly", "m:{0}:m:{1}".format(slug, date.strftime("%Y-%m")))
patterns.insert(3, "yearly", "m:{0}:y:{1}".format(slug, date.strftime("%Y")))
if granularity == "all":
return patterns.values()
else:
return [patterns[granularity]]
def post(self, request, *args, **kwargs):
fields = self.generate_fields()
readonly_fields = self.generate_readonly_fields()
form_class = self.generate_form_class(fields, readonly_fields)
form = self.get_form(form_class)
inline_form_views = SortedDict()
inline_forms_is_valid = True
inline_views = self.init_inline_views(form.instance)
inline_form_views = self._filter_inline_form_views(inline_views)
for inline_form_view in inline_form_views.values():
inline_forms_is_valid = (inline_form_view.formset.is_valid()) \
and inline_forms_is_valid
is_valid = form.is_valid()
is_changed = self.is_changed(form, inline_form_views=inline_form_views)
if is_valid and inline_forms_is_valid and is_changed:
return self.form_valid(form, inline_form_views, inline_views)
else:
if is_valid and not is_changed:
return self.form_invalid(form, inline_form_views, inline_views,
msg=_('No changes have been submitted.'),
msg_level=constants.INFO)
return self.form_invalid(form, inline_form_views, inline_views)
def post(self, request, *args, **kwargs):
fields = self.generate_fields()
readonly_fields = self.generate_readonly_fields()
form_class = self.generate_form_class(fields, readonly_fields)
form = self.get_form(form_class)
inline_form_views = SortedDict()
inline_forms_is_valid = True
inline_views = self.init_inline_views(form.instance)
inline_form_views = self._filter_inline_form_views(inline_views)
for inline_form_view in inline_form_views.values():
inline_forms_is_valid = (inline_form_view.formset.is_valid()) \
and inline_forms_is_valid
is_valid = form.is_valid()
is_changed = self.is_changed(form, inline_form_views=inline_form_views)
if is_valid and inline_forms_is_valid and is_changed:
return self.form_valid(form, inline_form_views, inline_views)
else:
if is_valid and not is_changed:
return self.form_invalid(
form,
inline_form_views,
inline_views,
msg=_('No changes have been submitted.'),
msg_level=constants.INFO)
return self.form_invalid(form, inline_form_views, inline_views)
def handle(self, *args, **options):
from django.conf import settings
from rent.models import Booking
log.info('Starting monthly insurance billing batch')
csv_file = TemporaryFile()
writer = csv.writer(csv_file, delimiter='|')
period = (date.today() - relativedelta(months=1))
for booking in Booking.objects.ended().filter(created_at__year=period.year, created_at__month=period.month):
row = SortedDict()
row['Numéro police'] = settings.POLICY_NUMBER
row['Numéro partenaire'] = settings.PARTNER_NUMBER
row['Numéro contrat'] = booking.contract_id
row[u'Durée de garantie'] = (booking.ended_at - booking.started_at).days
row[u'Numéro de commande'] = booking.uuid
row['Date d\'effet des garanties'] = booking.started_at.strftime("%Y%m%d")
row[u'Désignation'] = smart_str(booking.product.description)
row['Prix de la location TTC'] = booking.total_amount
row['Prix de cession HT'] = booking.insurance_fee
row['Com. du partenaire'] = booking.insurance_commission
row['Taxes assurance à 9%'] = booking.insurance_taxes
row['Cotisation TTC'] = booking.insurance_amount
writer.writerow(row.values())
log.info('Sending monthly insurance billing by mail')
email = EmailMessage('Fichier de facturation e-loue.com',
'Ci-joint le fichier de facturion du %s/%s' % (
period.month, period.year
), '*****@*****.**',
[settings.INSURANCE_EMAIL])
email.attach('facturation-eloue-%s-%s.csv' %
(period.month, period.year), csv_file)
email.send()
log.info('Finished monthly insurance reimbursement batch')
def download_selected_searchrequests(self, request, searchrequests):
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=%s' \
% self.get_download_filename(request)
writer = CsvUnicodeWriter(response, delimiter=',')
meta_data = (('id', _('Search request number')),
('num_items', _('Number of items')),
('state', _('Status')),
('owner', _('Owner')),
('creation_date', _('Creation date')),
)
columns = SortedDict()
for k, v in meta_data:
columns[k] = v
writer.writerow(columns.values())
for searchrequest in searchrequests:
row = columns.copy()
row['id'] = searchrequest.id
row['creation_date'] = format_datetime(searchrequest.date_created, 'DATETIME_FORMAT')
row['state'] = searchrequest.state
row['num_items'] = searchrequest.num_items
row['owner'] = searchrequest.owner.email
encoded_values = [six.text_type(value).encode('utf8')
for value in row.values()]
writer.writerow(encoded_values)
return response
def _build_report_data(self):
tmp_data = SortedDict()
totals = ['Totals'] + [0] * len(self.DEVICE_TYPES)
visit_counts = self.visit_queryset().values(
'visit_date',
'device__device_type__code',
).filter(
device__device_type__code__in=self.DEVICE_TYPES
).annotate(Count('device__device_type')).order_by('visit_date')
if not visit_counts:
return []
for visit in visit_counts:
device_type = visit['device__device_type__code']
date_obj = visit['visit_date']
if date_obj not in tmp_data:
date_str = format_date(date_obj)
tmp_data[date_obj] = [date_str] + ([0] * len(self.DEVICE_TYPES))
index = self.DEVICE_TYPES.index(device_type) + 1
tmp_data[date_obj][index] += visit['device__device_type__count']
totals[index] += visit['device__device_type__count']
return tmp_data.values() + [totals]
def testQuickpayPayments(self):
data = SortedDict([
('msgtype', 'authorize'),
('ordernumber', self.booking.ordernumber),
('amount', '1000'),
('currency', 'DKK'),
('time', '120101090000'),
('state', '1'),
('qpstat', '000'),
('qpstatmsg', 'qpstat message'),
('chstat', '000'),
('chstatmsg', 'chstat message'),
('merchant', self.account.merchant_id),
('merchantemail', '*****@*****.**'),
('transaction', '0123456789'),
('cardtype', 'dankort'),
('cardnumber', ''),
])
md_input = ''.join(data.values()) + self.account.secret_key
data['md5check'] = md5_constructor(md_input).hexdigest()
response = self.client.post(
reverse('quickpay_callback'),
data,
HTTP_HOST=self.http_host
)
self.assertTrue(Booking.objects.get(pk=self.booking.pk).confirmed)
def full_print(self):
if self.last_print and (datetime.datetime.now() - self.last_print < datetime.timedelta(seconds=3)):
return
d = SortedDict()
for name, deltas in self.messages.items():
sum = datetime.timedelta()
for delta in deltas:
sum += delta
avg = sum / len(deltas)
mx = max(deltas)
mn = min(deltas)
if len(name) > 50:
name = name[:50]
line = self.format %(name, avg, mx, mn, len(deltas))
d[avg] = line
d.keyOrder.sort()
d.keyOrder.reverse()
line_number = 3
self.stdscr.clear()
self.stdscr.addstr(1, 4, self.header_line)
for line in d.values():
try:
self.stdscr.addstr(line_number, 4, line)
except Exception:
break
line_number += 1
self.stdscr.refresh()
self.last_print = datetime.datetime.now()
class BindingDict(object):
"""
This dict-like object is used to store fields on a serializer.
This ensures that whenever fields are added to the serializer we call
`field.bind()` so that the `field_name` and `parent` attributes
can be set correctly.
"""
def __init__(self, serializer):
self.serializer = serializer
self.fields = SortedDict()
def __setitem__(self, key, field):
self.fields[key] = field
field.bind(field_name=key, parent=self.serializer)
def __getitem__(self, key):
return self.fields[key]
def __delitem__(self, key):
del self.fields[key]
def items(self):
return self.fields.items()
def keys(self):
return self.fields.keys()
def values(self):
return self.fields.values()
def get_and_child(parents, cqs):
""" Retourne les valeurs d'un SortedDict avec parents (liste reduite)
et enfants accessibles par l'attribut enfants, les enfants sont données
en queryset par le param cqs """
ret = SortedDict()
for p in parents:
p.enfants = []
p.file = False
ret[p.id] = p
parent_ids = ret.keys()
cqs = cqs.filter(parent__in=parent_ids)
alarms = TicketAlarm.opened.filter(ticket__in=parent_ids)
files = TicketFile.objects.filter(ticket__in=parent_ids)
for e in cqs:
ret[e.parent.id].enfants.append(e)
for a in alarms:
ret[a.ticket_id].alarm = a
for f in files:
ret[f.ticket.id].file = True
return ret.values()
class Node(object):
"""
A base class representing a navigation or page node and providing some
dictionary-like behavior for navigating the tree.
"""
def __init__(self):
super(Node, self).__init__()
self.children = SortedDict()
def __getitem__(self, key):
return self.children.__getitem__(key)
def __iter__(self):
return self.children.__iter__()
def __setitem__(self, key, value):
return self.children.__setitem__(key, value)
def __unicode__(self):
return self.title
def keys(self):
return self.children.keys()
def values(self):
return self.children.values()
@property
def is_leaf(self):
return not bool(self.children)
def handle_noargs(self, **options):
self.set_options(**options)
found_files = SortedDict()
manifest = ConfiguredStaticFilesManifest()
manifest.clear()
ignore_patterns = getattr(settings, 'ECSTATIC_MANIFEST_EXCLUDES', [])
for finder in finders.get_finders():
for path, storage in finder.list(ignore_patterns):
# Prefix the relative path if the source storage contains it
if getattr(storage, 'prefix', None):
prefixed_path = os.path.join(storage.prefix, path)
else:
prefixed_path = path
if prefixed_path not in found_files:
found_files[prefixed_path] = path
for path in found_files.values() + settings.ECSTATIC_MANIFEST_EXTRAS:
try:
generate_url = self.storage.generate_url
except AttributeError:
raise AttributeError(
'%s doesn\'t define a generate_url method.'
' Did you remember to extend StaticManifestMixin?' %
self.storage)
hashed_name = generate_url(path)
manifest.add(path, hashed_name)
manifest.flush()
def get_message_list(project_id, lang_id, src_filters={}, target_filters={}):
lang_id = int(lang_id)
project_language = Project.objects.get(id=project_id).lang.id
new_query = SetMessage.objects.all()
if not new_query.exists():
return []
new_query = new_query.filter(_normalize_filters(src_filters))
target_predicate = _normalize_filters(target_filters)
if target_predicate:
new_query = new_query.filter(Q(lang=project_language) | Q(target_predicate))
res = SortedDict()
new_query = _update_message_query(new_query, project_id, lang_id)
for data in new_query.order_by('msgid'):
msg_info = res.setdefault(data.msgid, {'msg_id': data.msgid})
if data.lang_id == lang_id:
msg_info.update(
{
'msg_target': data.msgstr,
'target_id': data.id,
'is_translated': data.is_translated
}
)
if data.lang_id == project_language:
msg_info.update({'msg_source': data.msgstr, 'id': data.id})
messages = [i for i in res.values() if 'msg_target' in i]
return messages
def _handle_messages(self, child):
"""
``<messages>`` has a somewhat nonstandard structure::
<messages>
<topic type="message" href="/messages/id/123" /> <!-- first message in thread -->
<read> <!-- read count (?) -->
<count type="int">5</count>
</read>
<linear> <!-- list of messages -->
<!-- note: first message is equal to topic -->
<message type="message" href="/messages/id/123" />
<message type="message" href="/messages/id/124" />
<message type="message" href="/messages/id/125" />
</linear>
</messages>
"""
messages = SortedDict()
for elem in child:
if elem.tag == 'topic':
self.topic = xml_to_type(elem, self._api)
messages[self.topic.href] = self.topic
elif elem.tag == 'linear':
for message in elem:
m = xml_to_type(message, self._api)
if m.href not in messages:
messages[m.href] = m
if m.parent and m.parent.href in messages:
m.parent = messages[m.parent.href]
elif elem.tag == 'read':
self.read_count = elem.text
self.messages = messages.values()
def create_report_criteria_form(*args, **kwargs):
""" Factory function to create dynamic Report forms
Included `report` kwargs will be assessed for
any linked TableCriteria objects and passed to
the initialization method for a ReportCriteriaForm.
If the report has no associated TableCriteria, nothing
special will occur, and a nominal form will be returned.
Only objects which have no "parents" will be included,
"parent" objects will later provide the form values
to all children criteria during processing.
"""
report = kwargs.pop('report')
jsonform = kwargs.pop('jsonform', False)
# use SortedDict to limit to unique criteria objects only
extra = SortedDict()
for c in report.criteria.all():
if not c.parent:
extra[c.id] = c
for widget in Widget.objects.filter(report=report):
for table in widget.tables.all():
for tc in table.criteria.all():
if not tc.parent:
extra[tc.id] = tc
kwargs['extra'] = extra.values()
if jsonform:
return ReportCriteriaJSONForm(*args, **kwargs)
else:
return ReportCriteriaForm(*args, **kwargs)
def _site_query(period, start, end, field=None, request=None):
old_version = request and request.GET.get("old_version", "0") or "0"
cursor = connection.cursor()
# Let MySQL make this fast. Make sure we prevent SQL injection with the
# assert.
if period not in SERIES_GROUPS_DATE:
raise AssertionError("%s period is not valid." % period)
sql = (
"SELECT name, MIN(date), SUM(count) "
"FROM global_stats "
"WHERE date > %%s AND date <= %%s "
"AND name IN (%s) "
"GROUP BY %s(date), name "
"ORDER BY %s(date) DESC;" % (", ".join(["%s" for key in _KEYS.keys()]), period, period)
)
cursor.execute(sql, [start, end] + _KEYS.keys())
# Process the results into a format that is friendly for render_*.
default = dict([(k, 0) for k in _CACHED_KEYS])
result = SortedDict()
for name, date, count in cursor.fetchall():
date = date.strftime("%Y-%m-%d")
if date not in result:
result[date] = default.copy()
result[date]["date"] = date
result[date]["data"] = {}
result[date]["data"][_KEYS[name]] = count
return result.values(), _CACHED_KEYS
def render(self):
product = self.context.get("product", None)
category = self.context.get("category", None)
if product:
cats = product.category.all()
if cats:
category = cats[0]
if not category:
categories = SortedDict()
first_level_categories = Category.objects.filter(
parent__isnull=True, is_active=True).order_by('ordering', 'name')
for item in first_level_categories:
categories[item.pk] = SortedDict({
'name': item.name,
'slug': item.slug,
'url': item.get_absolute_url(),
'subcategories': {},
'current': False})
return {'menu': self.asHtml(categories),
'categories': categories.values()}
else:
internal_categories = self.look_for_category(
category, category.id)
html_categories = self.asHtml(internal_categories)
return {'menu': html_categories,
'categories': internal_categories.values()}
def handle_noargs(self, **options):
self.set_options(**options)
found_files = SortedDict()
manifest = ConfiguredStaticFilesManifest()
manifest.clear()
ignore_patterns = getattr(settings, 'ECSTATIC_MANIFEST_EXCLUDES', [])
for finder in finders.get_finders():
for path, storage in finder.list(ignore_patterns):
# Prefix the relative path if the source storage contains it
if getattr(storage, 'prefix', None):
prefixed_path = os.path.join(storage.prefix, path)
else:
prefixed_path = path
if prefixed_path not in found_files:
found_files[prefixed_path] = path
for path in found_files.values() + settings.ECSTATIC_MANIFEST_EXTRAS:
try:
generate_url = self.storage.generate_url
except AttributeError:
raise AttributeError('%s doesn\'t define a generate_url method.'
' Did you remember to extend StaticManifestMixin?' %
self.storage)
hashed_name = generate_url(path)
manifest.add(path, hashed_name)
manifest.flush()
class PasswdListView(PdfMixin, KlassDetailMixin, LoginRequiredMixin, generic.TemplateView):
"""
Renders the PDF password list and saves in the klass the passwords were
printed.
"""
template_name = 'teachers/clients/passwd_list.html'
def get(self, request, *args, **kwargs):
password_list = request.session.get('password_list', {})
if str(self.klass.pk) in password_list:
self.klass.password_list_printed_at = timezone.now()
self.klass.save()
self.passwords = SortedDict(password_list[str(self.klass.pk)])
return super(PasswdListView, self).get(request, *args, **kwargs)
else:
raise ValueError('You are trying to access the pdf list of passwords'
' but it is not in the session.')
def get_context_data(self, *args, **kwargs):
context = super(PasswdListView, self).get_context_data(*args, **kwargs)
context['klass'] = self.klass
users = User.objects.filter(pk__in=self.passwords.keys())
context['passwords'] = zip(users, self.passwords.values())
return context
def __new__(cls, name, bases, attrs):
super_new = super(PistonViewMetaclass, cls).__new__
parents = [b for b in bases if isinstance(b, PistonViewMetaclass)]
if not parents:
# If this isn't a subclass of PistonViewMetaclass, don't do anything special.
return super_new(cls, name, bases, attrs)
base_fields = SortedDict()
for parent_cls in parents:
for field in getattr(parent_cls, 'base_fields', []):
# if the superclass has defined a field, don't add
# that field from the base class since inspect.getmro
# lists classes in order from super to base
if field.destination not in base_fields:
base_fields[field.destination] = field
for field in attrs.get('fields', []):
if isinstance(field, basestring):
field = Field(field)
base_fields[field.destination] = field
attrs['base_fields'] = base_fields.values()
new_class = super_new(cls, name, bases, attrs)
return new_class
class Node(object):
"""
A base class representing a navigation or page node and providing some
dictionary-like behavior for navigating the tree.
"""
def __init__(self):
super(Node, self).__init__()
self.children = SortedDict()
def __getitem__(self, key):
return self.children.__getitem__(key)
def __iter__(self):
return self.children.__iter__()
def __setitem__(self, key, value):
return self.children.__setitem__(key, value)
def __unicode__(self):
return self.title
def keys(self):
return self.children.keys()
def values(self):
return self.children.values()
@property
def is_leaf(self):
return not bool(self.children)
def _site_query(period, start, end, field=None, request=None):
cursor = connection.cursor()
# Let MySQL make this fast. Make sure we prevent SQL injection with the
# assert.
if period not in SERIES_GROUPS_DATE:
raise AssertionError('%s period is not valid.' % period)
sql = ("SELECT name, MIN(date), SUM(count) "
"FROM global_stats "
"WHERE date > %%s AND date <= %%s "
"AND name IN (%s) "
"GROUP BY %s(date), name "
"ORDER BY %s(date) DESC;" %
(', '.join(['%s' for key in _KEYS.keys()]), period, period))
cursor.execute(sql, [start, end] + _KEYS.keys())
# Process the results into a format that is friendly for render_*.
default = dict([(k, 0) for k in _CACHED_KEYS])
result = SortedDict()
for name, date_, count in cursor.fetchall():
date_ = date_.strftime('%Y-%m-%d')
if date_ not in result:
result[date_] = default.copy()
result[date_]['date'] = date_
result[date_]['data'] = {}
result[date_]['data'][_KEYS[name]] = int(count)
return result.values(), _CACHED_KEYS
def _site_query(period, start, end, field=None, request=None):
cursor = connection.cursor()
# Let MySQL make this fast. Make sure we prevent SQL injection with the
# assert.
if period not in SERIES_GROUPS_DATE:
raise AssertionError('%s period is not valid.' % period)
sql = ("SELECT name, MIN(date), SUM(count) "
"FROM global_stats "
"WHERE date > %%s AND date <= %%s "
"AND name IN (%s) "
"GROUP BY %s(date), name "
"ORDER BY %s(date) DESC;"
% (', '.join(['%s' for key in _KEYS.keys()]), period, period))
cursor.execute(sql, [start, end] + _KEYS.keys())
# Process the results into a format that is friendly for render_*.
default = dict([(k, 0) for k in _CACHED_KEYS])
result = SortedDict()
for name, date_, count in cursor.fetchall():
date_ = date_.strftime('%Y-%m-%d')
if date_ not in result:
result[date_] = default.copy()
result[date_]['date'] = date_
result[date_]['data'] = {}
result[date_]['data'][_KEYS[name]] = int(count)
return result.values(), _CACHED_KEYS
def get_context_data(self, **kwargs):
context = super(DedicatedBindingView, self).get_context_data(**kwargs)
self.page_title=self.request.GET.get("page_title", None)
context['pool_type']=self.request.GET.get("pool_type", None)
context['tenant_id']=self.kwargs['tenant_id']
context['instance'] = self.get_instance()
tenant = SortedDict([(t.id, t.name)for t in self.tenant_list()])
user_list = [us.id for us in api.keystone.user_list(self.request)]
free_instance = list()
for ins in self.get_instance():
if not ins.tenant_id:
free_instance.append(ins)
elif ins.tenant_id not in tenant.keys():
free_instance.append(ins)
elif ins.user_id not in user_list and ins.tenant_id == self.kwargs['tenant_id']:
free_instance.append(ins)
elif ins.tenant_id in tenant.keys():
_values = tenant.values()
admin_index = _values.index(u'admin')
_keys = tenant.keys()
admin_keys_id = _keys.pop(admin_index)
if ins.tenant_id == admin_keys_id:
free_instance.append(ins)
context['free_instance']=sorted(free_instance, key=operator.attrgetter('name'))
context['user']=sorted(self.get_user(tenant_id=self.kwargs['tenant_id']),
key=operator.attrgetter('name'))
return context
def vote(request, course_id):
# retrieve course and make sure that the user is allowed to vote
course = get_object_or_404(Course, id=course_id)
if not course.can_user_vote(request.user):
raise PermissionDenied
# build forms
forms = SortedDict()
for questionnaire, contribution in questionnaires_and_contributions(
course):
form = QuestionsForm(request.POST or None,
contribution=contribution,
questionnaire=questionnaire)
forms[(contribution, questionnaire)] = form
if all(form.is_valid() for form in forms.values()):
# begin vote operation
with transaction.commit_on_success():
for (contribution, questionnaire), form in forms.items():
for question in questionnaire.question_set.all():
identifier = make_form_identifier(contribution,
questionnaire, question)
value = form.cleaned_data.get(identifier)
if type(value) in [str, unicode]:
value = value.strip()
if value == 6: #no answer
value = None
# store the answer if one was given
if value:
question.answer_class.objects.create(
contribution=contribution,
question=question,
answer=value)
# remember that the user voted already
course.voters.add(request.user)
messages.add_message(request, messages.INFO,
_("Your vote was recorded."))
return redirect('evap.student.views.index')
else:
return render_to_response("student_vote.html",
dict(forms=forms.values(), course=course),
context_instance=RequestContext(request))
def get_best_matches(record):
ret = SortedDict()
record.documents = {}
# Match based on legacy id (record.stokes_db)
hand_id = record.stokes_db.strip()
if hand_id:
hands = Hand.objects.filter(legacy_id=hand_id)
for hand in hands:
add_matching_hand_to_result(ret, record, hand, 'L', True)
# Match based on scragg id (record.scragg, hand.scragg)
hand_id = record.scragg.strip()
if hand_id:
hands = Hand.objects.filter(scragg=hand_id)
for hand in hands:
add_matching_hand_to_result(ret, record, hand, 'Scr', False)
# Match based on K/G/S/P ids
sources = ['ker', 'gneuss', 'sp']
for source in sources:
document_id = getattr(record, source, '').strip()
if document_id:
source_dp = source
if source == 'sp':
source_dp = settings.SOURCE_SAWYER_KW
document_id_p = re.sub('(?i)^\s*p\s*(\d+)', r'\1', document_id)
source = 'S'
if document_id_p != document_id:
document_id = document_id_p
source_dp = 'pelteret'
source = 'P'
document_ids = re.split('\s*,\s*', document_id)
documents = ItemPart.objects.filter(Q(historical_items__catalogue_numbers__source=Source.get_source_from_keyword(source_dp)) & \
Q(historical_items__catalogue_numbers__number__in=document_ids)).distinct()
for doc in documents: record.documents[doc.id] = doc
hands = Hand.objects.filter(latin_only=False).filter(Q(images__item_part__in=documents) | Q(item_part__in=documents)).distinct().order_by('id')
for hand in hands:
add_matching_hand_to_result(ret, record, hand, source.upper()[0])
# find best matches based on the historical item
# Existing matches
for match in record.get_matched_hands():
rtype, rid = match.split(':')
if rtype == 'h':
add_matching_hand_to_result(ret, record, Hand.objects.get(id=rid), 'M')
if rtype == 'ip':
add_matching_hand_to_result(ret, record, Hand(item_part_id=rid, label="NEW HAND"), 'M')
# New Hand
add_matching_hand_to_result(ret, record, Hand(), 'New')
record.documents = record.documents.values()
ret = [h for h in ret.values()]
return ret
class Meta(object):
auto_created = False
abstract = False
db_table = None
local_many_to_many = []
many_to_many = local_many_to_many
unique_together = []
parents = {}
proxy = None
managed = False
pk = Field('pk', unique=True, primary_key=True, auto_created=True, editable=False)
def __init__(self, model_name, app_label, fields, verbose_name,
verbose_name_plural, ordering=None):
self.object_name = self.model_name = model_name
self.module_name = self.model_name.lower()
self.app_label = app_label
self.verbose_name_raw = self.verbose_name = verbose_name
self.verbose_name_plural = verbose_name_plural
self.fields_dict = SortedDict(
[('pk', self.pk)] + [(f, Field(f)) for f in fields]
)
self.has_auto_field = True
self.auto_field = self.pk
self.fields = self.local_fields = self.fields_dict.values()
self.ordering = ordering
def get_field(self, name):
if name not in self.fields_dict:
raise FieldDoesNotExist('No field `%s` in model: %s' % (name, self.object_name))
return self.fields_dict[name]
def get_field_by_name(self, name):
return (self.get_field(name), None, True)
def get_ordered_objects(self):
return []
def get_all_related_objects(self, include_hidden=None):
return []
def get_all_related_many_to_many_objects(self):
return []
def get_delete_permission(self):
return 'delete'
def handle(self, *args, **options):
from django.conf import settings
from rent.models import Sinister
log.info('Starting daily insurance sinisters batch')
csv_file = TemporaryFile()
writer = csv.writer(csv_file, delimiter='|')
period = (date.today() - timedelta(days=1))
for sinister in Sinister.objects.filter(
~Q(product__owner__is_professional=True),
product__carproduct=None,
product__realestateproduct=None,
created_at__year=period.year,
created_at__month=period.month,
created_at__day=period.day,
product__category__need_insurance=True):
row = SortedDict()
row['Login locataire'] = sinister.booking.borrower.username
row['Adresse email'] = sinister.booking.borrower.email
phones = sinister.booking.borrower.phones.all()
if phones:
row[u'Numéro de téléphone'] = phones[0]
else:
row[u'Numéro de téléphone'] = None
row[u'Numéro du sinistre'] = sinister.sinister_id
row['Date de survenance du sinistre'] = sinister.created_at.strftime(
"%Y%m%d")
row['Nature du sinistre'] = 'bris'
row['Description des circonstances'] = smart_str(
sinister.description)
row[u'Numéro police'] = settings.POLICY_NUMBER
row[u'Numéro partenaire'] = settings.PARTNER_NUMBER
row[u'Numéro contrat'] = sinister.booking.contract_id
row['Date d\'effet des garanties'] = sinister.booking.started_at.strftime(
"%Y%m%d")
row[u'Numéro de commande'] = sinister.booking.uuid
row[u'Type de produit'] = smart_str(
sinister.booking.product.category.name)
row['Montant de la Caution'] = comma_separated(
sinister.booking.deposit_amount)
row['Prix de la location TTC'] = comma_separated(
sinister.booking.total_amount)
writer.writerow(row.values())
csv_file.seek(0)
latin1csv_file = TemporaryFile()
for line in csv_file:
latin1csv_file.write(
line.decode('utf-8').encode('latin1', 'ignore'))
latin1csv_file.seek(0)
log.info('Uploading daily insurance subscriptions')
ftp = FTP(settings.INSURANCE_FTP_HOST)
ftp.login(settings.INSURANCE_FTP_USER, settings.INSURANCE_FTP_PASSWORD)
if settings.INSURANCE_FTP_CWD:
ftp.cwd(settings.INSURANCE_FTP_CWD)
ftp.storlines("STOR sinistre-eloue-%s-%s" % (period.month, period.day),
latin1csv_file)
ftp.quit()
log.info('Finished daily insurance sinisters batch')
class ToolbarPool(object):
def __init__(self):
self.toolbars = SortedDict()
self._discovered = False
self.force_register = False
def discover_toolbars(self):
if self._discovered:
return
#import all the modules
toolbars = get_cms_setting('TOOLBARS')
if toolbars:
for cls in iterload_objects(toolbars):
self.force_register = True
self.register(cls)
self.force_register = False
else:
load('cms_toolbar')
self._discovered = True
def clear(self):
self.toolbars = SortedDict()
self._discovered = False
def register(self, toolbar):
if not self.force_register and get_cms_setting('TOOLBARS'):
return toolbar
from cms.toolbar_base import CMSToolbar
# validate the app
if not issubclass(toolbar, CMSToolbar):
raise ImproperlyConfigured(
'CMS Toolbar must inherit '
'cms.toolbar_base.CMSToolbar, %r does not' % toolbar)
name = "%s.%s" % (toolbar.__module__, toolbar.__name__)
if name in self.toolbars.keys():
raise ToolbarAlreadyRegistered(
"[%s] a toolbar with this name is already registered" % name)
self.toolbars[name] = toolbar
return toolbar
def unregister(self, toolbar):
name = '%s.%s' % (toolbar.__module__, toolbar.__name__)
if name not in self.toolbars:
raise ToolbarNotRegistered('The toolbar %s is not registered' %
name)
del self.toolbars[name]
def get_toolbars(self):
self.discover_toolbars()
return self.toolbars
def get_watch_models(self):
models = []
for toolbar in self.toolbars.values():
if hasattr(toolbar, 'watch_models'):
models += toolbar.watch_models
return models
def course_preview(request, semester_id, course_id):
semester = get_object_or_404(Semester, id=semester_id)
course = get_object_or_404(Course, id=course_id)
# build forms
forms = SortedDict()
for questionnaire, contribution in questionnaires_and_contributions(course):
form = QuestionsForm(request.POST or None, contribution=contribution, questionnaire=questionnaire)
forms[(contribution, questionnaire)] = form
return render_to_response("fsr_course_preview.html", dict(forms=forms.values(), course=course, semester=semester), context_instance=RequestContext(request))
def collect_fields_by_section(self):
""" Return a dict of all fields related to this report by section id.
"""
# map of section id to field dict
fields_by_section = {}
# section id=0 is the "common" section
fields_by_section[0] = SortedDict()
if self.fields:
report_fields = {}
for f in self.fields.all():
report_fields[f.keyword] = f
fields_by_section[0].update(report_fields)
# Pull in fields from each section (which may add fields to
# the common as well)
for s in Section.objects.filter(report=self):
for section_id, fields in s.collect_fields_by_section().iteritems(
):
if section_id not in fields_by_section:
fields_by_section[section_id] = fields
else:
fields.update(fields_by_section[section_id])
fields_by_section[section_id] = fields
# Reorder fields in each section according to the field_order list
new_fields_by_section = {}
for i, fields in fields_by_section.iteritems():
# fields_by_section will have the format:
# { 's17_duration' : TableField(keyword='duration'),
# 's18_duration' : TableField(keyword='duration'), ...}
# The field_order list is by keyword, not the <sectionid>_<keyword> format
keywords_to_field_names = SortedDict()
for (field_name, field) in fields_by_section[i].iteritems():
keywords_to_field_names[field.keyword] = (field_name, field)
ordered_field_names = SortedDict()
# Iterate over the defined order list, which may not address all fields
if self.field_order:
for keyword in self.field_order:
if keyword in keywords_to_field_names:
pair = keywords_to_field_names[keyword]
ordered_field_names[pair[0]] = pair[1]
del keywords_to_field_names[keyword]
# Preserve the order of any fields left
for pair in keywords_to_field_names.values():
ordered_field_names[pair[0]] = pair[1]
new_fields_by_section[i] = ordered_field_names
return new_fields_by_section
def galYearPurchase(request):
''' Plots a pie chart showing the material cost by Organizational Units'''
width = int(request.GET.get('w', '400'))
height = int(request.GET.get('h', '240'))
end_date = datetime.strptime(
request.GET.get('end_date',
datetime.today().strftime('%Y-%m-%d')), '%Y-%m-%d')
if 'start_date' in request.GET:
start_date = datetime.strptime(
request.GET.get('start_date',
datetime.today().strftime('%Y-%m-%d')), '%Y-%m-%d')
else: # Calcs 12 months ago
if end_date.month == 12:
start_date = datetime(end_date.year, 1, 1)
else:
start_date = datetime(end_date.year - 1, end_date.month + 1, 1)
year = start_date.year
month = start_date.month
data = SortedDict()
while (datetime(year, month, 1) < end_date):
data[datetime(year, month, 1).strftime('%m-%Y')] = 0
month += 1
if month > 12:
year += 1
month = 1
for inv in PurchaseInvoice.objects.filter(
input_date__gt=start_date,
input_date__lte=end_date).order_by('input_date'):
month_year = inv.input_date.strftime('%m-%Y')
data[month_year] += inv.total_cost
chart = pygal.Line(width=width,
height=height,
style=LightStyle,
x_label_rotation=30,
show_legend=False,
interpolate='cubic',
title_font_size=12)
chart.title = _(u'From %(startdate)s to %(enddate)s') % {
'startdate': start_date.strftime('%d-%m-%Y'),
'enddate': end_date.strftime('%d-%m-%Y')
}
chart.x_labels = data.keys()
chart.add(_(u'Purchases'), map(float, data.values()))
svg = chart.render()
png = cairosvg.svg2png(svg)
return HttpResponse(png, 'image/png')
class DebugToolbar(object):
def __init__(self, request):
self.request = request
self._panels = SortedDict()
base_url = self.request.META.get('SCRIPT_NAME', '')
self.config = {
'INTERCEPT_REDIRECTS': True,
'MEDIA_URL': u'%s/__debug__/m/' % base_url,
'ROOT_TAG_ATTRS': '',
}
# Check if settings has a DEBUG_TOOLBAR_CONFIG and updated config
self.config.update(getattr(settings, 'DEBUG_TOOLBAR_CONFIG', {}))
self.template_context = {
'BASE_URL': base_url, # for backwards compatibility
'DEBUG_TOOLBAR_MEDIA_URL': self.config.get('MEDIA_URL'),
'STATIC_URL': settings.STATIC_URL,
'TOOLBAR_ROOT_TAG_ATTRS': self.config.get('ROOT_TAG_ATTRS'),
}
self.load_panels()
self.stats = {}
def _get_panels(self):
return self._panels.values()
panels = property(_get_panels)
def get_panel(self, cls):
return self._panels[cls]
def load_panels(self):
"""
Populate debug panels
"""
global panel_classes
for panel_class in panel_classes:
try:
panel_instance = panel_class(context=self.template_context)
except:
raise # Bubble up problem loading panel
self._panels[panel_class] = panel_instance
def render_toolbar(self):
"""
Renders the overall Toolbar with panels inside.
"""
context = self.template_context.copy()
context.update({
'panels': self.panels,
})
return render_to_string('debug_toolbar/base.html', context)
def main_menu(context):
app_list = lfssite.index(context['request']).context_data['app_list']
new_app_list = SortedDict()
for app in app_list:
if app['name'] in new_app_list:
new_app_list[app['name']]['models'].extend(app['models'])
else:
new_app_list[app['name']] = app
context['new_app_list'] = new_app_list.values()
if context.get('title') == _('Site administration'):
context['app_list'] = context['new_app_list']
return context
class IndicatorSet(object):
def __init__(self, spec):
self.slug = spec["slug"]
self.name = spec["name"]
self.indicators = SortedDict()
for ispec in spec.get("indicators", []):
self.indicators[ispec["slug"]] = Indicator(ispec)
def get_indicators(self):
return self.indicators.values()
def get_indicator(self, slug):
return self.indicators[slug]
class IndicatorSet(object):
def __init__(self, spec):
from django.utils.datastructures import SortedDict
self.slug = spec["slug"]
self.name = spec["name"]
self.indicators = SortedDict()
for ispec in spec.get("indicators", []):
self.indicators[ispec["slug"]] = Indicator(ispec)
def get_indicators(self):
return list(self.indicators.values())
def get_indicator(self, slug):
return self.indicators[slug]
def products_photos_get(qset):
ids_map = SortedDict()
for product in qset:
ids_map[product.pk] = product
for img in ProductImage.active_objects.filter(
product__in=ids_map.keys()).order_by('pos'):
product = ids_map[img.product_id]
if not hasattr(product, 'images'):
product.images = []
product.images.append(img)
return ids_map.values()
class Backend(object):
def __init__(self):
self.servers = SortedDict()
fp = open(settings.DASHVISOR_CONFIG_FILE)
index = 0
for line in fp.xreadlines():
id = str(index)
server = Server(line.strip(), id=id)
self.servers[id] = server
index += 1
fp.close()
def refresh(self):
for s in self.servers.values():
s.refresh()
def build_events_by_year(events, **config):
display_months_without_events = (config.get(
'display_months_without_events', True))
# archive view means time runs in reverse. of the current year in a
# other order
is_archive_view = config.get('is_archive_view', False)
now = timezone.now()
events_by_year = SortedDict()
for event in events:
year = event.start_date.year
if year not in events_by_year:
events_by_year[year] = {
'year': year,
'date': date(year, 1, 1),
'months': build_months(year=year,
is_archive_view=is_archive_view)
}
(events_by_year[year]['months'][event.start_date.month]
['events'].append(event))
flattened_events_by_year = events_by_year.values()
for year in flattened_events_by_year:
year['months'] = year['months'].values()
year['event_count'] = 0
for month in year['months']:
month['event_count'] = len(month['events'])
year['event_count'] += month['event_count']
month['has_events'] = bool(month['event_count'])
month['display_in_navigation'] = (
(not display_months_without_events and month['has_events'])
or display_months_without_events)
# if this is the current year, hide months before this month (or after
# this month if we're in archive view)
if year['year'] == now.year:
if is_archive_view:
# don't display any months after the current month
for month in year['months']:
if month['month'] > now.month:
month['display_in_navigation'] = False
else:
# don't display any months before the current month
for month in year['months']:
if month['month'] < now.month:
month['display_in_navigation'] = False
return flattened_events_by_year
class DebugToolbar(object):
def __init__(self, request):
self.request = request
self._panels = SortedDict()
base_url = self.request.META.get('SCRIPT_NAME', '')
self.config = {
'MEDIA_URL': '%s/__debug__/m/' % base_url,
}
self.config.update(CONFIG)
self.template_context = {
'BASE_URL': base_url, # for backwards compatibility
'DEBUG_TOOLBAR_MEDIA_URL': self.config['MEDIA_URL'],
'STATIC_URL': settings.STATIC_URL,
'TOOLBAR_ROOT_TAG_ATTRS': self.config['ROOT_TAG_ATTRS'],
}
self.load_panels()
self.stats = {}
def _get_panels(self):
return list(self._panels.values())
panels = property(_get_panels)
def get_panel(self, cls):
return self._panels[cls]
def load_panels(self):
"""
Populate debug panels
"""
global panel_classes
for panel_class in panel_classes:
panel_instance = panel_class(context=self.template_context)
self._panels[panel_class] = panel_instance
def render_toolbar(self):
"""
Renders the overall Toolbar with panels inside.
"""
context = self.template_context.copy()
context.update({
'panels': self.panels,
})
return render_to_string('debug_toolbar/base.html', context)
def test_init_keys(self):
"""
Initialising a SortedDict with two keys will just take the first one.
A real dict will actually take the second value so we will too, but
we'll keep the ordering from the first key found.
"""
tuples = ((2, 'two'), (1, 'one'), (2, 'second-two'))
d = SortedDict(tuples)
self.assertEqual(d.keys(), [2, 1])
real_dict = dict(tuples)
self.assertEqual(sorted(real_dict.values()), ['one', 'second-two'])
# Here the order of SortedDict values *is* what we are testing
self.assertEqual(d.values(), ['second-two', 'one'])
def download_selected_orders(self, request, orders):
response = HttpResponse(mimetype='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=%s' % self.get_download_filename(
request)
writer = CsvUnicodeWriter(response, delimiter=',')
meta_data = (
('number', _('Order number')),
('value', _('Order value')),
('date', _('Date of purchase')),
('num_items', _('Number of items')),
('status', _('Order status')),
('customer', _('Customer email address')),
('shipping_address', _('Shipping address')),
('billing_address', _('Billing address')),
)
columns = SortedDict()
for k, v in meta_data:
columns[k] = v
writer.writerow(columns.values())
for order in orders:
row = columns.copy()
row['number'] = order.number
row['value'] = order.total_incl_tax
row['date'] = format_date(order.date_placed, 'DATETIME_FORMAT')
row['num_items'] = order.num_items
row['status'] = order.status
row['customer'] = order.email
if order.shipping_address:
row['shipping_address'] = order.shipping_address
else:
row['shipping_address'] = ''
if order.billing_address:
row['billing_address'] = order.billing_address
else:
row['billing_address'] = ''
encoded_values = [
unicode(value).encode('utf8') for value in row.values()
]
writer.writerow(encoded_values)
return response
def get_querysets(self):
from django.db.models import get_app, get_apps, get_model
if not self._querysets:
app_list = SortedDict()
for label in self.app_labels:
app_label, _, model_qs = label.partition('.')
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" % app_label)
model_label, _, given_qs = model_qs.partition('.')
# this ensures that model exists and thus the eval'ed string
# (if valid) is at least a method of the model default manager.
model = get_model(app_label, model_label)
if model is None:
raise CommandError("Unknown model: %s.%s" %
(app_label, model_label))
if model == Page:
qs = []
temp_qs = eval("model._default_manager.using('%s').%s" %
(self.options.get('database'),
given_qs.partition('.')[2]))
if self.options.get('recursive'):
for page in temp_qs:
qs.extend(page.get_descendants(include_self=True))
else:
qs = temp_qs
else:
if self.options.get('use_base_manager'):
qs = eval("model._base_manager.using('%s').%s" %
(self.options.get('database'),
given_qs.partition('.')[2]))
else:
qs = eval("model._default_manager.using('%s').%s" %
(self.options.get('database'),
given_qs.partition('.')[2]))
if app in app_list.keys():
if app_list[app] and model not in app_list[app]:
app_list[app].extend(qs)
else:
app_list[app] = qs
self._querysets = app_list.values()
return self._querysets
def download_selected_invoices(self, request, invoices):
response = http.HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=%s' \
% self.get_download_filename(request)
writer = UnicodeCSVWriter(open_file=response)
meta_data = (
('number', _('Invoice number')),
('value', _('Invoice value')),
('date', _('Date of purchase')),
('order_number', _('Order number')),
('num_items', _('Number of items')),
('status', _('Invoice status')),
('customer', _('Customer email address')),
('person_name', _('Pay as juristic person')),
('person_vatin', _('Juristic person VAT number')),
('person_code', _('Juristic person code (e.g. KPP in Russia)')),
)
columns = SortedDict()
for k, v in meta_data:
columns[k] = v
writer.writerow(columns.values())
for invoice in invoices:
row = columns.copy()
row['number'] = invoice.number
row['value'] = invoice.total_incl_tax
row['date'] = format_datetime(invoice.date_created,
'DATETIME_FORMAT')
row['order_number'] = invoice.order_number
row['num_items'] = invoice.order.num_items
row['status'] = invoice.status
row['customer'] = invoice.order.email
if invoice.person:
row['person_name'] = invoice.person.name
row['person_vatin'] = invoice.person.vatin
row['person_code'] = invoice.person.reason_code
else:
row['person_name'] = '<none>'
row['person_vatin'] = '<none>'
row['person_code'] = '<none>'
writer.writerow(row.values())
return response
