def test_search(self):
self.sb.update(self.wmmi, self.sample_objs)
self.assertEqual(len(self.whoosh_search(u'*')), 23)
# No query string should always yield zero results.
self.assertEqual(self.sb.search(u''), {'hits': 0, 'results': []})
# A one letter query string gets nabbed by a stopwords filter. Should
# always yield zero results.
self.assertEqual(self.sb.search(u'a'), {'hits': 0, 'results': []})
# Possible AttributeError?
# self.assertEqual(self.sb.search(u'a b'), {'hits': 0, 'results': [], 'spelling_suggestion': '', 'facets': {}})
self.assertEqual(self.sb.search(u'*')['hits'], 23)
self.assertEqual([result.pk for result in self.sb.search(u'*')['results']], [u'%s' % i for i in range(1, 24)])
self.assertEqual(self.sb.search(u'Indexe')['hits'], 23)
self.assertEqual(self.sb.search(u'Indexe')['spelling_suggestion'], u'indexed')
self.assertEqual(self.sb.search(u'', facets=['name']), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', facets=['name'])
results = self.sb.search(u'index*', facets=['name'])
self.assertEqual(results['hits'], 23)
self.assertEqual(results['facets'], {})
self.assertEqual(self.sb.search(u'', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}}), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}})
results = self.sb.search(u'index*', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}})
self.assertEqual(results['hits'], 23)
self.assertEqual(results['facets'], {})
self.assertEqual(self.sb.search(u'', query_facets={'name': '[* TO e]'}), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', query_facets={'name': '[* TO e]'})
results = self.sb.search(u'index*', query_facets={'name': '[* TO e]'})
self.assertEqual(results['hits'], 23)
self.assertEqual(results['facets'], {})
# self.assertEqual(self.sb.search('', narrow_queries=set(['name:daniel1'])), {'hits': 0, 'results': []})
# results = self.sb.search('Index*', narrow_queries=set(['name:daniel1']))
# self.assertEqual(results['hits'], 1)
# Ensure that swapping the ``result_class`` works.
self.assertTrue(isinstance(self.sb.search(u'Index*', result_class=MockSearchResult)['results'][0], MockSearchResult))
# Check the use of ``limit_to_registered_models``.
self.assertEqual(self.sb.search(u'', limit_to_registered_models=False), {'hits': 0, 'results': []})
self.assertEqual(self.sb.search(u'*', limit_to_registered_models=False)['hits'], 23)
self.assertEqual([result.pk for result in self.sb.search(u'*', limit_to_registered_models=False)['results']], [u'%s' % i for i in range(1, 24)])
# Stow.
old_limit_to_registered_models = getattr(settings, 'HAYSTACK_LIMIT_TO_REGISTERED_MODELS', True)
settings.HAYSTACK_LIMIT_TO_REGISTERED_MODELS = False
self.assertEqual(self.sb.search(u''), {'hits': 0, 'results': []})
self.assertEqual(self.sb.search(u'*')['hits'], 23)
self.assertEqual([result.pk for result in self.sb.search(u'*')['results']], [u'%s' % i for i in range(1, 24)])
# Restore.
settings.HAYSTACK_LIMIT_TO_REGISTERED_MODELS = old_limit_to_registered_models
def test_various_searchquerysets(self):
self.sb.update(self.smmi, self.sample_objs)
sqs = self.sqs.filter(content='Index')
self.assertEqual(sqs.query.build_query(), u'Index')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!')
self.assertEqual(sqs.query.build_query(), u'Indexed\\!')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 8, 31))
self.assertEqual(sqs.query.build_query(), u'(Indexed\\! AND pub_date:[TO 2009\-08\-31T00\:00\:00])')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 23))
self.assertEqual(sqs.query.build_query(), u'(Indexed\\! AND pub_date:[TO 2009\\-02\\-23T00\\:00\\:00])')
self.assertEqual(len(sqs), 2)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 25)).filter(django_id__in=[1, 2]).exclude(name='daniel1')
self.assertEqual(sqs.query.build_query(), u'(Indexed\\! AND pub_date:[TO 2009\\-02\\-25T00\\:00\\:00] AND (django_id:"1" OR django_id:"2") AND NOT (name:daniel1))')
self.assertEqual(len(sqs), 1)
sqs = self.sqs.auto_query('re-inker')
self.assertEqual(sqs.query.build_query(), u're\\-inker')
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query('0.7 wire')
self.assertEqual(sqs.query.build_query(), u'(0\\.7 AND wire)')
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query("daler-rowney pearlescent 'bell bronze'")
self.assertEqual(sqs.query.build_query(), u'("bell bronze" AND daler\\-rowney AND pearlescent)')
self.assertEqual(len(sqs), 0)
def get_fechas(self):
now = date.today()
self.fin = date(now.year, now.month,
calendar.monthrange(now.year, now.month)[1])
self.inicio = date(now.year, now.month, 1)
self.inicio = datetime.combine(self.inicio, time.min)
self.fin = datetime.combine(self.fin, time.max)
def test_compare_datetimes(self):
self.assertEqual(original_datetime(*self.more_recent), datetime(*self.more_recent))
self.assertEqual(original_datetime(*self.really_old), datetime(*self.really_old))
self.assertEqual(original_date(*self.more_recent), date(*self.more_recent))
self.assertEqual(original_date(*self.really_old), date(*self.really_old))
self.assertEqual(original_date(*self.just_safe).strftime('%Y-%m-%d'), date(*self.just_safe).strftime('%Y-%m-%d'))
self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d'))
def setUp(self):
status_processo = StatusProcesso.objects.create(
descricao='Status do processo'
)
user = User.objects.create(
email='*****@*****.**',
first_name='',
last_name='',
)
workspace = AreaTrabalho.objects.create(
nome='Área de trabalho',
owner=user,
modifier=user,
)
contato = Contato.objects.create(
nome='Contato 1',
sexo='M',
naturalidade='Brasileiro',
nome_pai='',
nome_mae='',
# numero_sus='',
# cpf='',
# titulo_eleitor="",
# rg='',
# rg_orgao_expedidor=''
workspace=workspace,
modifier=user,
owner=user,
# profissao='',
)
bairro = Bairro.objects.create(nome='Bairro')
self.processo = Processo.objects.create(
titulo='Título do processo',
data=date(2016, 10, 10),
protocolo='10004D',
proto_cam='99.999999.9999',
proto_pref='XX999FQG9',
instituicao='Instituição',
rua='Rua',
orgao='Órgão',
bairro=bairro,
status=status_processo,
urgente=True,
data_solucao=date(2016, 10, 12),
importancia='M',
workspace=workspace,
owner=user,
modifier=user,
)
self.processo.contatos.add(contato)
def test_safe_strftime(self):
self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)')
self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)')
self.assertEqual(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)')
self.assertEqual(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)')
# %y will error before this date
self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
def test_import_single_row_without_balance(self):
account = Account(name="test", number="1234", id=1)
expected_transaction = {'account_id': 1,
'transaction_date': date(2011,03,31),
'currency_date': date(2011,03,31),
'reference': 5484535483,
'text': u'SKISTAR AB /11-03-30',
'value': -2980.00}
account.import_data("2011-03-31\t2011-03-31\t5484535483\tSKISTAR AB /11-03-30\t-2980")
self.assertQuerysetEqual(account.transaction_set.all(), [expected_transaction], transaction_to_dict)
def dispatch(self, request, *args, **kwargs):
tz = timezone.get_current_timezone()
now = timezone.now()
day = timedelta(days=1)
self.yesterday = now - day
self.today = tz.localize(datetime.combine(now, time.min))
self.fin = date(now.year, now.month,
calendar.monthrange(now.year, now.month)[1])
self.inicio = date(now.year, now.month, 1)
self.inicio = tz.localize(datetime.combine(self.inicio, time.min))
self.fin = tz.localize(datetime.combine(self.fin, time.max))
return super(ConsultorioIndexView, self).dispatch(request, *args,
**kwargs)
def convert(self, value):
if isinstance(value, basestring):
match = DATE_REGEX.search(value)
if match:
data = match.groupdict()
return datetime_safe.date(
int(data['year']), int(data['month']), int(data['day']))
else:
raise ApiFieldError(
"Date provided to '%s' field doesn't appear to be a " \
"valid date string: '%s'" % (self._field_name, value))
return datetime_safe.date(value.year, value.month, value.day)
def setUp(self):
super(WhooshSearchBackendTestCase, self).setUp()
# Stow.
temp_path = os.path.join("tmp", "test_whoosh_query")
self.old_whoosh_path = getattr(settings, "HAYSTACK_WHOOSH_PATH", temp_path)
settings.HAYSTACK_WHOOSH_PATH = temp_path
self.site = WhooshSearchSite()
self.sb = SearchBackend(site=self.site)
self.smmi = WhooshMockSearchIndex(MockModel, backend=self.sb)
self.wmtmmi = WhooshMaintainTypeMockSearchIndex(MockModel, backend=self.sb)
self.site.register(MockModel, WhooshMockSearchIndex)
# With the models registered, you get the proper bits.
import haystack
# Stow.
self.old_site = haystack.site
haystack.site = self.site
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in xrange(1, 4):
mock = MockModel()
mock.id = i
mock.author = "daniel%s" % i
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
def setUp(self):
super(WhooshBoostBackendTestCase, self).setUp()
self.old_ui = connections['whoosh'].get_unified_index()
self.ui = UnifiedIndex()
self.wmmi = WhooshBoostMockSearchIndex()
self.ui.build(indexes=[self.wmmi])
self.sb = connections['whoosh'].get_backend()
connections['whoosh']._index = self.ui
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in range(1, 5):
mock = AFourthMockModel()
mock.id = i
if i % 2:
mock.author = 'daniel'
mock.editor = 'david'
else:
mock.author = 'david'
mock.editor = 'daniel'
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
def setUp(self):
super(LiveWhooshSearchQueryTestCase, self).setUp()
# Stow.
temp_path = os.path.join('tmp', 'test_whoosh_query')
self.old_whoosh_path = getattr(settings, 'HAYSTACK_WHOOSH_PATH', temp_path)
settings.HAYSTACK_WHOOSH_PATH = temp_path
self.site = SearchSite()
self.sb = SearchBackend(site=self.site)
self.smmi = WhooshMockSearchIndex(MockModel, backend=self.sb)
self.site.register(MockModel, WhooshMockSearchIndex)
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in xrange(1, 4):
mock = MockModel()
mock.id = i
mock.author = 'daniel%s' % i
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
self.sq = SearchQuery(backend=self.sb)
def test_zero_padding(self):
"""
Regression for #12524
Pre-1000AD dates are padded with zeros if necessary
"""
self.assertEqual(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday')
def test_import_multiple_rows(self):
account = Account(name="test", number="1234", id=1)
expected_transactions = [{'account_id': 1,
'transaction_date': date(2011,03,24),
'currency_date': date(2011,03,24),
'reference': 5484478982,
'text': u'COOP NARA VA/11-03-22',
'value': Decimal("-280.22")},
{'account_id': 1,
'transaction_date': date(2011,03,25),
'currency_date': date(2011,03,25),
'reference': 5490966600,
'text': u'LÖN',
'value': Decimal("21320")},
]
def setUp(self):
super(LiveWhooshSearchQuerySetTestCase, self).setUp()
# Stow.
temp_path = os.path.join('tmp', 'test_whoosh_query')
self.old_whoosh_path = settings.HAYSTACK_CONNECTIONS['default']['PATH']
settings.HAYSTACK_CONNECTIONS['default']['PATH'] = temp_path
self.old_ui = connections['default'].get_unified_index()
self.ui = UnifiedIndex()
self.wmmi = WhooshMockSearchIndex()
self.ui.build(indexes=[self.wmmi])
self.sb = connections['default'].get_backend()
connections['default']._index = self.ui
# Stow.
self.old_debug = settings.DEBUG
settings.DEBUG = True
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in xrange(1, 4):
mock = MockModel()
mock.id = i
mock.author = 'daniel%s' % i
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
self.sq = connections['default'].get_query()
self.sqs = SearchQuerySet()
def __parse_gen_date(date_value):
if type(date_value) is not str or date_value == '':
return None, None, None, False
date_value = date_value.strip(' ')
# Parse year ranges.
finds = findall('BET. (\d{4}) - (\d{4})', date_value)
if len(finds) == 1:
year, year_range_end = map(lambda x: int(x), finds[0])
return datetime(year, 1, 1), '%Y', year_range_end, False
# Parse dates.
finds = findall('(?:(ABT) +)?(.+)', date_value)
if len(finds) != 1:
raise ValueError("Date string not understood: '" + date_value + "'")
approxQ, date_string = finds[0]
# If 'ABT' is in the date_value, it's an approximate date.
approxQ = (len(approxQ) > 0)
# Try to parse the date string.
rdate = None
for date_format in DATE_FORMATS:
try:
rdate = datetime.strptime(date_string, date_format[0])
break
except ValueError:
pass
if rdate is None:
return None, None, None, False
#raise ValueError("Could not parse date string: '" + date_value + "'")
return date(rdate.year, rdate.month, rdate.day), date_format[1], None, approxQ
def __parse_gen_date(date_value):
if type(date_value) is not str or date_value == '':
return None, None, None, False
date_value = date_value.strip(' ')
# Parse year ranges.
found = findall(r'^BET. (\d{4}) - (\d{4})$', date_value)
if found:
year, year_range_end = [int(y) for y in found[0]]
return datetime(year, 1, 1), '%Y', year_range_end, False
# Parse dates.
found = findall(r'^(?:(ABT) +)?(.+)$', date_value)
if not found:
raise ValueError("Date string not understood: '%s'" % date_value)
approxQ, date_string = found[0]
# If 'ABT' is in the date_value, it's an approximate date.
approxQ = (len(approxQ) > 0)
# Try to parse the date string.
rdate = None
for parse_format, print_format in DATE_FORMATS:
try:
rdate = datetime.strptime(date_string, parse_format)
return (
date(rdate.year, rdate.month, rdate.day),
print_format, None, approxQ
)
except ValueError:
pass
return None, None, None, False
def setUp(self):
super(WhooshBoostBackendTestCase, self).setUp()
# Stow.
temp_path = os.path.join('tmp', 'test_whoosh_query')
self.old_whoosh_path = settings.HAYSTACK_CONNECTIONS['default']['PATH']
settings.HAYSTACK_CONNECTIONS['default']['PATH'] = temp_path
self.old_ui = connections['default'].get_unified_index()
self.ui = UnifiedIndex()
self.wmmi = WhooshBoostMockSearchIndex()
self.ui.build(indexes=[self.wmmi])
self.sb = connections['default'].get_backend()
connections['default']._index = self.ui
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in xrange(1, 5):
mock = AFourthMockModel()
mock.id = i
if i % 2:
mock.author = 'daniel'
mock.editor = 'david'
else:
mock.author = 'david'
mock.editor = 'daniel'
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
def setUp(self):
super(LiveWhooshSearchQuerySetTestCase, self).setUp()
# Stow.
self.old_ui = connections['whoosh'].get_unified_index()
self.ui = UnifiedIndex()
self.wmmi = WhooshMockSearchIndex()
self.ui.build(indexes=[self.wmmi])
self.sb = connections['whoosh'].get_backend()
connections['whoosh']._index = self.ui
self.sb.setup()
self.raw_whoosh = self.sb.index
self.parser = QueryParser(self.sb.content_field_name, schema=self.sb.schema)
self.sb.delete_index()
self.sample_objs = []
for i in range(1, 4):
mock = MockModel()
mock.id = i
mock.author = 'daniel%s' % i
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
self.sample_objs.append(mock)
self.sq = connections['whoosh'].get_query()
self.sqs = SearchQuerySet('whoosh')
def afegeixGuardia(request, dia=None, mes=None, year=None):
credentials = getImpersonateUser(request)
(user, _ ) = credentials
head=u'Fer guardia'
url_next = '/presencia/mostraImpartir/%d/%d/%d/'% (
int(year),
int(mes),
int(dia ) )
if request.method == 'POST':
form = afegeixGuardiaForm(request.POST)
if form.is_valid():
professor = form.cleaned_data['professor']
franges = form.cleaned_data['franges']
dia_impartir = date( int(year), int(mes), int(dia) )
professor_guardia = User2Professor( user )
Impartir.objects.filter( dia_impartir = dia_impartir,
horari__professor = professor,
horari__hora__in = franges
).update( professor_guardia = professor_guardia )
return HttpResponseRedirect( url_next )
else:
form = afegeixGuardiaForm()
return render_to_response(
'form.html',
{'form': form,
'head': head},
context_instance=RequestContext(request))
def complementFormulariOmple( request, pk_professor, dia, mes, year ):
credentials = tools.getImpersonateUser(request)
(user, _ ) = credentials
professor = User2Professor( user )
data = date( int(year), int(mes), int(dia) )
head = u"Feina professor absent {0} {1}".format( professor, data )
imparticions = Impartir.objects.filter( dia_impartir = data, horari__professor__pk = pk_professor )
formsetFac = modelformset_factory(model = Feina, extra=0, can_delete=False,
fields=('professor_fa_guardia','feina_a_fer','comentaris_per_al_professor_guardia',))
if request.method == "POST":
formset = formsetFac( request.POST, queryset=Feina.objects.filter( impartir__in = imparticions ) )
if formset.is_valid():
formset.save()
for form in formset:
if (form.instance.professor_fa_guardia):
form.instance.impartir.professor_guardia = form.instance.professor_fa_guardia
form.instance.impartir.save()
return HttpResponseRedirect( r'/' )
else:
#crear els que no existeixin:
for i in imparticions:
feina, _ = Feina.objects.get_or_create( impartir = i ,
defaults = {'professor_darrera_modificacio':professor, } )
if bool( i.professor_guardia ):
feina.professor_fa_guardia = i.professor_guardia
feina.save()
formset = formsetFac( queryset=Feina.objects.filter( impartir__in = imparticions ) )
for form in formset:
instance = form.instance
form.formSetDelimited = True
guardies = Impartir.objects.filter(
horari__assignatura__nom_assignatura = 'G',
horari__hora = instance.impartir.horari.hora,
dia_impartir = instance.impartir.dia_impartir
).distinct()
form.infoForm = (
( u'Hora', instance.impartir.horari.hora),
( u'Assignatura', instance.impartir.horari.assignatura),
( u'Grup', instance.impartir.horari.grup),
( u'Aula', instance.impartir.horari.nom_aula),
( u'Professors de Guardia', u', '.join( [ unicode(p) for p in Professor.objects.filter( horari__impartir__in = guardies ).distinct() ] ) )
)
return render_to_response(
'formset.html',
{'formset': formset,
'head': head},
context_instance=RequestContext(request))
def test_StrictDateField_update_via_queryset_invalid_then_get():
"""
So for whatever reason, by the time this gets to the FieldCleaningDescriptor
the 'blep' has been converted into True ... fun.
"""
model = DateFieldModel.objects.create(field=date.today())
model.__class__.objects.filter(pk=model.pk).update(field='2000-01-01')
assert model.__class__.objects.get(pk=model.pk).field == date(2000, 1, 1)
def date_string(self):
if self.date is None:
return ''
elif self.year_range_end:
return 'between %d and %d' % (self.date.year, self.year_range_end)
elif self.date_format:
new_date = date(self.date.year, self.date.month, self.date.day)
return new_date.strftime(self.date_format)
def test_serialize_datetime_safe(self):
self.assertSerializedResultEqual(
datetime_safe.date(2014, 3, 31), ("datetime.date(2014, 3, 31)", {"import datetime"})
)
self.assertSerializedResultEqual(datetime_safe.time(10, 25), ("datetime.time(10, 25)", {"import datetime"}))
self.assertSerializedResultEqual(
datetime_safe.datetime(2014, 3, 31, 16, 4, 31),
("datetime.datetime(2014, 3, 31, 16, 4, 31)", {"import datetime"}),
)
def test_StrictDateField_descriptor_doesnt_disappear():
"""
don't clobber the descriptor
"""
today = date.today()
value = DateFieldModel(field=today)
assert value.field == today
value.field = '2015-04-16'
assert value.field == date(2015, 4, 16)
with pytest.raises(ValidationError):
value.field = 'v'*256
assert value.field == date(2015, 4, 16)
value.field = today
assert value.field == today
with pytest.raises(TypeError):
value.field = -1
with pytest.raises(ValidationError):
value.field = '-1'
def for_year(cls, year):
from timetables.utils.datetimes import termweek_to_date
if not year in TERM_STARTS:
raise ValueError("Unknown year: %s. Expected one of: %s" %
(year, TERM_STARTS.keys()))
start_boundary = date(year, YEAR_BOUNDARIES["START"]["MONTH"],
YEAR_BOUNDARIES["START"]["DAY"])
end_boundary = date(year + 1, YEAR_BOUNDARIES["END"]["MONTH"],
YEAR_BOUNDARIES["END"]["DAY"])
terms = []
for term_name in TERMS:
start_date = termweek_to_date(year, term_name, 1, TERM_START_DAY)
terms.append(Term(term_name, start_date))
return cls(year, start_boundary, end_boundary, terms)
def test_import_one(self):
dataset = tablib.Dataset(["15/6/2016", "5.10", "Example payment"],
headers=["date", "amount", "description"])
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 1)
obj = StatementLine.objects.get()
self.assertEqual(obj.date, date(2016, 6, 15))
self.assertEqual(obj.amount, Decimal("5.10"))
self.assertEqual(obj.description, "Example payment")
def test_import_one(self):
dataset = tablib.Dataset(['15/6/2016', '5.10', 'Example payment'],
headers=['date', 'amount', 'description'])
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 1)
obj = StatementLine.objects.get()
self.assertEqual(obj.date, date(2016, 6, 15))
self.assertEqual(obj.amount, Decimal('5.10'))
self.assertEqual(obj.description, 'Example payment')
def generate_category_statistics():
"""
Generate statistics about events, number of events per category
:return: Dict with key, value resp. being category, event count.
"""
year = datetime_to_lectureyear(timezone.now())
data = {}
for i in range(5):
year_start = date(year=year - i, month=9, day=1)
year_end = date(year=year - i + 1, month=9, day=1)
data[str(year - i)] = {
str(display): Event.objects.filter(
category=key, start__gte=year_start, end__lte=year_end
).count()
for key, display in Event.EVENT_CATEGORIES
}
return data
def test_search(self):
self.sb.update(self.smmi, self.sample_objs)
self.assertEqual(len(self.whoosh_search(u'*')), 3)
# No query string should always yield zero results.
self.assertEqual(self.sb.search(u''), {'hits': 0, 'results': []})
# A one letter query string gets nabbed by a stopwords filter. Should
# always yield zero results.
self.assertEqual(self.sb.search(u'a'), {'hits': 0, 'results': []})
# Possible AttributeError?
self.assertEqual(self.sb.search(u'a b'), {'hits': 0, 'results': [], 'spelling_suggestion': '', 'facets': {}})
self.assertEqual(self.sb.search(u'*')['hits'], 3)
self.assertEqual([result.pk for result in self.sb.search(u'*')['results']], [u'3', u'2', u'1'])
self.assertEqual(self.sb.search(u'', highlight=True), {'hits': 0, 'results': []})
self.assertEqual(self.sb.search(u'index*', highlight=True)['hits'], 3)
# DRL_FIXME: Uncomment once highlighting works.
# self.assertEqual([result.highlighted['text'][0] for result in self.sb.search('Index*', highlight=True)['results']], ['<em>Indexed</em>!\n3', '<em>Indexed</em>!\n2', '<em>Indexed</em>!\n1'])
self.assertEqual(self.sb.search(u'Indx')['hits'], 0)
self.assertEqual(self.sb.search(u'Indx')['spelling_suggestion'], u'index')
self.assertEqual(self.sb.search(u'', facets=['name']), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', facets=['name'])
results = self.sb.search(u'index*', facets=['name'])
self.assertEqual(results['hits'], 3)
self.assertEqual(results['facets'], {})
self.assertEqual(self.sb.search(u'', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}}), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}})
results = self.sb.search(u'index*', date_facets={'pub_date': {'start_date': date(2008, 2, 26), 'end_date': date(2008, 2, 26), 'gap': '/MONTH'}})
self.assertEqual(results['hits'], 3)
self.assertEqual(results['facets'], {})
self.assertEqual(self.sb.search(u'', query_facets={'name': '[* TO e]'}), {'hits': 0, 'results': []})
results = self.sb.search(u'Index*', query_facets={'name': '[* TO e]'})
results = self.sb.search(u'index*', query_facets={'name': '[* TO e]'})
self.assertEqual(results['hits'], 3)
self.assertEqual(results['facets'], {})
def test_compare_datetimes(self):
self.assertEqual(original_datetime(*self.more_recent),
datetime(*self.more_recent))
self.assertEqual(original_datetime(*self.really_old),
datetime(*self.really_old))
self.assertEqual(original_date(*self.more_recent),
date(*self.more_recent))
self.assertEqual(original_date(*self.really_old),
date(*self.really_old))
self.assertEqual(
original_date(*self.just_safe).strftime('%Y-%m-%d'),
date(*self.just_safe).strftime('%Y-%m-%d'))
self.assertEqual(
original_datetime(*self.just_safe).strftime('%Y-%m-%d'),
datetime(*self.just_safe).strftime('%Y-%m-%d'))
self.assertEqual(
original_time(*self.just_time).strftime('%H:%M:%S'),
time(*self.just_time).strftime('%H:%M:%S'))
def test_safe_strftime(self):
self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '0999-12-31 (weekday 2)')
self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1000-01-01 (weekday 3)')
self.assertEqual(
datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '0999-12-31 23:59:59 (weekday 2)'
)
self.assertEqual(
datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1000-01-01 00:00:00 (weekday 3)'
)
self.assertEqual(time(*self.just_time).strftime('%H:%M:%S AM'), '11:30:59 AM')
# %y will error before this date
self.assertEqual(date(*self.percent_y_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.percent_y_safe).strftime('%y'), '00')
with self.assertRaisesMessage(TypeError, 'strftime of dates before 1000 does not handle %y'):
datetime(*self.just_unsafe).strftime('%y')
self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
class GetLikeAnalyticsSelectorTest(TestCase):
date_from = date(2021, 1, 1)
date_to = date(2021, 1, 5)
def setUp(self) -> None:
start_date = self.date_from
end_date = self.date_to
delta = timedelta(days=1)
while start_date <= end_date:
res = LikeFactory.create_batch(5, kind=True)
res += LikeFactory.create_batch(2, kind=False)
Like.objects.filter(id__in=[like.id for like in res]).update(created_at=start_date)
start_date += delta
def test_get_like_analytics_selector(self):
analytics_list = list(get_like_analytics(date_from=self.date_from, date_to=self.date_to))
self.assertEqual(len(analytics_list), 5)
for day in analytics_list:
self.assertEqual(day['likes'], 5)
self.assertEqual(day['dislikes'], 2)
def test_import_a_few(self):
dataset = tablib.Dataset(['15/6/2016', '5.10', 'Example payment'],
['16/6/2016', '10.91', 'Another payment'],
['17/6/2016', '-1.23', 'Paying someone'],
headers=['date', 'amount', 'description'])
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 3)
objs = StatementLine.objects.all().order_by('pk')
self.assertEqual(objs[0].date, date(2016, 6, 15))
self.assertEqual(objs[0].amount, Decimal('5.10'))
self.assertEqual(objs[0].description, 'Example payment')
self.assertEqual(objs[1].date, date(2016, 6, 16))
self.assertEqual(objs[1].amount, Decimal('10.91'))
self.assertEqual(objs[1].description, 'Another payment')
self.assertEqual(objs[2].date, date(2016, 6, 17))
self.assertEqual(objs[2].amount, Decimal('-1.23'))
self.assertEqual(objs[2].description, 'Paying someone')
def passaLlistaGrupData(request, grup, dia, mes, year):
credentials = getImpersonateUser(request)
(user, l4) = credentials
data = date( year = int(year), month = int(mes), day = int(dia) )
controls = ( ControlAssistencia.objects
.filter( alumne__grup = grup, impartir__dia_impartir = data )
.order_by( 'alumne', 'impartir__horari__hora__hora_inici' )
)
pendents = controls.filter( estat__isnull = True )
frmFact = modelformset_factory(
ControlAssistencia,
extra = 0,
fields = ( 'estat', ) ,
#widgets={'estat': RadioSelect( attrs={'class':'presenciaEstat'} ), }
)
if request.method == "POST":
formSet = frmFact( request.POST , queryset = controls )
for f in formSet.forms:
f.instance.credentials = credentials
if formSet.is_valid():
formSet.save()
return HttpResponseRedirect( '/' )
else:
formSet = frmFact( queryset = controls )
if bool(formSet.forms):
f_prev = formSet.forms[0]
for f in formSet:
f.fields['estat'].widget = RadioSelect(
choices = [x for x in f.fields['estat'].choices][1:],
attrs={'class':'presenciaEstat'},
)
f.fields['estat'].label = u'{0} {1}'.format( f.instance.alumne, f.instance.impartir.horari.hora )
if f.instance.alumne != f_prev.instance.alumne:
f_prev = f
f.formSetDelimited = True
return render_to_response(
"passaLlistaGrup.html",
{"formset": formSet,
"head": u"Passa llista a grup",
'pendents': pendents,
},
context_instance=RequestContext(request))
def convert(self, value):
if value is None:
return None
if isinstance(value, six.string_types):
try:
year, month, day = value[:10].split('-')
return datetime_safe.date(int(year), int(month), int(day))
except ValueError:
raise ApiFieldError("Date provided to '%s' field doesn't appear to be a valid date string: '%s'" % (self.instance_name, value))
return value
def queryset(self, request, queryset):
"""Query set to get actually used months"""
value = self.value()
if value is None:
return queryset
try:
start_month, start_year = map(int, value.split("-"))
except ValueError:
return queryset
if duration_unit == "month":
if start_month == 12:
end_month, end_year = 1, start_year + 1
else:
end_month, end_year = start_month + 1, start_year
return queryset.filter(date__gte=date(start_year, start_month,
1),
date__lt=date(end_year, end_month, 1))
return queryset
def get(self, request, **kwargs):
if not request.user.is_authenticated:
return redirect('permission_denied')
d = date(int(kwargs.get('year')), int(kwargs.get('month')),
int(kwargs.get('day')))
daily_attendance = get_object_or_404(DailyAttendance, date=d)
attendance_dict = create_daily_attendance_dict(daily_attendance)
# attendance_dict = { "1st year": { user: [present, s_time, e_time], } }
context = {'attendance_dict': attendance_dict, 'head': d}
return render(request, self.template_name, context)
def convert(self, value):
if value is None:
return None
if isinstance(value, six.string_types):
try:
year, month, day = value[:10].split('-')
return datetime_safe.date(int(year), int(month), int(day))
except ValueError:
raise ApiFieldError("Date provided to '%s' field doesn't appear to be a valid date string: '%s'" % (self.instance_name, value))
return value
def test_split_amounts(self):
dataset = tablib.Dataset(
['15/6/2016', '', '100.56', 'Example payment'],
['16/6/2016', '60.31', '', 'Example income'],
['17/6/2016', '', '-102.56', 'Example payment 2'],
headers=['date', 'amount_in', 'amount_out', 'description'])
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 3)
obj = StatementLine.objects.all().order_by('date')
self.assertEqual(obj[0].date, date(2016, 6, 15))
self.assertEqual(obj[0].amount, Decimal('-100.56'))
self.assertEqual(obj[0].description, 'Example payment')
self.assertEqual(obj[1].date, date(2016, 6, 16))
self.assertEqual(obj[1].amount, Decimal('60.31'))
self.assertEqual(obj[1].description, 'Example income')
self.assertEqual(obj[2].date, date(2016, 6, 17))
self.assertEqual(obj[2].amount, Decimal('-102.56'))
self.assertEqual(obj[2].description, 'Example payment 2')
def test_serialize_datetime_safe(self):
self.assertSerializedResultEqual(
datetime_safe.date(2014, 3, 31),
("datetime.date(2014, 3, 31)", {'import datetime'})
)
self.assertSerializedResultEqual(
datetime_safe.time(10, 25),
("datetime.time(10, 25)", {'import datetime'})
)
self.assertSerializedResultEqual(
datetime_safe.datetime(2014, 3, 31, 16, 4, 31),
("datetime.datetime(2014, 3, 31, 16, 4, 31)", {'import datetime'})
)
def passaLlistaGrupData(request, grup, dia, mes, year):
credentials = getImpersonateUser(request)
(user, l4) = credentials
data = date(year=int(year), month=int(mes), day=int(dia))
controls = (ControlAssistencia.objects.filter(
alumne__grup=grup, impartir__dia_impartir=data).order_by(
'alumne', 'impartir__horari__hora__hora_inici'))
pendents = controls.filter(estat__isnull=True)
frmFact = modelformset_factory(
ControlAssistencia,
extra=0,
fields=('estat', ),
#widgets={'estat': RadioSelect( attrs={'class':'presenciaEstat'} ), }
)
if request.method == "POST":
formSet = frmFact(request.POST, queryset=controls)
for f in formSet.forms:
f.instance.credentials = credentials
if formSet.is_valid():
formSet.save()
return HttpResponseRedirect('/')
else:
formSet = frmFact(queryset=controls)
if bool(formSet.forms):
f_prev = formSet.forms[0]
for f in formSet:
f.fields['estat'].widget = RadioSelect(
choices=[x for x in f.fields['estat'].choices][1:],
attrs={'class': 'presenciaEstat'},
)
f.fields['estat'].label = u'{0} {1}'.format(
f.instance.alumne, f.instance.impartir.horari.hora)
if f.instance.alumne != f_prev.instance.alumne:
f_prev = f
f.formSetDelimited = True
return render_to_response("passaLlistaGrup.html", {
"formset": formSet,
"head": u"Passa llista a grup",
'pendents': pendents,
},
context_instance=RequestContext(request))
def test_various_searchquerysets(self):
self.sb.update(self.wmmi, self.sample_objs)
sqs = self.sqs.filter(content='Index')
self.assertEqual(sqs.query.build_query(), u'(Index)')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!')
self.assertEqual(sqs.query.build_query(), u"('Indexed!')")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 8, 31))
self.assertEqual(sqs.query.build_query(), u"(('Indexed!') AND pub_date:([to 20090831000000]))")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 23))
self.assertEqual(sqs.query.build_query(), u"(('Indexed!') AND pub_date:([to 20090223000000]))")
self.assertEqual(len(sqs), 2)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 25)).filter(django_id__in=[1, 2]).exclude(name='daniel1')
self.assertEqual(sqs.query.build_query(), u'((\'Indexed!\') AND pub_date:([to 20090225000000]) AND django_id:(1 OR 2) AND NOT (name:(daniel1)))')
self.assertEqual(len(sqs), 1)
sqs = self.sqs.auto_query('re-inker')
self.assertEqual(sqs.query.build_query(), u"('re-inker')")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query('0.7 wire')
self.assertEqual(sqs.query.build_query(), u"('0.7' wire)")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query("daler-rowney pearlescent 'bell bronze'")
self.assertEqual(sqs.query.build_query(), u"('daler-rowney' pearlescent 'bell bronze')")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.models(MockModel)
self.assertEqual(sqs.query.build_query(), u'*')
self.assertEqual(len(sqs), 3)
def test_various_searchquerysets(self):
self.sb.update(self.smmi, self.sample_objs)
sqs = self.sqs.filter(content='Index')
self.assertEqual(sqs.query.build_query(), u'Index')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!')
self.assertEqual(sqs.query.build_query(), u"'Indexed!'")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 8, 31))
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[to 20090831000000])")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 23))
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[to 20090223000000])")
self.assertEqual(len(sqs), 2)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 25)).filter(django_id__in=[1, 2]).exclude(name='daniel1')
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[to 20090225000000] AND (django_id:\"1\" OR django_id:\"2\") AND NOT (name:daniel1))")
self.assertEqual(len(sqs), 1)
sqs = self.sqs.auto_query('re-inker')
self.assertEqual(sqs.query.build_query(), u"'re-inker'")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query('0.7 wire')
self.assertEqual(sqs.query.build_query(), u"('0.7' AND wire)")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query("daler-rowney pearlescent 'bell bronze'")
self.assertEqual(sqs.query.build_query(), u"('daler-rowney' AND pearlescent AND 'bell AND bronze')")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.models(MockModel)
self.assertEqual(sqs.query.build_query(), u'django_ct:core.mockmodel')
self.assertEqual(len(sqs), 3)
def test_various_searchquerysets(self):
self.sb.update(self.smmi, self.sample_objs)
sqs = self.sqs.filter(content='Index')
self.assertEqual(sqs.query.build_query(), u'Index')
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!')
self.assertEqual(sqs.query.build_query(), u"'Indexed!'")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 8, 31))
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[TO 20090831T000000])")
self.assertEqual(len(sqs), 3)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 23))
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[TO 20090223T000000])")
self.assertEqual(len(sqs), 2)
sqs = self.sqs.auto_query('Indexed!').filter(pub_date__lte=date(2009, 2, 25)).filter(django_id__in=[1, 2]).exclude(name='daniel1')
self.assertEqual(sqs.query.build_query(), u"('Indexed!' AND pub_date:[TO 20090225T000000] AND (django_id:\"1\" OR django_id:\"2\") AND NOT (name:daniel1))")
self.assertEqual(len(sqs), 1)
sqs = self.sqs.auto_query('re-inker')
self.assertEqual(sqs.query.build_query(), u"'re-inker'")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query('0.7 wire')
self.assertEqual(sqs.query.build_query(), u"('0.7' AND wire)")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.auto_query("daler-rowney pearlescent 'bell bronze'")
self.assertEqual(sqs.query.build_query(), u"('daler-rowney' AND pearlescent AND 'bell AND bronze')")
self.assertEqual(len(sqs), 0)
sqs = self.sqs.models(MockModel)
self.assertEqual(sqs.query.build_query(), u'django_ct:core.mockmodel')
self.assertEqual(len(sqs), 3)
def test_import_a_few(self):
dataset = tablib.Dataset(
["15/6/2016", "5.10", "Example payment"],
["16/6/2016", "10.91", "Another payment"],
["17/6/2016", "-1.23", "Paying someone"],
headers=["date", "amount", "description"],
)
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 3)
objs = StatementLine.objects.all().order_by("pk")
self.assertEqual(objs[0].date, date(2016, 6, 15))
self.assertEqual(objs[0].amount, Decimal("5.10"))
self.assertEqual(objs[0].description, "Example payment")
self.assertEqual(objs[1].date, date(2016, 6, 16))
self.assertEqual(objs[1].amount, Decimal("10.91"))
self.assertEqual(objs[1].description, "Another payment")
self.assertEqual(objs[2].date, date(2016, 6, 17))
self.assertEqual(objs[2].amount, Decimal("-1.23"))
self.assertEqual(objs[2].description, "Paying someone")
def test_split_amounts(self):
dataset = tablib.Dataset(
["15/6/2016", "", "100.56", "Example payment"],
["16/6/2016", "60.31", "", "Example income"],
["17/6/2016", "", "-102.56", "Example payment 2"],
headers=["date", "amount_in", "amount_out", "description"],
)
self.makeResource().import_data(dataset)
self.assertEqual(StatementLine.objects.count(), 3)
obj = StatementLine.objects.all().order_by("date")
self.assertEqual(obj[0].date, date(2016, 6, 15))
self.assertEqual(obj[0].amount, Decimal("-100.56"))
self.assertEqual(obj[0].description, "Example payment")
self.assertEqual(obj[1].date, date(2016, 6, 16))
self.assertEqual(obj[1].amount, Decimal("60.31"))
self.assertEqual(obj[1].description, "Example income")
self.assertEqual(obj[2].date, date(2016, 6, 17))
self.assertEqual(obj[2].amount, Decimal("-102.56"))
self.assertEqual(obj[2].description, "Example payment 2")
def convert(self, value):
if value is None:
return None
if isinstance(value, basestring):
match = DATETIME_REGEX.search(value)
if match:
data = match.groupdict()
return datetime_safe.date(int(data['year']), int(data['month']), int(data['day']))
else:
raise SearchFieldError("Date provided to '%s' field doesn't appear to be a valid date string: '%s'" % (self.instance_name, value))
return value
def get_date(s):
"""Returns date object from string."""
if s.find(".") != -1:
# DD.MM.YYYY(.) format
args = s.split(".")
if args[len(args) - 1] == "":
args.pop()
args.reverse()
else:
# YYYY-MM-DD format
args = s.split("-")
args = list(map(int, args))
return datetime_safe.date(args[0], args[1], args[2])
def test_expected_values(self):
expectations = [
((datetime.date(2012, 10, 4), ), (2012, "michaelmas", 1, "thu")),
((datetime.date(2012, 10, 5), ), (2012, "michaelmas", 1, "fri")),
((datetime.date(2012, 9, 27), ), (2012, "michaelmas", 0, "thu")),
((datetime.date(2012, 10, 3), ), (2012, "michaelmas", 0, "wed")),
((datetime.date(2012, 9, 26), ), (2012, "michaelmas", -1, "wed")),
((datetime.date(2012, 9, 19), ), (2012, "michaelmas", -2, "wed")),
((datetime.date(2012, 9, 18), ), (2012, "michaelmas", -2, "tue")),
((datetime.date(2012, 9, 20), ), (2012, "michaelmas", -1, "thu")),
]
for args, expected in expectations:
actual = datetimes.date_to_termweek(*args)
self.assertEqual(
expected, actual, "expected: %s, actual: %s, "
"args: %s" % (expected, actual, args))
def prepare(self, obj):
prepped = super(WhooshRoundTripSearchIndex, self).prepare(obj)
prepped.update({
'text': 'This is some example text.',
'name': 'Mister Pants',
'is_active': True,
'post_count': 25,
'average_rating': 3.6,
'pub_date': date(2009, 11, 21),
'created': datetime(2009, 11, 21, 21, 31, 00),
'tags': ['staff', 'outdoor', 'activist', 'scientist'],
'sites': [3, 5, 1],
'empty_list': [],
})
return prepped
def post(self, request, *args, **kwargs):
data = request.POST
current_date = datetime.strptime(data['date'], '%Y-%m-%d').date()
month = date(current_date.year, current_date.month, 1)
present = bool(data['present'])
student = Student.objects.get(pk=data['pk'])
journal = MonthJournal.objects.get_or_create(student=student,
date=month)[0]
setattr(journal, 'present_day{0}'.format(current_date.day), present)
journal.save()
return JsonResponse({'status': 'success'})
def test_safe_strftime(self):
self.assertEqual(
date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'),
'1899-12-31 (weekday 0)')
self.assertEqual(
date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'),
'1900-01-01 (weekday 1)')
self.assertEqual(
datetime(
*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'1899-12-31 23:59:59 (weekday 0)')
self.assertEqual(
datetime(
*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'1900-01-01 00:00:00 (weekday 1)')
# %y will error before this date
self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
self.assertEqual(
date(1850, 8, 2).strftime("%Y/%m/%d was a %A"),
'1850/08/02 was a Friday')
def prepare(self, obj):
prepped = super().prepare(obj)
prepped.update(
{
"text": "This is some example text.",
"name": "Mister Pants",
"is_active": True,
"post_count": 25,
"average_rating": 3.6,
"price": Decimal("24.99"),
"pub_date": date(2009, 11, 21),
"created": datetime(2009, 11, 21, 21, 31, 00),
"tags": ["staff", "outdoor", "activist", "scientist"],
"sites": [3, 5, 1],
"empty_list": [],
}
)
return prepped
def test_count(self):
more_samples = []
for i in xrange(1, 50):
mock = MockModel()
mock.id = i
mock.author = 'daniel%s' % i
mock.pub_date = date(2009, 2, 25) - timedelta(days=i)
more_samples.append(mock)
self.sb.update(self.smmi, more_samples)
backends.reset_search_queries()
self.assertEqual(len(backends.queries), 0)
results = self.sqs.all()
self.assertEqual(len(results), 49)
self.assertEqual(results._cache_is_full(), False)
self.assertEqual(len(backends.queries), 1)
def test_expected_values(self):
expectations = [
((2012, "michaelmas", 0, "thu"), datetime.date(2012, 9, 27)),
((2012, "michaelmas", 1, "thu"), datetime.date(2012, 10, 4)),
((2012, "michaelmas", 1, "fri"), datetime.date(2012, 10, 5)),
((2012, "michaelmas", 1, "wed"), datetime.date(2012, 10, 10)),
((2012, "michaelmas", 2, "thu"), datetime.date(2012, 10, 11)),
((2012, "michaelmas", 2, "mon"), datetime.date(2012, 10, 15)),
((2012, "michaelmas", -1, "tue"), datetime.date(2012, 9, 25)),
]
for args, expected in expectations:
actual = datetimes.termweek_to_date(*args)
self.assertEqual(
expected, actual, "expected: %s, actual: %s, "
"args: %s" % (expected, actual, args))
def _parse_date_facets(self, facet_items):
'''
Parse date faceted fields like:
{'departure_dates': {'2010-04-24T18:17:03Z': 105,
'2010-05-01T00:00:00Z': 323,
'2010-06-01T00:00:00Z': 334,
'2010-07-01T00:00:00Z': 468,
'2010-08-01T00:00:00Z': 504,
'2010-09-01T00:00:00Z': 515,
'2010-10-01T00:00:00Z': 519,
'2010-11-01T00:00:00Z': 478,
'2010-12-01T00:00:00Z': 457,
'2011-01-01T00:00:00Z': 370,
'2011-02-01T00:00:00Z': 357,
'2011-03-01T00:00:00Z': 370,
'2011-04-01T00:00:00Z': 359,
'end': '2011-05-01T00:00:00Z',
'gap': '+1MONTH/MONTH'}}
'''
facets = []
for field, date_counts in facet_items.iteritems():
facet = Facet(field=field, label=field.replace('_', ' ').title())
gap = date_counts['gap']
for date_string, count in date_counts.iteritems():
match = DATETIME_REGEX.search(date_string)
if not match: continue
data = match.groupdict()
date = datetime_safe.date(int(data['year']),
int(data['month']), int(data['day']))
item = FacetItem(date, count)
if gap == '+1MONTH/MONTH':
item.label = date.strftime("%B")
item.value = date.strftime("%Y-%m")
elif gap == '+1YEAR/YEAR':
item.label = date.strftime("%Y")
item.value = date.strftime("%Y-01")
item.is_selected = self._is_selected_facet(
field, check_parse_date(item.value))
item.facet = facet
facet.items.append(item)
facet.items.sort(key=lambda x: x.value)
facets.append(facet)
return facets
def formatday(self, day, weekday):
if day != 0:
cssclass = self.cssclasses[weekday]
day_date = date(self.year, self.month, day)
if date.today() == day_date:
cssclass += ' today'
if day_date in self.counts:
cssclass += ' filled'
body = ['<ul>']
for item in self.counts[day_date]:
body.append('<li>')
body.append(str(item['dcount']))
body.append('</li>')
body.append('</ul>')
return self.day_cell(
cssclass,
'<span class="day">%d</span> %s' % (day, ''.join(body)))
return self.day_cell(cssclass, '<span class="day">%d</span>' % day)
return self.day_cell('noday', ' ')
def setUp(self):
# First let's setup our accounts
# Create standard chart of accounts
swiftwind_create_accounts.Command().handle(currency='GBP')
# Create some billing cycles
BillingCycle._populate(as_of=date(2000, 1, 1))
self.billing_cycle_1 = BillingCycle.objects.all()[0]
self.billing_cycle_2 = BillingCycle.objects.all()[1]
# Pull out some accounts we'll want
self.bank = Account.objects.get(name='Bank') # Asset
self.food = Account.objects.get(name='Food') # Expense
self.gas_expense = Account.objects.get(name='Gas Expense') # Expense
self.gas_payable = Account.objects.get(name='Gas Payable') # Liability
self.housemate_account_1 = self.housemate(account_kwargs=dict(
currencies=['GBP'])).account # Income account
self.housemate_account_2 = self.housemate(account_kwargs=dict(
currencies=['GBP'])).account # Income account
self.housemate_account_3 = self.housemate(account_kwargs=dict(
currencies=['GBP'])).account # Income account
# Recurring cost for food
self.food_recurring_cost = RecurringCost.objects.create(
to_account=self.food,
type=RecurringCost.TYPES.
arrears_balance, # Pay the previous month's balance
initial_billing_cycle=self.billing_cycle_1,
)
self.create_splits(self.food_recurring_cost)
# Recurring cost for gas
self.gas_recurring_cost = RecurringCost.objects.create(
to_account=self.gas_payable,
fixed_amount=150,
type=RecurringCost.TYPES.normal,
initial_billing_cycle=self.billing_cycle_1,
)
self.create_splits(self.gas_recurring_cost)
