class Charge(models.Model):
invoice_number = models.CharField(primary_key=True, max_length=32)
date = models.DateField(default=datetime.today() - timedelta(days=1))
due_date = models.DateField(default=datetime.today() + timedelta(days=30))
customer = models.ForeignKey(AccountReceivable)
charge = models.DecimalField(max_digits=7, decimal_places=2)
note = models.CharField(max_length=128, blank=True)
def save(self, *args, **kwargs):
ar_obj = AccountReceivable.objects.get(id=self.customer.id)
try:
charge_obj = Charge.objects.filter(
customer=self.customer.id).order_by('due_date')[0]
ar_obj.due_date = charge_obj.due_date
except IndexError:
print "Please add more charges!"
ar_obj.current_balance += self.charge
ar_obj.save()
super(Charge, self).save(*args, **kwargs)
class Meta:
ordering = ['date', 'customer']
def __str__(self):
return "Charge #{}".format(self.invoice_number)
class FilterHistoryForm(AccountMixin, CategoryMixin, forms.Form):
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request')
super(FilterHistoryForm, self).__init__(*args, **kwargs)
self.fields['account'].queryset = BankAccount.objects.filter(
owner=self.request.user)
self.fields['category'].queryset = Category.objects.filter(
owner=self.request.user)
years = [year for year in range(1985, datetime.today().year + 1)][::-1]
day = datetime.today() - relativedelta(days=1)
week = datetime.today() - relativedelta(weeks=1)
month = datetime.today() - relativedelta(months=1)
year = datetime.today() - relativedelta(years=1)
time_periods = (
(None, ' '),
(day, _('Day')),
(week, _('Week')),
(month, _('Month')),
(year, _('Year')),
)
time_period = forms.ChoiceField(choices=time_periods,
initial=time_periods[0],
required=False,
label=_("Time period"))
date_from = forms.DateField(widget=forms.SelectDateWidget(years=years),
required=False,
label=_("From"))
date_to = forms.DateField(widget=forms.SelectDateWidget(years=years),
required=False,
label=_("To"))
keywords = forms.CharField(required=False, label=_("Keywords"))
account = forms.ModelChoiceField(queryset=None,
required=False,
label=_("Account"))
def resource_with_id_and_filename(filename, dataset, obj_id):
from mcod.resources.models import Resource
full_filename = prepare_file(filename)
with open(full_filename, 'rb') as outfile:
if is_enabled('S40_new_file_model.be'):
res = Resource.objects.create(
id=obj_id,
title='Local file resource',
description='Resource with file',
dataset=dataset,
data_date=datetime.today(),
status='published'
)
ResourceFileFactory.create(
resource_id=res.pk,
file=File(outfile),
)
else:
Resource.objects.create(
id=obj_id,
title='Local file resource',
description='Resource with file',
file=File(outfile),
dataset=dataset,
data_date=datetime.today(),
status='published'
)
def ajaxEditGraf(request):
user = request.user
usuario = Usuario.objects.get(user=user)
vendedor = usuario.get_vendedor()
iniDate = request.GET.get('ini', None)
print(iniDate)
iniDate = iniDate.replace("/", "-")
finDate = request.GET.get('fin', None)
finDate = finDate.replace("/", "-")
if iniDate == "" and finDate == "":
finDate = datetime.today()
iniDate = finDate - timedelta(days=4)
if iniDate == "" and finDate != "":
finDate = datetime.strptime(finDate, '%Y-%m-%d')
iniDate = finDate - timedelta(days=4)
if iniDate != "" and finDate == "":
finDate = datetime.today()
iniDate = datetime.strptime(iniDate, '%Y-%m-%d')
else:
iniDate = datetime.strptime(iniDate, '%Y-%m-%d')
finDate = datetime.strptime(finDate, '%Y-%m-%d')
print("alo")
if iniDate.date() > finDate.date():
return redirect('/main/estadisticas/')
trvend = Transacciones.objects.filter(vendedor=vendedor)
trvend = trvend.filter(fecha__lte=finDate,
fecha__gte=iniDate).values('producto').annotate(
conteo=Count('producto'))
listaTransac = list(trvend)
productos = []
cantidad = []
for i in listaTransac:
productos.append(Producto.objects.get(id=int(i['producto'])).nombre)
cantidad.append(int(i['conteo']))
favoritQS = Favoritos.objects.filter(
vendedor=vendedor, fecha__lte=finDate,
fecha__gte=iniDate).values('vendedor').annotate(
conteo=Count('vendedor'))
listaFav = list(favoritQS)
favoritos = []
for i in listaFav:
favoritos.append(int(i['conteo']))
print(productos)
print(cantidad)
print(favoritos)
return JsonResponse({
'productosGraficar': simplejson.dumps(productos),
'cantidadGraficar': simplejson.dumps(cantidad),
'numFav': simplejson.dumps(favoritos)
})
def home(request):
context = {
'show':
Show.objects.order_by('-date')[0],
'today_in_history':
Show.objects.order_by('-date').filter(
date__day=datetime.today().day - 1,
date__month=datetime.today().month)
}
return render(request, 'home/index.html', context)
def get_cohort():
cohort, _ = Cohort.objects.get_or_create(
cohort_number=22,
label="CodeClubNG",
defaults={
"cohort_curriculum": curriculum,
"start_date": datetime.today() + timedelta(days=1),
"end_date": datetime.today() + timedelta(days=366),
},
)
return cohort
def test_sell_recommendation(self):
Quote.objects.create(ticker=Ticker.objects.create(symbol=settings.INDEX_TICKER),
date=datetime.today())
quote = Quote.objects.create(ticker=Ticker.objects.create(symbol='TEST'),
date=datetime.today())
quote.sac_to_sacma_ratio = 1.5
quote.save()
response = self.client.get(reverse('get_recommendations'))
self.assertEqual(response.status_code, 200)
self.assertEqual(
json.dumps(response.data),
json.dumps({'success': True,
'latest_data_date': quote.date.strftime('%Y-%m-%d'),
'sell_hits': [fake_quote_serialize(quote)],
'buy_hits': []}))
def calendario_moscosos(request):
if request.method == 'GET':
ronda = Ronda.objects.get(id=request.GET['r'])
cm = ConfiguraMoscosos.objects.get(ronda=ronda)
mes = datetime.today().month
elif request.method == 'POST':
ronda = Ronda.objects.get(id=request.POST['r'])
cm = ConfiguraMoscosos.objects.get(ronda=ronda)
mes = datetime.today().month
respuesta = {
'moscosos':
Moscoso.objects.filter(cm=cm, fecha__month=mes).order_by('fecha'),
}
return render(request, "moscosos.html", respuesta)
def index(request):
#records = DailyRecord.objects.filter(created_on__date=datetime(2018,4,12))
records = DailyRecord.objects.filter(created_on__date=datetime.today())
data = {
"records": records,
}
return render(request,'website/main.html', context=data)
def clean_pass_date(self):
pass_date = self.cleaned_data['pass_date']
if pass_date == None:
return "date_wrong"
elif pass_date < datetime.today().date():
return "date_wrong"
return pass_date
def has_warning(inspector):
today = datetime.today()
today = make_aware(today.replace(hour=0, minute=0))
if OutBlockWarning.objects.filter(inspector=inspector,create_time__gt=today,proc_status='unprocess')\
.exists():
return True
return False
def get_context_data(self, *args, **kwargs):
context = super(AdminDashBoardView,
self).get_context_data(kwargs=kwargs)
if self.request.user.is_authenticated and self.request.user.is_superuser:
from django.utils.timezone import datetime
today = datetime.today()
context['order_cnt'] = Order.objects.filter(
time__month=today.month, time__year=today.year).count()
context['monthly_revenue'] = sum(
pkg.price
for ord in Order.objects.filter(time__month=today.month,
time__year=today.year)
for pkg in ord.get_package_list())
context['item_cnt'] = Package.objects.filter(
available=True).count()
context['rest_count'] = Restaurant.objects.exclude(
restaurant_key='0').count()
context['user_cnt'] = User.objects.filter(is_customer=True).count()
context['months'] = [
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
]
context['restaurants'] = get_monthwise_order_completed_count_all()
context['menus'] = get_packagewise_order_completed_count_all(
last_n_months=3)
return context
def handle(self, *args, **options):
# monday = '{} {} 1'.format(ISO_CALENDAR[0], ISO_CALENDAR[1])
# query = Task.objects.filter(
# starting__gte=datetime.fromtimestamp(
# time.mktime(time.strptime(monday, '%Y %W %w'))))
query = Task.objects.filter(starting__gte=tzdatetime.today().date())
data = [('state', 'starting', 'end', 'dataset_id', 'dataset_name',
'resource_id', 'resource_name', 'error')]
for item in query:
resource = Resource.objects.get(id=item.extras['resource'])
dataset = resource.dataset
data.append((
item.state, item.starting.isoformat(),
item.end.isoformat(), dataset.id, dataset.title,
resource.id, resource.title, item.extras.get('error', None)))
f = StringIO()
csv.writer(f).writerows(data)
mail_instance = Mail.objects.get(template_name='email_task')
mail = EmailMessage(
mail_instance.subject, mail_instance.message,
DEFAULT_FROM_EMAIL, get_admins_mails())
mail.attach('log.csv', f.getvalue(), 'text/csv')
mail.send()
def contextfunc(request):
today = datetime.today()
# today = datetime.date()
myapptstoday=Appointment.objects.filter(userappointments_id=request.session['id'])
myapptstoday2=Appointment.objects.filter(datee__year=today.year, datee__month=today.month, datee__day=today.day)
s1=set(myapptstoday)
s2=set(myapptstoday2)
s2=s2-s1
otherappts=Appointment.objects.filter(userappointments_id=request.session['id'])
otherappts2=Appointment.objects.exclude(datee__year=today.year, datee__month=today.month, datee__day=today.day)
y1=set(otherappts)
y2=set(otherappts2)
y1=y1-y2
context={
'myappttoday':s2,
'otherappt':y1
}
return render(request,'app2/dashboard.html',context)
def add_jobs_listing_page(slug, cls):
job_category = JobCategory(
job_category='CFPB Testing job category',
blurb='CFPB Testing blurb'
)
job_category.save()
job_region = JobLocation(
abbreviation='TR',
name='Testing Region'
)
job_region.save()
jobs_listing_page = cls(
close_date=datetime.now() + timedelta(days=30),
description='Test Job Description',
division=job_category,
open_date=datetime.today(),
salary_max=120000,
salary_min=95000,
slug=slug,
title=slug,
location=job_region
)
publish_page(jobs_listing_page)
def construct_postings_lists(self, day_before=1, end_date=datetime.today().date()):
config = configparser.ConfigParser()
config.read(self.config_path, self.config_encoding)
# files = News.objects.filter(datetime__day=timezone.now().day - day_before)
files = News.objects.filter(
datetime__gte=end_date - timezone.timedelta(days=day_before),
datetime__lte=end_date)
total_len = int(config['FORMULA']['avg_l']) * int(config['FORMULA']['n'])
for file in files:
title = file.title
body = file.body
docid = file.pk
date_time = file.datetime.strftime('%y-%m-%d %H:%M:%S')
seg_list = jieba.lcut_for_search(title + '。' + body)
total_words, cleaned_dict = self.clean_list(seg_list)
total_len += total_words
for term, tf_in_doc in cleaned_dict.items():
if term in title:
tf_in_doc += int(math.log2(total_words))
d = Doc(docid, date_time, tf_in_doc, total_words)
if term in self.postings_lists: # if term in dict, append doc
self.postings_lists[term][0] += 1 # doc_frequency++
self.postings_lists[term][1].append(d)
else: # else create new term and insert doc
self.postings_lists[term] = [1, [d]] # [doc_frequency, [Doc]]
AVG_L = int(total_len / News.objects.count())
config.set('FORMULA', 'n', str(News.objects.count()))
config.set('FORMULA', 'avg_l', str(AVG_L))
with open(self.config_path, 'w', encoding=self.config_encoding) as configfile:
config.write(configfile)
self.write_postings_to_db()
def get_appointments(patient):
apps = Appointment.objects.filter(patient=patient)
ret = []
for a in apps:
if a.dateOfApp >= datetime.today().date():
ret.append(a)
return ret
def ajaxFavChange(request):
user = request.user
usuario = Usuario.objects.get(user=user)
consumidor = usuario.get_consumidor()
v_id = int(request.GET.get('v_id', None))
vendedor = Vendedor.objects.get(id=v_id)
favItem = Favoritos.objects.filter(consumidor=consumidor,
vendedor=vendedor).values()
if not favItem:
fav = Favoritos(consumidor=consumidor,
vendedor=vendedor,
fecha=datetime.today())
fav.save()
consumidor.vendedoresFavoritos.append(str(v_id))
consumidor.save()
vendedor.numfavoritos += 1
vendedor.save()
else:
fav = Favoritos.objects.filter(consumidor=consumidor,
vendedor=vendedor)
fav.delete()
consumidor.vendedoresFavoritos.remove(str(v_id))
vendedor.numfavoritos -= 1
vendedor.save()
return JsonResponse({'nFav': vendedor.numfavoritos})
def ReportView(request):
if request.is_ajax():
endDate = None
startDate = request.GET.get('startDate')
if request.GET.get(
'endDate') == '' or request.GET.get('endDate') is None:
endDateConverter = datetime.today()
else:
endDate = request.GET.get('endDate')
endDateConverter = datetime.strptime(endDate, "%Y-%m-%d").date()
startDateConverter = datetime.strptime(startDate, "%Y-%m-%d").date()
from_user = DaftarTransaksi.objects.filter(
user_id=request.user.id,
created__date__gte=startDateConverter,
created__date__lte=endDateConverter)
daftar_barang = ListProductTransaksi.objects.filter(
transaksi_id__in=from_user)
return render(request, 'report_details.html', {
'daftar_barang': daftar_barang,
'num': startDateConverter
})
from_user = DaftarTransaksi.objects.filter(user_id=request.user.id)
daftar_barang = ListProductTransaksi.objects.filter(
transaksi_id__in=from_user)
context = {
'daftar_barang': daftar_barang,
'from_user': from_user,
}
return render(request, 'cashier/report.html', context)
def expiry(self):
today = datetime.today()
pk = Package.objects.filter(soft=self, from_dt__lte=today.date(), to_dt__gte=today.date())
if not pk.exists():
return mark_safe('<span style="color:red;">Expired</span>')
elif pk:
return pk[0].to_dt
def buzzfeed_fakenews_resource(buzzfeed_dataset, buzzfeed_editor, mocker):
from mcod.resources.models import Resource
_name = 'buzzfeed-2018-fake-news-1000-lines.csv'
copyfile(os.path.join(settings.TEST_DATA_PATH, _name),
os.path.join(settings.RESOURCES_MEDIA_ROOT, _name))
res = Resource(
title='Analysis of fake news sites and viral posts',
description=
'Over the past four years, BuzzFeed News has maintained lists of sites that '
'publish completely fabricated stories. As we encounter new ones and debunk '
'their content, we add them to the list.',
file=_name,
link=f'http://falconframework.org/media/resources/{_name}',
format='csv',
openness_score=3,
views_count=10,
downloads_count=20,
dataset=buzzfeed_dataset,
created_by=buzzfeed_editor,
modified_by=buzzfeed_editor,
data_date=datetime.today())
res.tracker.saved_data['link'] = res.link
res.save()
return res
def doctor_dict(request):
dam = DoctorAssistantMapping.objects.filter(
doctor_id=request.user.doctor.id)
assistants = []
for d in dam:
assistants.append(d.assistant)
appointments = Appointment.objects.all().filter(
dateOfApp=datetime.today().date())
apps = []
for a in appointments:
if a.dsm.doctor.user == request.user:
apps.append({'appointment': a, 'data': get_records(a.patient)})
medicine = Medicine.objects.all()
proc = MedicalProcedure.objects.all()
cities = City.objects.all()
areas = Area.objects.all()
args = {
'user': request.user,
'assistants': assistants,
'apps': apps,
'medicine': medicine,
'proc': proc,
'requests': get_friend_requests(request),
'dsm': get_schedules(request.user.doctor),
'zones': CityAreaMapping.objects.all()
}
return args
def rmtinf(self):
nombres = ', '.join(
self.deudores.values_list('gauser__first_name', flat=True))
return 'Pago de cuota: %s - %s (%s)' % (
self.emitida.politica.concepto,
self.emitida.politica.get_tipo_cobro_display(),
datetime.today().strftime('%d-%m-%Y'))
def post(self, request, name):
data = request.data
if name:
try:
_data = []
if name == 'textbookuploadexcel':
_file = request.FILES['file']
_ep = ExcelParser(file_content=_file.read())
_data = _ep.get_row_list(column=['发言内容', '状态', '權重'])
_done = get_main_service(
is_admin=True).add_textbook_sentense(_data)
if not _done:
return JsonResponse({
'error': 'Failed.',
'data': _data
},
safe=False)
return JsonResponse({
'name': name,
'datetime': datetime.today(),
'data': _data,
})
except Exception as err:
return HttpResponseForbidden(str(err))
else:
return JsonResponse({'name': 'none'}, safe=False)
def add_jobs_listing_page(slug, cls):
job_category = JobCategory(
job_category='CFPB Testing job category',
blurb='CFPB Testing blurb'
)
job_category.save()
job_region = JobLocation(
abbreviation='TR',
name='Testing Region'
)
job_region.save()
jobs_listing_page = cls(
close_date=datetime.now() + timedelta(days=30),
description='Test Job Description',
division=job_category,
open_date=datetime.today(),
salary_max=120000,
salary_min=95000,
slug=slug,
title=slug,
location=job_region
)
publish_page(jobs_listing_page)
def moscosos(request):
g_e = request.session['gauser_extra']
cm, c = ConfiguraMoscosos.objects.get_or_create(ronda=g_e.ronda)
mes = datetime.today().month
if cm.autoriza == g_e:
propios = Moscoso.objects.filter(cm=cm,
fecha__month=mes).order_by('fecha')
else:
propios = Moscoso.objects.filter(cm=cm, solicita=g_e)
if request.method == 'POST':
pass
respuesta = {
'iconos': ({
'tipo': 'button',
'nombre': 'plus',
'texto': 'Nuevo',
'title': 'Solicitar un día de libre disposición',
'permiso': 'acceso_moscosos'
}, ),
'formname':
'moscosos',
'cm':
cm,
'moscosos':
Moscoso.objects.filter(cm=cm, fecha__month=mes).order_by('fecha'),
'propios':
propios,
'avisos':
Aviso.objects.filter(usuario=g_e, aceptado=False)
}
return render(request, "moscosos.html", respuesta)
def other_remote_file_resource(buzzfeed_dataset, buzzfeed_editor, mocker, httpserver):
from mcod.resources.models import Resource
simple_csv_path = os.path.join(settings.TEST_SAMPLES_PATH, 'simple.csv')
httpserver.serve_content(
content=open(simple_csv_path).read(),
headers={
'content-type': 'application/csv'
},
)
res = Resource(
title='Other remote file resource',
description='Other remote file resource',
link=httpserver.url,
format='csv',
openness_score=3,
views_count=10,
downloads_count=20,
dataset=buzzfeed_dataset,
created_by=buzzfeed_editor,
modified_by=buzzfeed_editor,
data_date=datetime.today()
)
res.save()
return res
class TireSale(models.Model):
customer = models.ForeignKey(Customer)
tires = models.ForeignKey(TireInventory)
date_of_purchase = models.DateField(default=datetime.today())
total_price = models.DecimalField(max_digits=6, decimal_places=2)
amount_paid = models.DecimalField(max_digits=6,
decimal_places=2,
null=True,
blank=True)
quantity = models.IntegerField()
mileage = models.IntegerField(default=0, null=True, blank=True)
rotation_performed = models.BooleanField(default=False)
notes = models.CharField(max_length=256, blank=True)
@property
def rotation_mileage(self):
if self.quantity >= 4:
return (int(self.mileage) + 10000)
else:
return ("")
def save(self, *args, **kwargs):
tire_obj = TireInventory.objects.get(id=self.tires.id)
tire_obj.quantity -= self.quantity
tire_obj.save()
super(TireSale, self).save(*args, **kwargs)
class Meta:
ordering = ['customer', 'date_of_purchase']
def __str__(self):
return "Tire Sale #{}".format(self.id)
def job_search(request):
today = datetime.today()
queryset_list = Booking.objects.filter(is_advertised=True).filter(
event_date__gte=today).order_by('event_date')
# Dance style
if 'style' in request.GET:
style = request.GET['style']
if style:
queryset_list = queryset_list.filter(
dance_style__dance_style__icontains=style)
# City
if 'city' in request.GET:
city = request.GET['city']
if city:
queryset_list = queryset_list.filter(city__name__iexact=city)
# Teacher Booked
if 'teacher_booked' in request.GET:
teacher_booked = request.GET['teacher_booked']
if teacher_booked:
queryset_list = queryset_list.filter(
teacher_confirmed=teacher_booked)
context = {
'bookings': queryset_list,
'city_choices': city_choices,
'options': options,
'dance_choices': dance_choices
}
return render(request, 'pages/job_search.html', context)
def peoples_closet(request):
today = datetime_django.today()
peoples = FamilyEntry.objects.filter(last_entry__year=today.year,
last_entry__month=today.month,
last_entry__day=today.day)
ref = Referring.objects.all()
id_excludes = []
for p in peoples:
# import ipdb; ipdb.set_trace()
if p.family.role == 'r':
referente = Referring.objects.get(family_id=p.family_id)
if referente.last_buy != None:
if referente.last_buy.year == today.year and referente.last_buy.month == today.month and referente.last_buy.day == today.day:
#peoples.exclude(family_id=p.family_id)
id_excludes.append(p.family_id)
else:
referente = Referring.objects.get(family_id=p.family.ref)
if referente.last_buy != None:
if referente.last_buy.year == today.year and referente.last_buy.month == today.month and referente.last_buy.day == today.day:
#peoples.exclude(family_id=p.family_id)
id_excludes.append(p.family_id)
peoples = peoples.exclude(family_id__in=id_excludes)
context = {'peoples': peoples, 'ref': ref, 'today': today}
return render(request, 'peoples_closet.html', context)
def home(request):
user = User.objects.get(username=request.user)
month_first_day = datetime.today().replace(day=1, hour=0, minute=0, second=0, microsecond=0)
services_records = ServicesRecord.objects.filter(contractor=user, order_date__gte=month_first_day)
cartridges_count = services_records.count()
context = {
'user': user.username,
'date_joined': user.date_joined,
'cartridges_count': cartridges_count,
'all_operations_cost': 0,
'errors': [],
}
operations_prices = OperationPrice.objects.all()
for record in services_records:
for operation in record.operations.all():
try:
context['all_operations_cost'] += operations_prices.get(cartridge=record.cartridge,
operation=operation).cost
except ObjectDoesNotExist:
context['errors'].append("Не указана цена для {} {}".format(record.cartridge.name, operation.name))
return render(request, 'reporting_system/home.html', context)
def __init__(self, *args, **kwargs):
super(InternForm, self).__init__(*args, **kwargs)
placeholders = {
'first_name': _('Bruce'),
'last_name': _('Wayne'),
'date_of_birth': _('1999-12-24'),
'e_mail': _('*****@*****.**'),
'phone': _('314 159 265'),
'school': _('Česká vysoká škola v Gotham City'),
'faculty': _('Fakulta bojových umění'),
'year': _('2. ročník'),
'wanted_boarding_date': _(datetime.today()),
'field': _('Tajemné zmizení a vyvolání strachu'),
'interests': _('Zájmy'),
'learned_from': _('Vím o programu'),
'resume': _('Životopis'),
'cover_letter': _('Motivační dopis'),
}
for field in self.fields.keys():
if field != 'resume' and field != 'cover_letter' and field != 'agreement':
self.fields[field].widget.attrs.update({
'required':
self.fields[field].required,
'placeholder':
placeholders[field],
'class':
'form-control col-md-7 col-xs-12'
})
self.fields['interests'].queryset = Position.objects.filter(
is_active=True)
def setUp(self):
library = self.library = FeedLibrary(shared=False)
library.register(ListItemFeed, 'list feed')
self.feeds = [ ListItemFeed("['hello']"),
ListItemFeed("['world']") ]
for feed in self.feeds:
feed.get_last_updated_time = Mock(return_value=datetime.today())
self.feed_records = [library.get_record(feed) for feed in self.feeds]
def add_meal_to_basket(request, meal_id, meal_price_id):
previous = request.META.get('HTTP_REFERER')
meal_price = get_object_or_404(Price, pk=meal_price_id)
meal = Meal.objects.get(pk=meal_id)
basket, created = Basket.objects.get_or_create(
owner=request.user,
created_at=datetime.today()
)
Order.objects.create(meal=meal, size=meal_price.size, basket=basket)
if previous:
return HttpResponseRedirect(previous)
return redirect('restaurant-list')
def test_authorized_user_can_create_via_create_view(self):
'''Tests authorized user can create entry via EntryCreateView'''
self.assertTrue(self.client.login(username=self.user, password='******'))
r = self.client.post('/blogs/{}/create/'.format(self.user.username), {
'pub_state' : 'public',
'title' : '日記です',
'body' : '天気が良かったです',
})
today = datetime.today()
self.assertRedirects(r, '/blogs/{0}/{1}/{2}/{3}/1/'.format(self.user.username, today.year, today.month, today.day))
self.assertEqual(Entry.objects.count(), 1)
e = Entry.objects.get(pk=1)
self.assertEqual(e.title, '日記です')
self.assertTrue('messages' in r.cookies, "No messages are appeared")
def test_get_by_order_date(admin_user):
shop = get_default_shop()
today = dt.today()
yesterday = dt.today() - datetime.timedelta(days=1)
for i in range(1, 10):
order = create_empty_order(shop=shop)
order.order_date = yesterday
order.save()
order = create_empty_order(shop=shop)
order.save()
client = _get_client(admin_user)
response = client.get("/api/shuup/order/", data={"date": today})
assert response.status_code == status.HTTP_200_OK
order_data = json.loads(response.content.decode("utf-8"))
assert len(order_data) == 1
assert order_data[0].get("id") == order.id
assert order_data[0].get("identifier") == order.identifier
response = client.get("/api/shuup/order/", data={"date": yesterday})
assert response.status_code == status.HTTP_200_OK
order_data = json.loads(response.content.decode("utf-8"))
assert len(order_data) == 9
def console_input(request):
if request.method == 'POST':
contractor = request.user
today = datetime.today()
data = {}
try:
counteragent, records = request.POST['input'].split(':')
except ValueError:
return {'error': 'invalid input'}
try:
counteragent = Counteragent.objects.get(alias=ru2en_lower(counteragent))
except ObjectDoesNotExist:
return {'error': "В базе нет такого клиента "}
except IndexError:
return {'error': 'invalid input'}
for item in records.split(','):
try:
cartridge, *operations = item.split()
except ValueError:
return {'error': 'invalid input'}
try:
cartridge = Cartridge.objects.get(alias=ru2en_lower(cartridge))
except ObjectDoesNotExist:
return {'error': "Такого картриджа нет в базе"}
operations_list = []
for operation in operations:
try:
operations_list.append(Operation.objects.get(alias=ru2en_lower(operation)))
except ObjectDoesNotExist:
return {'error': "Такой операции нет в базе"}
data[cartridge] = operations_list
for cartridge, operations_list in data.items():
services_record = ServicesRecord(order_date=today,
contractor=contractor,
counteragent=counteragent,
cartridge=cartridge)
services_record.save()
services_record.operations.add(*operations_list)
return {'success': "Сохранено"}
def test_user_can_create_entry_with_category(self):
"""
カテゴリを指定してブログ記事を新しく投稿できる
"""
category = CategoryFactory(author=self.user)
self.assertTrue(self.client.login(username=self.user, password='******'))
r = self.client.post('/blogs/{0}/create/'.format(self.user.username), {
'pub_state': 'public',
'title': '日記です',
'body': '天気が良かったです',
'category': category.pk
})
today = datetime.today()
self.assertRedirects(r, '/blogs/{0}/{1}/{2}/{3}/1/'.format(self.user.username, today.year, today.month, today.day))
self.assertEqual(Entry.objects.count(), 1)
e = Entry.objects.get(pk=1)
self.assertEqual(e.author, self.user)
self.assertEqual(e.category, category)
self.assertTrue('messages' in r.cookies, "No messages are appeared")
def test_user_cannot_modify_author_id(self):
'''
Tests authorized user cannot modify author id.
In entry creation form, `author` is exist as hidden field.
So user can modify `author` to invalid values.
This test checks that `author` will be set by `request.user`
'''
other = PersonaFactory()
self.assertTrue(self.client.login(username=self.user, password='******'))
r = self.client.post('/blogs/{0}/create/'.format(self.user.username), {
'pub_state' : 'public',
'title' : '日記です',
'body' : '天気が良かったです',
'author' : other.pk # crackers attempt to masquerade
})
today = datetime.today()
self.assertRedirects(r, '/blogs/{0}/{1}/{2}/{3}/1/'.format(self.user.username, today.year, today.month, today.day))
self.assertEqual(Entry.objects.count(), 1)
e = Entry.objects.get(pk=1)
self.assertEqual(e.author, self.user)
self.assertNotEqual(e.author, other)
self.assertTrue('messages' in r.cookies, "No messages are appeared")
def get_webinars_queryset(self):
queryset = Webinar.objects.all()
queryset = self.filter_category(queryset).exclude(published=False).exclude(release_date__gte=datetime.today())
return queryset
def get_interviews_queryset(self):
queryset = Interview.objects.all()
queryset = self.filter_category(queryset).exclude(cover__isnull=True).exclude(published=False).exclude(release_date__gte=datetime.today())
return queryset
def ending_this_month(self):
"""
Will this plan end within the next 30 days
"""
return (datetime.today() <= self.active_until <=
datetime.today() + timedelta(days=30))
def subscription_active(self):
'''
gets the status based on current active status and active_until
'''
return self.active and (self.active_until > datetime.today()
or self.active_until is None)
def specials(self):
today = datetime.today()
delta = timedelta(days=45) # the number of days changes from dealership to dealership
return self.filter(date_in_stock__lte=today-delta)
def get_last_updated_time(self):
return datetime.today()
def get_teaching_materials_queryset(self):
queryset = TeachingMaterial.objects.all()
queryset = self.filter_category(queryset).exclude(published=False).exclude(release_date__gte=datetime.today())
return queryset
from django.utils.dateparse import parse_datetime
from django.utils.timezone import datetime, timedelta
from django.contrib.humanize.templatetags.humanize import naturaltime
from lib.auth import logged_in
from apps import BaseView
from apps.alarms import AlarmView
from apps.alarms.forms import (
AddForm,
UpdateForm,
DeleteForm,
)
logger = logging.getLogger('django')
today = datetime.today().utcnow()
hour_ago = today - timedelta(hours=1)
day_ago = today - timedelta(days=1)
week_ago = today - timedelta(days=7)
month_ago = today - timedelta(days=30)
METRICS_OPTIONS = {
'last_hour': {
'date_trunc': None,
"date_from": hour_ago,
},
'last_day': {
'date_trunc': 'hour',
"date_from": day_ago,
},
'last_week': {
def get_interviews_queryset(self, career_id):
queryset = Interview.objects.filter(career=career_id).exclude(published=False).exclude(release_date__gte=datetime.today())
return queryset
def deliver_to(self, subscriber, delivery_text):
"""
Send an email to the subscriber with the delivery_text
"""
email_addr = subscriber.email
email_body = delivery_text
email_subject = self.render_subject({'subscriber': subscriber, 'text': delivery_text, 'today': datetime.today()}).strip()
self.send_email(email_addr, email_body, email_subject)
