def setUp(self):
self.bond = BondFactory(
cusip='FLEXBOND0',
face = 10000000.00,
coupon = 0.035,
initial_price = 1.02,
auction_date = timezone.now() + timezone.timedelta(days=3),
dated_date = timezone.now() + timezone.timedelta(days=10),
maturity = timezone.now() + timezone.timedelta(days=10960),
payments_per_year = 2,
)
self.residual = ResidualFactory(
face = 10000.00,
bond = self.bond,
payments_per_year = 2,
)
self.money_market = MoneyMarketFactory(
face = 8000000.00,
bond = self.bond,
coupon = 0.0025,
issuance_date = timezone.now() + timezone.timedelta(days=10),
maturity = timezone.now() + timezone.timedelta(days=40),
)
self.client = Client()
print ("=====SETTING UP=====")
def __set_now_playing(self, media, start, duration):
"""
curl -u ing_ob:Swissradio1 -v --data "rpId=155&startTime=2018-08-29T13:55:00&duration=3600&title=Love Power&artist=Nicola Conte" -X POST "https://ingest.swissradioplayer.ch/ingestor/metadata/v1/np/"
"""
log.info('set now playing: {} {} {}'.format(media, start, duration))
# r = self.client.get('/ingestor/metadata/v1/18884470')
_start = (start - timezone.timedelta(hours=2)).replace(microsecond=0).isoformat()
_start = (timezone.now() - timezone.timedelta(hours=2)).replace(microsecond=0).isoformat()
#
# print(_start)
payload = {
'startTime': _start,
'duration': int(duration / 1000),
'title': media.name,
'artist': media.get_artist_display()
}
r = self.client.post('/ingestor/metadata/v1/np/', payload=payload)
# print(r)
# print(r.__dict__)
# print(r.headers['Location'])
# print(r.text)
pass
def send_offer_help_emails():
""" Send "do you need help?" emails to events.
This sends emails to events that are in the future but less than 6 weeks away.
Because of dates being approximate, we sometimes can't tell if an event in the current month
has happened or not on the db-level. So we need to catch it while it's more than a month away.
"""
events = Event.objects.filter(
is_on_homepage=True,
date__gt=timezone.now(),
date__lte=timezone.now() + timezone.timedelta(weeks=6),
created_at__lte=timezone.now() - timezone.timedelta(weeks=2),
offer_help_email_sent__isnull=True
).filter(
Q(is_page_live=False) | Q(form=None)
)
send_event_emails(
events=events,
subject_template="emails/offer_help_subject.txt",
plain_template="emails/offer_help_email.txt",
html_template="emails/offer_help_email.html",
timestamp_field='offer_help_email_sent',
email_type="offer help email",
)
if events:
send_mail(
subject="Check-in email summary",
message="Hi there!\n Check-in emails were automatically send to events with no live website "
"or application form open. If the organizers don't contact you back soon, you should "
"remove those events from the events page:\n" + "\n".join(e.city for e in events),
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=["*****@*****.**"]
)
def test_event_status(self):
self.assertEqual(self.e.status(self.organizer), 'Organizing')
self.assertEqual(self.e.row_class(self.organizer), '')
self.e.nhs_approved = False
self.assertEqual(self.e.status(self.organizer), 'Not approved by NHS')
self.assertEqual(self.e.row_class(self.organizer), 'danger')
self.e.nhs_approved = True
new_user = create_test_user('test2')
self.assertEqual(self.e.status(new_user), 'Not participating')
self.assertEqual(self.e.row_class(new_user), '')
self.e.participants.add(new_user)
self.assertEqual(self.e.status(new_user), 'Unconfirmed')
self.assertEqual(self.e.row_class(new_user), 'warning')
self.assertEqual(self.e.confirm_status(new_user).button_class, 'btn-success')
self.assertEqual(self.e.confirm_status(new_user).button_text, 'Confirm')
self.e.confirmed_participants.add(new_user)
self.assertEqual(self.e.status(new_user), 'Confirmed')
self.assertEqual(self.e.row_class(new_user), 'success')
self.assertEqual(self.e.confirm_status(new_user).button_class, 'btn-warning')
self.assertEqual(self.e.confirm_status(new_user).button_text, 'Unconfirm')
self.e.date_start += timezone.timedelta(days=5)
self.assertEqual(self.e.status(new_user), 'Event has not occurred yet')
self.assertEqual(self.e.row_class(new_user), '')
self.e.participants.clear()
self.e.confirmed_participants.clear()
self.e.date_start = timezone.make_aware(timezone.datetime(timezone.now().year, timezone.now().month, 1)
- timezone.timedelta(hours=1), timezone.utc)
self.assertIn('last-month', self.e.row_class(new_user))
def motion_details(request, days=3):
devices = Device.objects.all()
minutes = 10
start = timezone.now() - timezone.timedelta(days=days)
motion_time = []
motion_count = []
delta = timezone.timedelta(minutes=minutes)
while start < timezone.now():
cnt = Log.objects.filter(log_type__exact='MO', status=True, created__range=[start, start+delta]).count()
motion_time.append(start)
motion_count.append(cnt)
start += delta
# motion_datestmp = last_motion
motion_time = mark_safe([timezone.localtime(m).strftime('%Y-%m-%d %H:%M:%S') for m in motion_time].__str__())
#motion_state = mark_safe([ int(m.status) for m in last_motions].__str__())
#motion_time = mark_safe(motion_time.__str__())
motion_count = mark_safe(motion_count.__str__())
range_start = mark_safe(timezone.localtime(timezone.now()-timezone.timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S'))
range_end = mark_safe(timezone.localtime(timezone.now()).strftime('%Y-%m-%d %H:%M:%S'))
return render_to_response(
'motions.html',
locals()
)
def month(dst=0, withtime=True, **kwargs):
"""
Возвращает точки начала и конца месяца.
Параметром dst (целое число) задаётся количество месяцев от текущего.
Наример, если dst == 1 то вернёт:
(начало-следующго-месяца, конец-следующего-месяца)
"""
if withtime:
n = now().replace(day=1, hour=0, minute=0, second=0, microsecond=0)
else:
n = now().date().replace(day=1)
month = n.month
year = n.year
if dst < 0:
month = ((n.month - ((abs(dst)) % 12)) % 12) or 12
year = n.year - ((abs(dst)+12-n.month) // 12)
elif dst > 0:
month = ((n.month + ((abs(dst)) % 12)) % 12) or 12
year = n.year + ((abs(dst)+n.month-1) // 12)
start = n.replace(year=year, month=month)
next_month = get_next_month(start)
if withtime:
end = next_month - timedelta(microseconds=1)
else:
end = next_month - timedelta(days=1)
return (start, end)
def test_deletion(self):
self.is_not_callable(kwargs={
'pk': 5,
'year': self.event.start.date().year,
'month': self.event.start.date().month,
'day': self.event.start.date().day,
}, user=self.event.created_by, msg=('Wrong event pk.'))
self.is_not_callable(kwargs={
'pk': self.event.pk,
'year': self.event.start.date().year,
'month': '999',
'day': self.event.start.date().day,
}, user=self.event.created_by, msg=('Wrong dates.'))
new_rule = mixer.blend('calendarium.Rule', name='weekly',
frequency='WEEKLY')
new_event = mixer.blend(
'calendarium.Event',
rule=new_rule,
end_recurring_period=now() + timedelta(days=200),
start=now() - timedelta(hours=5),
)
test_date = self.event.start.date() - timedelta(days=5)
self.is_not_callable(kwargs={
'pk': new_event.pk,
'year': test_date.year,
'month': test_date.month,
'day': test_date.day,
}, user=self.event.created_by, msg=(
'No occurrence available for this day.'))
self.is_callable(user=self.event.created_by)
self.is_postable(user=self.event.created_by, to='/',
data={'decision': 'this one'})
def test_finish_in_progress_sessions_past_due_only_dued(self):
# now_datetime > grading_rule.due
fake_grading_rule = self.get_hacked_session_grading_rule(
due=now() + timedelta(days=1))
with mock.patch("course.flow.get_session_grading_rule") as \
mock_get_grading_rule:
mock_get_grading_rule.return_value = fake_grading_rule
finish_in_progress_sessions(
self.gopp.course_id, self.gopp.flow_id,
rule_tag=None, now_datetime=now()+timedelta(days=3),
past_due_only=True)
self.assertEqual(
models.FlowSession.objects.filter(in_progress=True).count(),
0)
self.assertEqual(
models.FlowSession.objects.filter(in_progress=False).count(),
self.all_sessions_count)
self.assertEqual(
models.FlowPageVisitGrade.objects.filter(
visit__flow_session__in=self.ended_sessions).count(),
0)
for ended_session in self.in_progress_sessions:
self.assertTrue(
models.FlowPageVisitGrade.objects.filter(
visit__flow_session=ended_session).count() > 0)
self.assertEqual(
self.mock_update_state.call_count, self.in_progress_sessions_count)
def dispatch(self, request, *args, **kwargs):
self.day = int(kwargs.get('day'))
self.month = int(kwargs.get('month'))
self.year = int(kwargs.get('year'))
try:
self.date = datetime(year=self.year, month=self.month,
day=self.day, tzinfo=utc)
except ValueError:
raise Http404
if request.method == 'POST':
if request.POST.get('next'):
date = self.date + timedelta(days=1)
return HttpResponseRedirect(reverse('calendar_day', kwargs={
'year': date.year, 'month': date.month, 'day': date.day}))
elif request.POST.get('previous'):
date = self.date - timedelta(days=1)
return HttpResponseRedirect(reverse('calendar_day', kwargs={
'year': date.year, 'month': date.month, 'day': date.day}))
elif request.POST.get('today'):
return HttpResponseRedirect(reverse('calendar_day', kwargs={
'year': now().year, 'month': now().month,
'day': now().day}))
if request.is_ajax():
self.template_name = 'calendarium/partials/calendar_day.html'
return super(DayView, self).dispatch(request, *args, **kwargs)
def setUp(self):
super(TestMultiTenant, self).setUp()
now = timezone.now()
self.init_projects()
self.tenant1 = connection.tenant
status_running = ProjectPhase.objects.get(slug='campaign')
# Create a project for the main tenant
self.project = ProjectFactory.create(status=ProjectPhase.objects.get(slug='campaign'),
deadline=now - timezone.timedelta(days=5),
amount_asked=0)
# Create a second tenant
connection.set_schema_to_public()
tenant_domain = 'testserver2'
self.tenant2 = get_tenant_model()(
domain_url=tenant_domain,
schema_name='test2',
client_name='test2')
self.tenant2.save(verbosity=0)
connection.set_tenant(self.tenant2)
self.init_projects()
self.project2 = ProjectFactory.create(status=ProjectPhase.objects.get(slug='campaign'),
deadline=now - timezone.timedelta(days=5),
amount_asked=0)
def test_has_active_subscription_with_unspecified_plan_with_multiple_subscriptions(
self, product_retrieve_mock, customer_retrieve_mock, subscription_create_mock
):
plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN))
self.assert_fks(plan, expected_blank_fks={})
subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
subscription_fake["current_period_end"] = datetime_to_unix(
timezone.now() + timezone.timedelta(days=7)
)
subscription_fake_duplicate = deepcopy(FAKE_SUBSCRIPTION)
subscription_fake_duplicate["current_period_end"] = datetime_to_unix(
timezone.now() + timezone.timedelta(days=7)
)
subscription_fake_duplicate["id"] = "sub_6lsC8pt7IcF8jd"
subscription_create_mock.side_effect = [
subscription_fake,
subscription_fake_duplicate,
]
self.customer.subscribe(plan=plan, charge_immediately=False)
self.customer.subscribe(plan=plan, charge_immediately=False)
self.assertEqual(2, self.customer.subscriptions.count())
with self.assertRaises(TypeError):
self.customer.has_active_subscription()
def _create_events(self):
prefec_list = list(self.prefectures)
#ポイント稼ぎ用ボランティア
random.seed(1)
for i in range(1,21):
for j in range(1,4):
name = "【第%d回】"%j + eventname_sample[i]["name"]
host_user = User.objects.get(username="******"%i)
past_or_future = 1 if i < 10 else -1
demoevent = Event(
name=name,
start_time=timezone.now() + timezone.timedelta(days=301) * past_or_future,
end_time = timezone.now() + timezone.timedelta(days=302) * past_or_future,
meeting_place="池袋駅東口母子像前",
contact="*****@*****.**",
details=eventdetail_sample,
host_user=host_user,
region=prefec_list[i%47],
longitude=139.7191 + 0.01 * random.uniform(-2.0,2.0),
latitude=35.7291 + 0.01 * random.uniform(-2.0,2.0)
)
demoevent.save()
demoevent.admin = User.objects.filter(pk=i)
def _create_userreviewlists(self):
past_event_list = [event for event in Event.objects.all() if event.is_closed()]
for c_event in past_event_list:
for c_participant in c_event.participant.all():
# Host -> Participant
if random.choice([0,0,0,1,1,1,1,1,1,1]): # Did_or_Not_Did
userreviewlists_hp = UserReviewList(
to_rate_user = c_participant,
from_rate_user = c_event.host_user,
rating = random.choice([1,2,2,3,3,3,3,4,4,4,4,4,4,5,5,5,5]),
comment = review_comment_sample[random.choice([0,0,0,0,0,1,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,6])],
joined_event = c_event,
post_day = c_event.end_time + random.choice(range(1,15)) * timezone.timedelta(days=1),
from_event_host = True,
)
userreviewlists_hp.save()
# Participant-> Host
if random.choice([0,0,0,1,1,1,1,1,1,1]): # Did_or_Not_Did
userreviewlists_ph = UserReviewList(
to_rate_user = c_event.host_user,
from_rate_user = c_participant,
rating = random.choice([1,2,2,3,3,3,3,4,4,4,4,4,4,5,5,5,5]),
comment = review_comment_sample[random.choice([0,0,0,0,0,1,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6])],
joined_event = c_event,
post_day = c_event.end_time + random.choice(range(1,15)) * timezone.timedelta(days=1),
from_event_host = False,
)
userreviewlists_ph.save()
def test_revoke_access_token_with_mismatching_app(self):
"""
Test token revocation using mismatching application
"""
other_access_token = AccessToken.objects.create(user=self.test_user, token='1029384756',
application=self.public_application,
expires=timezone.now() + timezone.timedelta(days=1),
scope='read write')
other_refresh_token = RefreshToken.objects.create(user=self.test_user, token='1122334455',
application=self.public_application,
access_token=other_access_token,
expires=timezone.now() + timezone.timedelta(days=3))
self.client.credentials(HTTP_AUTHORIZATION=self.get_basic_auth(self.application.client_id,
self.application.client_secret))
data = {
'token': other_refresh_token.token,
'token_type_hint': 'refresh_token',
}
response = self.client.post(reverse('oauth_api:revoke-token'), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(AccessToken.objects.filter(pk=other_access_token.pk).exists())
self.assertTrue(AccessToken.objects.filter(pk=self.access_token.pk).exists())
self.assertTrue(RefreshToken.objects.filter(pk=other_access_token.pk).exists())
self.assertTrue(RefreshToken.objects.filter(pk=self.refresh_token.pk).exists())
def setUp(self):
self.today_date = timezone.datetime.today()
self.yesterday_date = timezone.datetime.today() - timezone.timedelta(days=1)
self.ereyesterday_date = self.yesterday_date + timezone.timedelta(days=-1)
self.word1=create_wordtext_and_worddetails(text='vehicle', source_name='WP', occured_num=3, datetime=self.today_date)
self.word2=create_wordtext_and_worddetails(text='gun', source_name='WP', occured_num=2, datetime=self.today_date)
self.word3=create_wordtext_and_worddetails(text='bike', source_name='WP', occured_num=1, datetime=self.yesterday_date)
self.word4=create_wordtext_and_worddetails(text='boat', source_name='WP', occured_num=2, datetime=self.yesterday_date)
self.word5=create_wordtext_and_worddetails(text='ferry', source_name='WP', occured_num=2, datetime=self.ereyesterday_date)
self.word6=create_wordtext_and_worddetails(text='train', source_name='WP', occured_num=2, datetime=self.ereyesterday_date)
self.link1 = create_link(datetime=self.today_date, title='Police find gun in vehicle.',
url_address='www.wp.pl/articles/011', source='WP')
self.link2 = create_link(datetime=self.today_date, title="Is this the world's greatest sport-utility vehicle?",
url_address='www.wp.pl/articles/012', source='WP')
self.link3 = create_link(datetime=self.yesterday_date, title="10 Reasons to Get on a Bike.",
url_address='www.wp.pl/articles/015', source='WP')
self.link1.words.add(self.word1)
self.link1.save()
self.link1.words.add(self.word2)
self.link1.save()
self.link2.words.add(self.word1)
self.link2.save()
self.link3.words.add(self.word3)
self.link3.save()
def create_concert(festival, artist):
return Concert.objects.create(
festival=festival,
artist=artist,
start=timezone.now() + timezone.timedelta(days=2, hours=1),
end=timezone.now() + timezone.timedelta(days=2, hours=2),
)
def test_filter_allowed_to_create_groups(self):
assignment_expired = mommy.make(
'core.Assignment',
students_can_create_groups=True,
students_can_not_create_groups_after=timezone.now() - timedelta(days=1)
)
assignment_not_expired = mommy.make(
'core.Assignment',
students_can_create_groups=True,
students_can_not_create_groups_after=timezone.now() + timedelta(days=1)
)
assignment_not_allowed = mommy.make('core.Assignment', students_can_create_groups=False)
assignment_allowed = mommy.make('core.Assignment', students_can_create_groups=True)
group1 = mommy.make('core.AssignmentGroup', parentnode=assignment_expired)
group2 = mommy.make('core.AssignmentGroup', parentnode=assignment_not_expired)
group3 = mommy.make('core.AssignmentGroup', parentnode=assignment_not_allowed)
group4 = mommy.make('core.AssignmentGroup', parentnode=assignment_allowed)
mommy.make('core.GroupInvite', group=group1, id=10)
mommy.make('core.GroupInvite', group=group2, id=11)
mommy.make('core.GroupInvite', group=group3, id=100)
mommy.make('core.GroupInvite', group=group4, id=101)
self.assertEqual(
set(invite.id for invite in GroupInvite.objects.filter_allowed_to_create_groups()),
{11, 101}
)
def dispatch(self, request, *args, **kwargs):
try:
self.event = LocalEvent.shows.get(pk=kwargs.get('pk'))
except LocalEvent.DoesNotExist:
raise Http404
year = int(kwargs.get('year'))
month = int(kwargs.get('month'))
day = int(kwargs.get('day'))
try:
date = datetime(year, month, day, tzinfo=utc)
except (TypeError, ValueError):
raise Http404
# this should retrieve the one single occurrence, that has a
# matching start date
try:
occ = LocalOccurrence.objects.get(
start__year=year, start__month=month, start__day=day)
except LocalOccurrence.DoesNotExist:
occ_gen = self.event.get_occurrences(self.event.start)
occ = occ_gen.next()
while occ.start.date() < date.date():
occ = occ_gen.next()
if occ.start.date() == date.date():
occ.start = occ.start + timedelta(days=1)
occ.end = occ.end + timedelta(days=1)
self.occurrence = occ
else:
raise Http404
self.object = occ
return super(LocalOccurrenceDetailView, self).dispatch(
request, *args, **kwargs)
def test_date_from_request_params(self):
"""Test that the date values from request params determine filter for responses."""
url = '/reports/region/599/?day=14&month=7&year=2014'
request = self.factory.get(url)
report = clinics.RegionReport(kwargs={'pk': self.region.pk})
report.request = request
report.get(request)
dt = timezone.now().replace(year=2014, month=7, day=14, second=0, microsecond=0)
curr_date = report.curr_date.replace(microsecond=0, second=0)
self.assertEqual(dt, curr_date)
# Test that responses btw 14th and 20th of June
v2 = factories.Visit.create(
service=factories.Service.create(code=3),
visit_time=dt + timezone.timedelta(2),
survey_sent=dt + timezone.timedelta(2),
patient=factories.Patient.create(clinic=self.clinic, serial=115)
)
factories.SurveyQuestionResponse.create(
question=self.respect,
datetime=timezone.now(),
visit=v2,
clinic=self.clinic, response='No')
self.assertEqual(1, report.responses.count())
def test_extend(
self,
customer_retrieve_mock,
subscription_retrieve_mock,
product_retrieve_mock,
plan_retrieve_mock,
):
subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
subscription_fake["current_period_end"] = datetime_to_unix(
timezone.now() - timezone.timedelta(days=20)
)
subscription_retrieve_mock.return_value = subscription_fake
subscription = Subscription.sync_from_stripe_data(subscription_fake)
self.assertFalse(subscription in self.customer.active_subscriptions)
self.assertEqual(self.customer.active_subscriptions.count(), 0)
delta = timezone.timedelta(days=30)
extended_subscription = subscription.extend(delta)
self.assertNotEqual(None, extended_subscription.trial_end)
self.assertTrue(self.customer.has_active_subscription())
self.assertTrue(self.customer.has_any_active_subscription())
self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
def get_date_range_dict():
filter_by_date_default_end_date = timezone.now()
date_range_dict = {'default': {'start_date': FILTER_BY_DATE_DEFAULT_START_DATE,
'end_date': filter_by_date_default_end_date},
'week': {'start_date': timezone.now() - timezone.timedelta(days=7),
'end_date': filter_by_date_default_end_date},
'two_weeks': {'start_date': timezone.now() - timezone.timedelta(days=14),
'end_date': filter_by_date_default_end_date},
'month': {'start_date': timezone.now() - timezone.timedelta(days=31),
'end_date': filter_by_date_default_end_date},
'current_month': {
'start_date': timezone.datetime(timezone.now().year, timezone.now().month, 1,
tzinfo=timezone.utc),
'end_date': filter_by_date_default_end_date
},
'current_year': {
'start_date': timezone.datetime(timezone.now().year, 1, 1, tzinfo=timezone.utc),
'end_date': filter_by_date_default_end_date
},
'protective_edge': {
# Dates are set based on information from Wikipedia:
# he.wikipedia.org/wiki/%D7%9E%D7%91%D7%A6%D7%A2_%D7%A6%D7%95%D7%A7_%D7%90%D7%99%D7%AA%D7%9F
'start_date': timezone.datetime(2014, 7, 8, tzinfo=timezone.utc),
'end_date': timezone.datetime(2014, 8, 26, tzinfo=timezone.utc)
},
}
return date_range_dict
def render(self, context):
context_time = self.time.resolve(context)
delta = tznow() - context_time
today = tznow().replace(hour=0, minute=0, second=0)
yesterday = today - timedelta(days=1)
tomorrow = today + timedelta(days=1)
if delta.days == 0:
if delta.seconds < 60:
msg = _('seconds ago')
return u'%d %s' % (delta.seconds, msg)
elif delta.seconds < 3600:
minutes = int(delta.seconds / 60)
msg = _('minutes ago')
return u'%d %s' % (minutes, msg)
if context['user'].is_authenticated():
if time.daylight:
tz1 = time.altzone
else:
tz1 = time.timezone
tz = tz1 + getattr(settings, 'PYBB_DEFAULT_TIME_ZONE', 0) * 60 * 60
context_time = context_time + timedelta(seconds=tz)
if today < context_time < tomorrow:
return _('today, %s') % context_time.strftime('%H:%M')
elif yesterday < context_time < today:
return _('yesterday, %s') % context_time.strftime('%H:%M')
else:
return dateformat.format(context_time, 'd M, Y H:i')
def index(request):
acs = Article.get_all_newest_contents_all_languages()
now = timezone.now()
acs_updated_in_the_last_24_hours = filter(
lambda ac: ac.updated > now - timezone.timedelta(hours=24), acs)
acs_updated_in_the_last_week = filter(
lambda ac: ac.updated > now - timezone.timedelta(days=7), acs)
acs_updated_in_the_last_month = filter(
lambda ac: ac.updated > now - timezone.timedelta(days=30), acs)
user_stats = _generate_user_statistics_for_one_day(
year=now.year, month=now.month, day=now.day
)
article_length_stats = _generate_article_length_statistics(acs)
return render(request, 'stats/index.html', {
'number_of_acs_updated_in_the_last_24_hours':
len(acs_updated_in_the_last_24_hours),
'number_of_acs_updated_in_the_last_week':
len(acs_updated_in_the_last_week),
'number_of_acs_updated_in_the_last_month':
len(acs_updated_in_the_last_month),
'users': user_stats,
'compendium_length_stats': article_length_stats,
})
def test_allocation_for_multiple_instances(self):
"""
Checks that the sum of allocations meets the expected value
"""
current_time = datetime(2014, 7, 4, hour=12, tzinfo=pytz.utc)
# Create 10 instances of uniform size
for idx in range(0, 10):
start_time = current_time
current_time = end_time = current_time + timedelta(days=3)
helper = InstanceHelper()
# Add 3 days of active
helper.add_history_entry(start_time, end_time)
# Add 3 days of suspended following active time
helper.add_history_entry(end_time, end_time + timedelta(days=3),
status="suspended")
self.allocation_helper.add_instance(
helper.to_instance("Instance %s" % idx))
allocation = self.allocation_helper.to_allocation()
self.assertTotalRuntimeEquals(allocation, timedelta(days=30))
def handle(self, *args, **options):
contact_email = getattr(settings, 'EMAIL_CONTACT_ADDRESS', None)
if contact_email is None:
raise ImproperlyConfigured('EMAIL_CONTACT_ADDRESS must be configured')
today = timezone.now().date()
expiration_days = (30, 15, 7)
expiration_dates = [today - timezone.timedelta(days=d) for d in expiration_days]
expiration_dates += [today]
filter_arg = None
for d in expiration_dates:
since = self._make_date_lookup_arg(d)
until = self._make_date_lookup_arg(d + timezone.timedelta(days=1))
if filter_arg is None:
filter_arg = Q(valid_until__gte=since, valid_until__lt=until)
else:
filter_arg |= Q(valid_until__gte=since, valid_until__lt=until)
if settings.USE_I18N:
translation.activate(settings.LANGUAGE_CODE)
for payment in Payment.objects.filter(filter_arg):
last_payment = payment.member.get_last_payment()
if last_payment:
last_payment_date = last_payment.valid_until.date()
status = [last_payment_date > d for d in expiration_dates]
already_renewed = all(status)
# skip to send notification if already renewed
if already_renewed:
continue
valid_until_date = payment.valid_until.date()
context = {
'contact_email': contact_email,
'member': payment.member,
'url': '%s%s' % (Site.objects.get_current().domain, reverse('payment', args=[payment.member.pk])),
}
if valid_until_date == today:
context['date'] = today
subject = '[Associação Python Brasil] Anuidade vencida'
message = render_to_string('payment/valid_until_today_email.txt',
context)
else:
date_diff = today - valid_until_date
context['days'] = date_diff.days
subject = '[Associação Python Brasil] Aviso de renovação'
message = render_to_string('payment/valid_until_email.txt',
context)
send_mail(subject, message, contact_email,
[payment.member.user.email], fail_silently=False)
if settings.USE_I18N:
translation.deactivate()
def dispatch(self, request, *args, **kwargs):
self.month = int(kwargs.get('month'))
self.year = int(kwargs.get('year'))
if self.month not in range(1, 13):
raise Http404
if request.method == 'POST':
if request.POST.get('next'):
new_date = datetime(self.year, self.month, 1) + timedelta(
days=31)
kwargs.update({'year': new_date.year, 'month': new_date.month})
return HttpResponseRedirect(
reverse('calendar_month', kwargs=kwargs))
elif request.POST.get('previous'):
new_date = datetime(self.year, self.month, 1) - timedelta(
days=1)
kwargs.update({'year': new_date.year, 'month': new_date.month})
return HttpResponseRedirect(
reverse('calendar_month', kwargs=kwargs))
elif request.POST.get('today'):
kwargs.update({'year': now().year, 'month': now().month})
return HttpResponseRedirect(
reverse('calendar_month', kwargs=kwargs))
if request.is_ajax():
self.template_name = 'calendarium/partials/calendar_month.html'
return super(MonthView, self).dispatch(request, *args, **kwargs)
def test_edit_suspended(self):
'''When we unsuspend a poll after the close date does it remind us?'''
# set our poll to have closed in the past
new_open_date = self.open_date - timezone.timedelta(days=30)
new_close_date = new_open_date + timezone.timedelta(days=2)
expected = self.open_date + timezone.timedelta(days=2)
update_data = {'close_date': new_close_date.strftime('%Y-%m-%d'),
'question': self.poll.question,
'open_date': new_open_date.strftime('%Y-%m-%d'),
'suspended': True}
path = '/approval_polls/update/{0}/'.format(self.poll.id)
response = self.client.post(path, data=update_data)
# our test is set up now if we unsuspend the poll it should reload the form and ask us
# to reset the close date to some time in the future.
update_data = {'close_date': new_close_date.strftime('%Y-%m-%d'),
'question': self.poll.question,
'open_date': new_open_date.strftime('%Y-%m-%d'),
'suspended': False}
response = self.client.post(path, data=update_data)
self.assertEqual(response.status_code, 200)
needle = '<li>Your close date is in the past. Please update the close date.</li>'
self.assertInHTML(needle, response.content)
def setUpTestData(cls):
super().setUpTestData()
cls.published_task1 = Task.objects.create(
title="Task 1",
category=cls.category1,
description="Task 1 description",
system_name="Task1",
pubdate=timezone.now(),
slug="task-1"
)
cls.published_task2 = Task.objects.create(
title="Task 2",
category=cls.category1,
description="Task 2 description",
system_name="Task2",
pubdate=timezone.now(),
slug="task-2"
)
cls.unpublished_task1 = Task.objects.create(
title="Unpublished Task 1",
category=cls.category1,
description="Unpublished Task 1 description",
system_name="UnpublishedTask1",
pubdate=timezone.now() + timezone.timedelta(days=7),
slug="unpublished-task-1"
)
cls.unpublished_task2 = Task.objects.create(
title="Unpublished Task 2",
category=cls.category1,
description="Unpublished Task 2 description",
system_name="UnpublishedTask2",
pubdate=timezone.now() + timezone.timedelta(days=7),
slug="unpublished-task-2"
)
def dispatch(self, request, *args, **kwargs):
self.week = int(kwargs.get('week'))
self.year = int(kwargs.get('year'))
if self.week not in range(1, 53):
raise Http404
if request.method == 'POST':
if request.POST.get('next'):
date = monday_of_week(self.year, self.week) + timedelta(days=7)
kwargs.update(
{'year': date.year, 'week': date.date().isocalendar()[1]})
return HttpResponseRedirect(
reverse('calendar_week', kwargs=kwargs))
elif request.POST.get('previous'):
date = monday_of_week(self.year, self.week) - timedelta(days=7)
kwargs.update(
{'year': date.year, 'week': date.date().isocalendar()[1]})
return HttpResponseRedirect(
reverse('calendar_week', kwargs=kwargs))
elif request.POST.get('today'):
kwargs.update({
'year': now().year,
'week': now().date().isocalendar()[1],
})
return HttpResponseRedirect(
reverse('calendar_week', kwargs=kwargs))
if request.is_ajax():
self.template_name = 'calendarium/partials/calendar_week.html'
return super(WeekView, self).dispatch(request, *args, **kwargs)
def get_allocation_dict(self):
if not self.allocation:
return {}
#Don't move it up. Circular reference.
from service.allocation import get_time, get_burn_time,\
delta_to_minutes, delta_to_hours, get_delta
delta = get_delta(self, time_period=relativedelta(day=1, months=1))
time_used = get_time(self.identity.created_by,
self.identity.id,
delta)
burn_time = get_burn_time(self.identity.created_by, self.identity.id,
delta,
timedelta(minutes=self.allocation.threshold))
mins_consumed = delta_to_minutes(time_used)
if burn_time:
burn_time = delta_to_hours(burn_time)
zero_time = datetime.now() + timedelta(
minutes=(self.allocation.threshold - mins_consumed))
allocation_dict = {
"threshold": floor(self.allocation.threshold/60),
"current": floor(mins_consumed/60),
"delta": ceil(delta.total_seconds()/60),
"burn": burn_time,
"ttz": zero_time,
}
return allocation_dict
def one_month_hence():
return timezone.now() + timezone.timedelta(days=30)
def online(self):
online_gte = timezone.now() - timezone.timedelta(
seconds=ONLINE_TIMEOUT)
return self.exclude(login_token=None).filter(
request_at__gte=online_gte)
def mock_enrollment_code_deactivation(self, enrollment_code):
enrollment_code.expires = now() - timedelta(days=1)
enrollment_code.save()
def setUp(self):
self.user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_active=True,
cellphone='988887777',
cellphone_ddd='55',
full_name='Crocodilo Dande',
born=(now() - timedelta(days=10000)).date(),
cpf='829.354.190-30',
)
address = Address(
user=self.user,
city='Longa vida',
state='MG',
street='Rua tal',
street_number='45',
zipcode='32444-000',
neighborhood='Bairro tal',
)
address.save()
self.professional = Professional.objects.create(
user=User.objects.create_user(
email='*****@*****.**',
password='******',
is_active=True,
full_name='Bernardo Lagosta',
cpf='059.391.440-63',
),
avg_price=99,
skills=['CI', 'AE', 'EM'],
occupation='CI',
coren='10.400'
)
self.professional.user.save()
self.professional.save()
self.user.create_customer()
card = {
"card_expiration_date": "1122",
"card_number": "4018720572598048",
"card_cvv": "123",
"card_holder_name": "Cersei Lannister"
}
self.user.create_card(card)
self.professional.create_recipient(**{
'agency': '0932',
'agency_dv': '5',
'bank_code': '341',
'account': '58054',
'account_dv': '1',
'legal_name': 'HOUSE TARGARYEN'
})
self.proposal = Proposal(
client=self.user,
professional=self.professional,
city='Curitiba',
state='PR',
professional_type='AE',
service_type='AC',
start_datetime=TODAY + timedelta(days=1),
end_datetime=TODAY + timedelta(days=3),
value=200.00,
description='Lorem Ipsum dolores'
)
self.proposal.save()
self.proposal.accept()
self.job:Job = self.proposal.job
self.job.pay(0)
def test_bulk_projection(self):
# make sure normies can't see this
self.assertOk(self.client.get(reverse("projection:add-movies")), 403)
permission = Permission.objects.get(codename='add_bulk_events')
self.user.user_permissions.add(permission)
self.assertOk(self.client.get(reverse("projection:add-movies")))
invalid_details = {
'contact': '',
'billing': '',
'date_first': '',
'date_second': '',
'submit': 'Save Changes'
}
# Create test organization
org = Organization.objects.create(name="LNL",
email="*****@*****.**",
phone="1234567890",
user_in_charge=self.user)
org.save()
org.associated_users.add(self.user)
org.save()
valid_details = {
'contact':
str(self.user.pk),
'billing':
str(org.pk),
'date_first':
timezone.datetime.today().date(),
'date_second':
timezone.datetime.today().date() + timezone.timedelta(days=14),
'submit':
'Save Changes'
}
# Should present errors on invalid data
self.assertOk(
self.client.get(reverse("projection:add-movies"), invalid_details))
first_form = forms.BulkCreateForm(data=invalid_details)
self.assertFalse(first_form.is_valid())
first_form = forms.BulkCreateForm(data=valid_details)
self.assertTrue(first_form.is_valid())
# Test DateEntryFormsetBase is valid / invalid
formset = formset_factory(forms.DateEntryFormSetBase, extra=0)
valid_data = {
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 1,
'form-MIN_NUM_FORMS': 0,
'form-MAX_NUM_FORMS': 1000,
'form-0-date': datetime.date(2020, 1, 4),
'form-0-name': 'Test Movie',
'form-0-friday': False,
'form-0-matinee': False,
'form-0-saturday': True,
'form-0-sunday': True,
'submit': 'Submit'
}
invalid_data = {
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 1,
'form-MIN_NUM_FORMS': 0,
'form-MAX_NUM_FORMS': 1000,
'form-0-date': '',
'form-0-name': 'Test Movie',
'form-0-friday': False,
'form-0-matinee': False,
'form-0-saturday': True,
'form-0-sunday': True,
'submit': 'Submit'
}
valid_form = formset(data=valid_data)
invalid_form = formset(data=invalid_data)
self.assertTrue(valid_form.is_valid())
self.assertFalse(invalid_form.is_valid())
# Do not count week if not filled out
empty_data = {
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 1,
'form-MIN_NUM_FORMS': 0,
'form-MAX_NUM_FORMS': 1000,
'form-0-date': datetime.date(2020, 1, 4),
'form-0-name': '',
'form-0-friday': False,
'form-0-matinee': False,
'form-0-saturday': True,
'form-0-sunday': True,
'submit': 'Submit'
}
empty_formset = formset(data=empty_data)
for form in empty_formset:
output = form.save_objects(user=self.user,
contact=self.user,
org=org,
ip=None)
self.assertEqual(output, [])
# Give permissions to approve event
permission = Permission.objects.get(codename="approve_event")
self.user.user_permissions.add(permission)
# Test posting of data (invalid and valid)
resp = self.client.post(
"%s?contact=%s&billing=1&date_first=2020-01-01&date_second=2020-01-08&save=Continue"
% (reverse("projection:add-movies"), self.user.pk), invalid_data)
self.assertNotContains(resp, "Events Added")
self.assertOk(resp)
resp = self.client.post(
"%s?contact=%s&billing=1&date_first=2020-01-01&date_second=2020-01-08&save=Continue"
% (reverse("projection:add-movies"), self.user.pk), valid_data)
self.assertContains(resp, "Events Added")
self.assertOk(resp)
# Check that event was automatically approved
movie = Event2019.objects.get(event_name="Test Movie",
datetime_start=timezone.make_aware(
datetime.datetime.combine(
datetime.date(2020, 1, 4),
datetime.time(20))))
self.assertTrue(movie.approved)
# Check for both saturday and sunday events in output
self.assertTrue(
Event2019.objects.filter(event_name="Test Movie",
datetime_start=timezone.make_aware(
datetime.datetime.combine(
datetime.date(2020, 1, 5),
datetime.time(20)))).exists())
def clean_date(self):
date = self.cleaned_data.get('date')
if date < timezone.now() - timezone.timedelta(hours=24):
raise forms.ValidationError(
_("Veuillez choisir une date dans le futur."))
return date
def test_check_pvoutput_sync_disabled(self):
PVOutputAddStatusSettings.get_solo().update(
export=False,
next_export=timezone.now() - timezone.timedelta(minutes=1))
self.assertIsNone(check_pvoutput_sync())
def one_year_hence():
return timezone.now() + timezone.timedelta(days=365)
def get_result(duration):
print("fuk")
date = timezone.now() - timezone.timedelta(days=5 * 30)
for day in range(0, duration):
temp = date + timezone.timedelta(days=day)
compute_bayesian_network_probabilities(temp)
avg_temp = [0, 0]
max_temp = [0, 0]
precipitation = [0, 0]
radiation_time = [0, 0]
for inc in range(0, 10):
temp = to_date(temp, inc * (-365))
avg_temp = [
avg_temp[0] + (10 - inc) * check_val(temp, Tipe.avg_temp)[0],
avg_temp[1] + (10 - inc) * check_val(temp, Tipe.avg_temp)[1],
]
max_temp = [
max_temp[0] + (10 - inc) * check_val(temp, Tipe.max_temp)[0],
max_temp[1] + (10 - inc) * check_val(temp, Tipe.max_temp)[1],
]
precipitation = [
precipitation[0] + (10 - inc) * check_val(temp, Tipe.precipitation)[0],
precipitation[1] + (10 - inc) * check_val(temp, Tipe.precipitation)[1],
]
radiation_time = [
radiation_time[0]
+ (10 - inc) * check_val(temp, Tipe.radiation_time)[0],
radiation_time[1]
+ (10 - inc) * check_val(temp, Tipe.radiation_time)[1],
]
temp = to_date(temp, inc * 365)
# compute key for temperature
temperature_key = 0
avg_temp_val = avg_temp[0] / avg_temp[1]
max_temp_val = max_temp[0] / max_temp[1]
radiation_time_val = radiation_time[0] / radiation_time[1]
if 22 <= avg_temp_val < 8000:
temperature_key += 1
if 26 <= max_temp_val < 8000:
temperature_key += 2
if 3 <= radiation_time_val < 8000:
temperature_key += 4
# compute key for humidity
humidity_key = 0
precipitation_val = precipitation[0] / precipitation[1]
if 0 <= precipitation_val <= 70:
humidity_key += 1
print(temperature_table[temperature_key] * humidity_table[humidity_key])
def one_day_hence():
return timezone.now() + timezone.timedelta(days=1)
def get_sidebar_tabs(request):
# setup tabs
hours = 24
hackathon_tabs = []
tabs = [{
'title': f"Everywhere",
'slug': 'everywhere',
'helper_text':
f'The activity feed items everywhere in the Gitcoin network',
'badge': get_amount_unread('everywhere', request),
}]
default_tab = 'everywhere'
if request.user.is_authenticated:
num_business_relationships = len(
set(get_my_earnings_counter_profiles(request.user.profile.pk)))
if num_business_relationships:
key = 'my_tribes'
new_tab = {
'title':
f"Relationships",
'slug':
key,
'helper_text':
f'Activity from the users who you\'ve done business with Gitcoin',
'badge':
max_of_ten(
get_specific_activities(key, False, request.user,
request.session.get(key,
0)).count())
if request.GET.get('tab') != key else 0
}
tabs = [new_tab] + tabs
default_tab = 'my_tribes'
num_grants_relationships = (len(
set(get_my_grants(request.user.profile))))
if num_grants_relationships:
key = 'grants'
new_tab = {
'title':
f'Grants',
'slug':
key,
'helper_text':
f'Activity on the Grants you\'ve created or funded.',
'badge':
max_of_ten(
get_specific_activities(key, False, request.user,
request.session.get(key,
0)).count())
if request.GET.get('tab') != key else 0
}
tabs = [new_tab] + tabs
default_tab = 'grants'
num_favorites = request.user.favorites.filter(grant=None).all().count()
if num_favorites:
key = 'my_favorites'
activities = get_specific_activities(key, False, request.user,
request.session.get(
key, 0)).count()
new_tab = {
'title':
f"My Favorites",
'slug':
key,
'helper_text':
f'Activity that you marked as favorite',
'badge':
max_of_ten(activities) if request.GET.get('tab') != key else 0
}
tabs = [new_tab] + tabs
default_tab = 'my_favorites'
threads_last_24_hours = max_of_ten(
request.user.profile.subscribed_threads.filter(
pk__gt=request.session.get('my_threads', 0)).count()
) if request.GET.get('tab') != 'my_threads' else 0
threads = {
'title': f"My Threads",
'slug': f'my_threads',
'helper_text':
f'The Threads that you\'ve liked, commented on, or sent a tip upon on Gitcoin since you last checked.',
'badge': threads_last_24_hours
}
tabs = [threads] + tabs
default_tab = 'connect'
connect = {
'title': f"Connect",
'slug': f'connect',
'helper_text':
f'The announcements, requests for help, kudos jobs, mentorship, or other connective requests on Gitcoin.',
'badge': get_amount_unread('connect', request),
}
tabs = [connect] + tabs
connect = {
'title': f"Kudos",
'slug': f'kudos',
'helper_text':
f'The Kudos that have been sent by Gitcoin community members, to show appreciation for one aother.',
'badge': get_amount_unread('kudos', request),
}
tabs = tabs + [connect]
start_date = timezone.now() + timezone.timedelta(days=28)
end_date = timezone.now() - timezone.timedelta(days=7)
hackathons = HackathonEvent.objects.filter(start_date__lt=start_date,
end_date__gt=end_date,
visible=True)
if hackathons.count():
for hackathon in hackathons:
connect = {
'title': hackathon.name,
'logo': hackathon.logo,
'start': hackathon.start_date,
'end': hackathon.end_date,
'slug': f'hackathon:{hackathon.pk}',
'url_slug': hackathon.slug,
'helper_text': f'Go to {hackathon.name} Townsquare.',
}
hackathon_tabs = [connect] + hackathon_tabs
# set tab
if request.COOKIES.get('tab'):
all_tabs = [tab.get('slug') for tab in tabs]
if request.COOKIES.get('tab') in all_tabs:
default_tab = request.COOKIES.get('tab')
tab = request.GET.get('tab', default_tab)
is_search = "activity:" in tab or "search-" in tab
if is_search:
tabs.append({
'title': "Search",
'slug': tab,
})
search = ''
if "search-" in tab:
search = tab.split('-')[1]
return tabs, tab, is_search, search, hackathon_tabs
from django.utils import formats, timezone
from django.utils.translation import ugettext_lazy as _
from django.utils.text import slugify
from model_utils.models import TimeStampedModel
from stdimage.models import StdImageField
from stdimage.utils import UploadToAutoSlug
from lib.models import (BaseAPIResource, AbstractLabel, NationBuilderResource,
ContactMixin, LocationMixin, ImageMixin,
DescriptionMixin, DescriptionField,
UploadToRelatedObjectDirectoryWithUUID,
UploadToInstanceDirectoryWithFilename)
from lib.form_fields import DateTimePickerWidget
EVENT_GRACE_PERIOD = timezone.timedelta(hours=12)
def upcoming_only(as_of):
return models.Q(end_time__gt=as_of - EVENT_GRACE_PERIOD)
def past_only(as_of):
return models.Q(end_time__lt=as_of)
class EventQuerySet(models.QuerySet):
def upcoming(self, as_of, published_only=True):
condition = upcoming_only(as_of)
if published_only:
condition &= models.Q(published=True)
def preprocess(request):
"""Handle inserting pertinent data into the current context."""
# make lbcheck super lightweight
if request.path == '/lbcheck':
return {}
from marketing.utils import get_stat
try:
num_slack = int(get_stat('slack_users'))
except Exception:
num_slack = 0
if num_slack > 1000:
num_slack = f'{str(round((num_slack) / 1000, 1))}k'
user_is_authenticated = request.user.is_authenticated
profile = request.user.profile if user_is_authenticated and hasattr(
request.user, 'profile') else None
email_subs = profile.email_subscriptions if profile else None
email_key = email_subs.first(
).priv if user_is_authenticated and email_subs and email_subs.exists(
) else ''
if user_is_authenticated and profile and profile.pk:
record_visit = not profile.last_visit or profile.last_visit < (
timezone.now() -
timezone.timedelta(seconds=RECORD_VISIT_EVERY_N_SECONDS))
if record_visit:
ip_address = get_ip(request)
profile.last_visit = timezone.now()
profile.save()
UserAction.objects.create(
user=request.user,
profile=profile,
action='Visit',
location_data=get_location_from_ip(ip_address),
ip_address=ip_address,
utm=_get_utm_from_cookie(request),
)
context = {
'STATIC_URL': settings.STATIC_URL,
'MEDIA_URL': settings.MEDIA_URL,
'num_slack': num_slack,
'github_handle':
request.user.username if user_is_authenticated else False,
'email': request.user.email if user_is_authenticated else False,
'name':
request.user.get_full_name() if user_is_authenticated else False,
'raven_js_version': settings.RAVEN_JS_VERSION,
'raven_js_dsn': settings.SENTRY_JS_DSN,
'release': settings.RELEASE,
'env': settings.ENV,
'email_key': email_key,
'profile_id': profile.id if profile else '',
'hotjar': settings.HOTJAR_CONFIG,
'ipfs_config': {
'host': settings.JS_IPFS_HOST,
'port': settings.IPFS_API_PORT,
'protocol': settings.IPFS_API_SCHEME,
'root': settings.IPFS_API_ROOT,
},
'access_token': profile.access_token if profile else '',
'is_staff': request.user.is_staff if user_is_authenticated else False,
'is_moderator': profile.is_moderator if profile else False,
}
context['json_context'] = json.dumps(context)
if context['github_handle']:
context['unclaimed_tips'] = Tip.objects.filter(
expires_date__gte=timezone.now(),
receive_txid='',
username__iexact=context['github_handle'],
web3_type='v3',
).send_happy_path()
context['unclaimed_kudos'] = KudosTransfer.objects.filter(
receive_txid='',
username__iexact="@" + context['github_handle'],
web3_type='v3',
).send_happy_path()
if not settings.DEBUG:
context['unclaimed_tips'] = context['unclaimed_tips'].filter(
network='mainnet')
context['unclaimed_kudos'] = context['unclaimed_kudos'].filter(
network='mainnet')
return context
def to_date(date, delta):
return date + timezone.timedelta(days=delta)
def cal_test(self):
print(timezone.now())
print(timezone.now() + timezone.timedelta())
def town_square(request):
# setup tabas
hours = 24 if not settings.DEBUG else 1000
posts_last_24_hours = lazy_round_number(Activity.objects.filter(created_on__gt=timezone.now() - timezone.timedelta(hours=hours)).count())
tabs = [{
'title': f"Everywhere",
'slug': 'everywhere',
'helper_text': f'The {posts_last_24_hours} activity feed items everywhere in the Gitcoin network',
'badge': posts_last_24_hours
}]
default_tab = 'everywhere'
if request.user.is_authenticated:
num_business_relationships = lazy_round_number(len(set(get_my_earnings_counter_profiles(request.user.profile.pk))))
if num_business_relationships:
new_tab = {
'title': f"Relationships",
'slug': 'my_tribes',
'helper_text': f'Activity from the {num_business_relationships} users who you\'ve done business with Gitcoin',
'badge': num_business_relationships
}
tabs = [new_tab] + tabs
default_tab = 'my_tribes'
num_grants_relationships = lazy_round_number(len(set(get_my_grants(request.user.profile))))
if num_grants_relationships:
new_tab = {
'title': f'Grants',
'slug': f'grants',
'helper_text': f'Activity on the {num_grants_relationships} Grants you\'ve created or funded.',
'badge': num_grants_relationships
}
tabs = [new_tab] + tabs
default_tab = 'grants'
hours = 24 if not settings.DEBUG else 1000
connect_last_24_hours = lazy_round_number(Activity.objects.filter(activity_type__in=['status_update', 'wall_post'], created_on__gt=timezone.now() - timezone.timedelta(hours=hours)).count())
if connect_last_24_hours:
default_tab = 'connect'
connect = {
'title': f"Connect",
'slug': f'connect',
'helper_text': f'The {connect_last_24_hours} announcements, requests for help, kudos jobs, mentorship, or other connective requests on Gitcoin in the last 24 hours.',
'badge': connect_last_24_hours
}
tabs = [connect] + tabs
kudos_last_24_hours = lazy_round_number(Activity.objects.filter(activity_type__in=['new_kudos', 'receive_kudos'], created_on__gt=timezone.now() - timezone.timedelta(hours=hours)).count())
if kudos_last_24_hours:
connect = {
'title': f"Kudos",
'slug': f'kudos',
'helper_text': f'The {kudos_last_24_hours} Kudos that have been sent by Gitcoin community members, to show appreciation for one aother.',
'badge': kudos_last_24_hours
}
tabs = tabs + [connect]
if request.user.is_authenticated:
hackathons = HackathonEvent.objects.filter(start_date__lt=timezone.now(), end_date__gt=timezone.now())
if hackathons.count():
user_registered_hackathon = request.user.profile.hackathon_registration.filter(registrant=request.user.profile, hackathon__in=hackathons).first()
if user_registered_hackathon:
default_tab = f'hackathon:{user_registered_hackathon.hackathon.pk}'
connect = {
'title': user_registered_hackathon.hackathon.name,
'slug': default_tab,
'helper_text': f'Activity from the {user_registered_hackathon.hackathon.name} Hackathon.',
}
tabs = [connect] + tabs
# set tab
if request.COOKIES.get('tab'):
all_tabs = [tab.get('slug') for tab in tabs]
if request.COOKIES.get('tab') in all_tabs:
default_tab = request.COOKIES.get('tab')
tab = request.GET.get('tab', default_tab)
is_search = "activity:" in tab or "search-" in tab
if is_search:
tabs.append({
'title': "Search",
'slug': tab,
})
search = ''
if "search-" in tab:
search = tab.split('-')[1]
# get offers
offer_pks = []
offers_by_category = {}
available_offers = Offer.objects.current()
if request.user.is_authenticated:
available_offers = available_offers.exclude(actions__profile=request.user.profile, actions__what__in=['click', 'decline', 'go'])
for key in ['top', 'secret', 'random', 'daily', 'weekly', 'monthly']:
next_time_available = get_next_time_available(key)
offers = available_offers.filter(key=key).order_by('-pk')
offer = offers.first()
for offer in offers:
offer_pks.append(offer.pk)
offers_by_category[key] = {
'offer': offer,
'offers': offers,
'time': next_time_available,
}
increment_offer_view_counts.delay(offer_pks)
# subscriber info
is_subscribed = False
if request.user.is_authenticated:
email_subscriber = request.user.profile.email_subscriptions.first()
if email_subscriber:
is_subscribed = email_subscriber.should_send_email_type_to('new_bounty_notifications')
# announcements
announcements = Announcement.objects.current().filter(key='townsquare')
# title
title = 'Home'
desc = 'View the recent activity on the Gitcoin network'
page_seo_text_insert = ''
avatar_url = ''
admin_link = ''
if "activity:" in tab:
try:
pk = int(tab.split(':')[1])
activity = Activity.objects.get(pk=pk)
title = f"@{activity.profile.handle}'s post on Gitcoin "
desc = f"{activity.text}"
comments_count = activity.comments.count()
admin_link = activity.admin_url
if comments_count:
title += f"(+ {comments_count} comments)"
avatar_url = activity.profile.avatar_url
page_seo_text_insert = desc
except Exception as e:
print(e)
# render page context
trending_only = int(request.GET.get('trending', 0))
context = {
'title': title,
'card_desc': desc,
'avatar_url': avatar_url,
'use_pic_card': True,
'page_seo_text_insert': page_seo_text_insert,
'nav': 'home',
'target': f'/activity?what={tab}&trending_only={trending_only}',
'tab': tab,
'tabs': tabs,
'admin_link': admin_link,
'now': timezone.now(),
'is_townsquare': True,
'trending_only': bool(trending_only),
'search': search,
'tags': [('#announce','bullhorn'), ('#mentor','terminal'), ('#jobs','code'), ('#help','laptop-code'), ('#other','briefcase'), ],
'announcements': announcements,
'is_subscribed': is_subscribed,
'offers_by_category': offers_by_category,
}
response = TemplateResponse(request, 'townsquare/index.html', context)
if request.GET.get('tab'):
if ":" not in request.GET.get('tab'):
response.set_cookie('tab', request.GET.get('tab'))
return response
def redeem_bulk_coupon(coupon, profile, address, ip_address, save_addr=False):
try:
address = Web3.toChecksumAddress(address)
except:
error = "You must enter a valid Ethereum address (so we know where to send your Kudos). Please try again."
return None, error, None
# handle form submission
kudos_transfer = None
if save_addr:
profile.preferred_payout_address = address
profile.save()
private_key = settings.KUDOS_PRIVATE_KEY if not coupon.sender_pk else coupon.sender_pk
kudos_owner_address = settings.KUDOS_OWNER_ACCOUNT if not coupon.sender_address else coupon.sender_address
gas_price_confirmation_time = 1 if not coupon.sender_address else 60
gas_price_multiplier = 1.5 if not coupon.sender_address else 1
kudos_contract_address = Web3.toChecksumAddress(
settings.KUDOS_CONTRACT_MAINNET)
kudos_owner_address = Web3.toChecksumAddress(kudos_owner_address)
w3 = get_web3(coupon.token.contract.network)
contract = w3.eth.contract(Web3.toChecksumAddress(kudos_contract_address),
abi=kudos_abi())
nonce = w3.eth.getTransactionCount(kudos_owner_address)
gas_price = int(
int(
recommend_min_gas_price_to_confirm_in_time(
gas_price_confirmation_time) * 10**9) * gas_price_multiplier)
tx = contract.functions.clone(
address, coupon.token.token_id, 1).buildTransaction({
'nonce':
nonce,
'gas':
500000,
'gasPrice':
gas_price,
'value':
int(coupon.token.price_finney / 1000.0 * 10**18),
})
if not profile.trust_profile and profile.github_created_on > (
timezone.now() - timezone.timedelta(days=7)):
error = f'Your github profile is too new. Cannot receive kudos.'
return None, error, None
else:
signed = w3.eth.account.signTransaction(tx, private_key)
retry_later = False
try:
txid = w3.eth.sendRawTransaction(signed.rawTransaction).hex()
except Exception as e:
txid = "pending_celery"
retry_later = True
with transaction.atomic():
kudos_transfer = KudosTransfer.objects.create(
emails=[profile.email],
# For kudos, `token` is a kudos.models.Token instance.
kudos_token_cloned_from=coupon.token,
amount=coupon.token.price_in_eth,
comments_public=coupon.comments_to_put_in_kudos_transfer,
ip=ip_address,
github_url='',
from_name=coupon.sender_profile.handle,
from_email='',
from_username=coupon.sender_profile.handle,
username=profile.handle,
network=coupon.token.contract.network,
from_address=kudos_owner_address,
is_for_bounty_fulfiller=False,
metadata={
'coupon_redemption': True,
'nonce': nonce
},
recipient_profile=profile,
sender_profile=coupon.sender_profile,
txid=txid,
receive_txid=txid,
tx_status='pending',
receive_tx_status='pending',
)
# save to DB
BulkTransferRedemption.objects.create(
coupon=coupon,
redeemed_by=profile,
ip_address=ip_address,
kudostransfer=kudos_transfer,
)
coupon.num_uses_remaining -= 1
coupon.current_uses += 1
coupon.save()
# user actions
record_user_action(kudos_transfer.username, 'new_kudos',
kudos_transfer)
record_user_action(kudos_transfer.from_username, 'receive_kudos',
kudos_transfer)
record_kudos_activity(kudos_transfer, kudos_transfer.username,
'receive_kudos')
# send email
maybe_market_kudos_to_email(kudos_transfer)
if retry_later:
from kudos.tasks import redeem_bulk_kudos
redeem_bulk_kudos.delay(kudos_transfer.id,
signed.rawTransaction.hex())
return True, None, kudos_transfer
def test_schedule_notice(self):
next_run = timezone.now() + timezone.timedelta(hours=1)
tasks.schedule_scheduling_notice(self.notice, next_run)
assert Schedule.objects.count() == 1
def stats(request):
# get param
_filter = request.GET.get('filter')
rollup = request.GET.get('rollup')
# types
types = list(Stat.objects.distinct('key').values_list('key', flat=True))
types.sort()
# filters
if _filter == 'Activity':
_filters = ['tip', 'bount']
types = filter_types(types, _filters)
if _filter == 'Marketing':
_filters = ['slack', 'email', 'whitepaper', 'twitter']
types = filter_types(types, _filters)
if _filter == 'KPI':
_filters = [
'browser_ext_chrome',
'medium_subscribers',
'github_stargazers_count',
'slack_users',
'email_subscribers_active',
'bounties_open',
'bounties_ful',
'joe_dominance_index_30_count',
'joe_dominance_index_30_value',
'turnaround_time_hours_30_days_back',
'tips',
'twitter',
'user_action_Login',
]
types = filter_types(types, _filters)
# params
params = {
'types': types,
'chart_list': [],
'filter_params': "?filter={}&rollup={}".format(_filter, rollup),
}
for t in types:
source = Stat.objects.filter(key=t)
if rollup == 'daily':
source = source.filter(created_on__hour=1)
source = source.filter(
created_on__gt=(timezone.now() - timezone.timedelta(days=30)))
elif rollup == 'weekly':
source = source.filter(created_on__hour=1, created_on__week_day=1)
source = source.filter(
created_on__gt=(timezone.now() -
timezone.timedelta(days=30 * 3)))
else:
source = source.filter(created_on__gt=(timezone.now() -
timezone.timedelta(days=2)))
# compute avg
total = 0
count = source.count() - 1
avg = "NA"
if count > 1:
for i in range(0, count):
total += (source[i + 1].val - source[i].val)
avg = round(total / count, 1)
avg = str("+{}".format(avg) if avg > 0 else avg)
chartdata = DataPool(series=[{
'options': {
'source': source
},
'terms': ['created_on', 'val']
}])
cht = Chart(datasource=chartdata,
series_options=[{
'options': {
'type': 'line',
'stacking': False
},
'terms': {
'created_on': ['val']
}
}],
chart_options={
'title': {
'text': f'{t} trend ({avg} avg)'
},
'xAxis': {
'title': {
'text': 'Time'
}
}
})
params['chart_list'].append(cht)
params['chart_list_str'] = ",".join(types)
return TemplateResponse(request, 'stats.html', params)
def render_filter_ele(condtion, admin_class, filter_condtions, request):
table_name = admin_class.model._meta.verbose_name
req = str(request)
num = req.find('sta')
if num > 0:
sta = req[num + 4:num + 5]
else:
sta = ''
if condtion == 'status' and sta == '0':
select_ele = ''
elif table_name == '项目流程' and condtion == 'department' and request.user.is_superuser == False:
select_ele = ''
elif table_name == '任务类型' and condtion == 'department' and request.user.is_superuser == False:
select_ele = ''
elif table_name == '项目类型' and condtion == 'department' and request.user.is_superuser == False:
select_ele = ''
elif table_name == '用户' and condtion == 'department' and request.user.is_superuser == False:
select_ele = ''
else:
if condtion == 'project':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">所属项目</option>'''
elif condtion == 'status':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">状态</option>'''
elif condtion == 'department' or condtion == 'department_id':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">所属部门</option>'''
elif condtion == 'tag':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">项目所属</option>'''
elif condtion == 'is_active':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">账号状态</option>'''
elif condtion == 'is_pass':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">状态</option>'''
elif condtion == 'type':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">延期类型</option>'''
elif condtion == 'postfix':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">文件类型</option>'''
elif condtion == 'created_time':
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">创建时间</option>'''
else:
select_ele = '''<select class="form-control m-t-10" name='{filter_field}' ><option value='' style="display:none;">------</option>'''
field_obj = admin_class.model._meta.get_field(condtion)
if condtion == 'type':
if filter_condtions.get(condtion) == '任务延期':
select1 = "<option value='任务延期' selected>任务延期</option>"
select2 = "<option value='项目延期'>项目延期</option>"
select3 = "<option value='节点延期'>节点延期</option>"
elif filter_condtions.get(condtion) == '项目延期':
select1 = "<option value='任务延期'>任务延期</option>"
select2 = "<option value='项目延期' selected>项目延期</option>"
select3 = "<option value='节点延期'>节点延期</option>"
elif filter_condtions.get(condtion) == '节点延期':
select1 = "<option value='任务延期'>任务延期</option>"
select2 = "<option value='项目延期'>项目延期</option>"
select3 = "<option value='节点延期' selected>节点延期</option>"
else:
select3 = "<option value='节点延期'>节点延期</option>"
select1 = "<option value='任务延期'>任务延期</option>"
select2 = "<option value='项目延期'>项目延期</option>"
select_ele += select3 + select1 + select2
if condtion == 'postfix':
files = project.File.objects.filter(existent=1)
postfixs = []
for file in files:
postfixs.append(file.postfix)
postfixs = list(set(postfixs))
for postfix in postfixs:
if filter_condtions.get(condtion) == postfix:
selected = "selected"
else:
selected = ''
select_ele += '''<option value='%s' %s>%s</option>''' % (
postfix, selected, postfix)
if field_obj.choices:
for choice_item in field_obj.choices:
li = []
if condtion == 'status':
if sta == '1':
li = [0, 3, 4]
elif sta == '3':
li = [0, 1, 2, 5]
if choice_item[0] not in li:
if filter_condtions.get(condtion) == str(choice_item[0]):
selected = "selected"
else:
selected = ''
select_ele += '''<option value='%s' %s>%s</option>''' % (
choice_item[0], selected, choice_item[1])
if type(field_obj).__name__ == "NullBooleanField":
if filter_condtions.get(condtion) == '1':
select1 = "<option value='1' selected>已通过</option>"
select2 = "<option value='0'>已拒绝</option>"
select3 = "<option value='None'>待审核</option>"
elif filter_condtions.get(condtion) == '0':
select1 = "<option value='1'>已通过</option>"
select2 = "<option value='0' selected>已拒绝</option>"
select3 = "<option value='None'>待审核</option>"
elif filter_condtions.get(condtion) == 'None':
select1 = "<option value='1'>已通过</option>"
select2 = "<option value='0'>未通过</option>"
select3 = "<option value='None' selected>待审核</option>"
else:
select3 = "<option value='None' >待审核</option>"
select1 = "<option value='1'>已通过</option>"
select2 = "<option value='0'>已拒绝</option>"
select_ele += select3 + select1 + select2
if type(field_obj).__name__ == "BooleanField":
if filter_condtions.get(condtion) == '1':
select1 = "<option value='1' selected>正常</option>"
select2 = "<option value='0'>禁用</option>"
elif filter_condtions.get(condtion) == '0':
select1 = "<option value='1'>正常</option>"
select2 = "<option value='0' selected>禁用</option>"
else:
select1 = "<option value='1'>正常</option>"
select2 = "<option value='0'>禁用</option>"
select_ele += select1 + select2
if type(field_obj).__name__ == "ForeignKey":
selected = ''
for choice_item in field_obj.get_choices()[1:]:
if filter_condtions.get(condtion) == str(choice_item[0]):
selected = "selected"
select_ele += '''<option value='%s' %s>%s</option>''' % (
choice_item[0], selected, choice_item[1])
selected = ''
if type(field_obj).__name__ in ['DateTimeField', 'DateField']:
date_els = []
today_ele = datetime.datetime.now().date()
date_els.append(['今天', datetime.datetime.now().date()])
# date_els.append(['昨天', today_ele - timedelta(days=1)])
date_els.append(['7天内', today_ele - timedelta(days=7)])
date_els.append(['15天内', today_ele - timedelta(days=15)])
date_els.append(['一个月内', today_ele - timedelta(days=30)])
date_els.append(['三个月内', today_ele - timedelta(days=30)])
date_els.append(['半年内', today_ele - timedelta(days=180)])
date_els.append(['一年内', today_ele - timedelta(days=365)])
# date_els.append(['mtd_ele', today_ele.replace(day=1)])
# date_els.append(['ytd_ele', today_ele.replace(month=1, day=1)])
filter_field_name = "%s__gte" % condtion
for item in date_els:
if str(item[1]) == str(
filter_condtions.get(filter_field_name)):
selected = 'selected'
else:
selected = ''
select_ele += '''<option value='%s' %s>%s</option>''' % (
item[1], selected, item[0])
else:
filter_field_name = condtion
select_ele += "</select>"
select_ele = select_ele.format(filter_field=filter_field_name)
return mark_safe(select_ele)
def setUp(self):
# Users -------
self.user1 = User.objects.create_user(email="*****@*****.**",
password="******")
self.user1.is_admin = False
self.user1.set_user_type_student()
self.user2 = User.objects.create_user(email="*****@*****.**",
password="******")
self.user2.is_admin = False
self.user2.set_user_type_student()
# Countries -------
self.country1 = Country.objects.create(name="country1",
slug="country1",
picture=None)
self.country2 = Country.objects.create(name="country2",
slug="country2",
picture=None)
# Universities -------
self.university1 = University.objects.create(name="university1",
country=self.country1,
description="Test desc1",
picture=None,
slug="university1")
self.university2 = University.objects.create(name="university2",
country=self.country2,
description="Test desc2",
picture=None,
slug="university2")
# Field of Studies -------
self.field_of_study1 = FieldOfStudy.objects.create(
name="field of study1",
description="Test desc1",
picture=None,
slug="field-of-study1")
self.field_of_study2 = FieldOfStudy.objects.create(
name="field of study2",
description="Test desc2",
picture=None,
slug="field-of-study2")
# Consultants -------
self.consultant1 = User.objects.create_user(email="*****@*****.**",
password="******")
self.consultant1.is_admin = False
self.consultant1.set_user_type_consultant()
self.consultant1_profile = ConsultantProfile.objects.create(
user=self.consultant1,
bio="bio1",
profile_picture=None,
aparat_link="https://www.aparat.com/v/vG4QC",
resume=None,
slug="consultant1",
active=True,
time_slot_price=100)
self.consultant1_profile.universities.set(
[self.university1, self.university2])
self.consultant1_profile.field_of_studies.set([self.field_of_study1])
self.consultant1_profile.countries.set([self.country1])
self.consultant2 = User.objects.create_user(email="*****@*****.**",
password="******")
self.consultant2.is_admin = False
self.consultant2.set_user_type_consultant()
self.consultant2_profile = ConsultantProfile.objects.create(
user=self.consultant2,
bio="bio2",
profile_picture=None,
aparat_link="https://www.aparat.com/v/vG4QC",
resume=None,
slug="consultant2",
active=True,
time_slot_price=80)
# TimeSlotSales -------
self.time_slot_sale1 = TimeSlotSale.objects.create(
consultant=self.consultant1_profile,
start_time=timezone.now() + timezone.timedelta(hours=1),
end_time=timezone.now() + timezone.timedelta(hours=2),
price=self.consultant1_profile.time_slot_price)
self.time_slot_sale2 = TimeSlotSale.objects.create(
consultant=self.consultant1_profile,
start_time=timezone.now() + timezone.timedelta(hours=2),
end_time=timezone.now() + timezone.timedelta(hours=3),
price=self.consultant1_profile.time_slot_price)
self.time_slot_sale3 = TimeSlotSale.objects.create(
consultant=self.consultant1_profile,
start_time=timezone.now() + timezone.timedelta(days=1),
end_time=timezone.now() + timezone.timedelta(days=1, hours=1),
price=self.consultant1_profile.time_slot_price)
self.time_slot_sale4 = TimeSlotSale.objects.create(
consultant=self.consultant2_profile,
start_time=timezone.now() + timezone.timedelta(hours=1),
end_time=timezone.now() + timezone.timedelta(hours=2),
price=self.consultant2_profile.time_slot_price)
self.time_slot_sale5 = TimeSlotSale.objects.create(
consultant=self.consultant2_profile,
start_time=timezone.now() + timezone.timedelta(hours=7),
end_time=timezone.now() + timezone.timedelta(hours=8),
price=self.consultant2_profile.time_slot_price)
# Carts -------
self.cart1 = Cart.objects.create(user=self.user1)
self.cart1.products.set([self.time_slot_sale1, self.time_slot_sale2])
self.cart2 = Cart.objects.create(user=self.user1)
self.cart2.products.set([self.time_slot_sale1, self.time_slot_sale3])
self.cart3 = Cart.objects.create(user=self.user2)
self.cart3.products.set([self.time_slot_sale1, self.time_slot_sale5])
# Consultant discounts
self.consultant_discount1 = ConsultantDiscount.objects.create(
percent=10,
code="discountcode1",
)
self.consultant_discount1.consultants.set(
[self.consultant1_profile, self.consultant2_profile])
self.consultant_discount2 = ConsultantDiscount.objects.create(
percent=20,
code="discountcode2",
)
self.consultant_discount2.consultants.set([
self.consultant1_profile,
])
# Cart consultant discounts
self.cart_consultant_discount1 = CartConsultantDiscount.objects.create(
cart=self.cart1, consultant_discount=self.consultant_discount1)
self.consultant_comment1 = ConsultantComment.objects.create(
user=self.user1,
consultant=self.consultant1_profile,
message="Message 1")
self.consultant_comment2 = ConsultantComment.objects.create(
user=self.user1,
consultant=self.consultant2_profile,
message="Message 2")
self.consultant_comment3 = ConsultantComment.objects.create(
user=self.user2,
consultant=self.consultant2_profile,
message="Message 3")
self.consultant_admin_comment1 = ConsultantAdminComment.objects.create(
comment=self.consultant_comment1, message="Admin message 1")
self.consultant_admin_comment2 = ConsultantAdminComment.objects.create(
comment=self.consultant_comment2, message="Admin message 2")
self.sold_time_slot_sale1 = SoldTimeSlotSale.objects.create(
sold_to=self.user1,
consultant=self.consultant1_profile,
start_time=timezone.now() + timezone.timedelta(days=2),
end_time=timezone.now() + timezone.timedelta(days=2, hours=1),
price=self.consultant1_profile.time_slot_price)
self.sold_time_slot_sale2 = SoldTimeSlotSale.objects.create(
sold_to=self.user2,
consultant=self.consultant1_profile,
start_time=timezone.now() + timezone.timedelta(days=2, hours=1),
end_time=timezone.now() + timezone.timedelta(days=2, hours=2),
price=self.consultant1_profile.time_slot_price)
self.sold_time_slot_sale3 = SoldTimeSlotSale.objects.create(
sold_to=self.user2,
consultant=self.consultant2_profile,
start_time=timezone.now() + timezone.timedelta(days=2),
end_time=timezone.now() + timezone.timedelta(days=2, hours=1),
price=self.consultant2_profile.time_slot_price)
self.sold_time_slot_rate_1 = SoldTimeSlotRate.objects.create(
sold_time_slot=self.sold_time_slot_sale1, rate=4)
self.sold_time_slot_rate_2 = SoldTimeSlotRate.objects.create(
sold_time_slot=self.sold_time_slot_sale2, rate=2.5)
self.room1 = Room.objects.create(
sold_time_slot=self.sold_time_slot_sale1, )
self.room2 = Room.objects.create(
sold_time_slot=self.sold_time_slot_sale2)
# Setup ------
self.client = APIClient()
PAYERS = 'payers'
EARNERS = 'earners'
ORGS = 'orgs'
KEYWORDS = 'keywords'
TOKENS = 'tokens'
COUNTRIES = 'countries'
CITIES = 'cities'
CONTINENTS = 'continents'
TIMES = [ALL, WEEKLY, QUARTERLY, YEARLY, MONTHLY]
BREAKDOWNS = [
FULFILLED, ALL, PAYERS, EARNERS, ORGS, KEYWORDS, TOKENS, COUNTRIES, CITIES,
CONTINENTS
]
WEEKLY_CUTOFF = timezone.now() - timezone.timedelta(
days=(30 if settings.DEBUG else 7))
MONTHLY_CUTOFF = timezone.now() - timezone.timedelta(days=30)
QUARTERLY_CUTOFF = timezone.now() - timezone.timedelta(days=90)
YEARLY_CUTOFF = timezone.now() - timezone.timedelta(days=365)
def default_ranks():
"""Generate a dictionary of nested dictionaries defining default ranks.
Returns:
dict: A nested dictionary mapping of all default ranks with empty dicts.
"""
return_dict = {}
for time in TIMES:
for breakdown in BREAKDOWNS:
def create_excel(model, records_id, request_id):
if model == "record":
records = Record.objects.filter(id__in=records_id)
elif model == "recordoks":
records = RecordOks.objects.filter(id__in=records_id)
user = User.objects.get(pk=request_id)
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('Выборка')
ws.col(0).width = 256 * 36
ws.col(3).width = 256 * 22
ws.col(6).width = 256 * 18
ws.col(8).width = 256 * 12
ws.col(9).width = 256 * 32
ws.col(10).width = 256 * 12
row_num = 0
font_style = xlwt.XFStyle()
font_style.font.bold = True
columns = [
'Дата размещение объявления', 'Цена', 'Площадь', 'Кадастровый номер',
'Адрес', 'Описание', 'Номер телефона', 'Сайт', 'URL',
'Дата обращение к странице сайта', 'Скриншоты'
]
for i, column in enumerate(columns):
ws.write(row_num, i, column, font_style)
columns = [
'DEAL_DATE', 'DEAL_PRICE', 'VALUE', 'CADASTRAL_NUMBER', 'REGION'
]
row_num += 1
for i, column in enumerate(columns):
ws.write(row_num, i, column, font_style)
for record in records:
row_num += 1
if record.date_added:
date_added = datetime.strftime(record.date_added, "%Y-%m-%d")
else:
date_added = ""
if record.source_date_added:
source_date_added = datetime.strftime(record.source_date_added,
"%Y-%m-%d")
else:
source_date_added = ""
file = record.get_file()
if file:
file = file.split("/")[-1]
record_list = [
source_date_added,
str(record.price_rub).replace(".", ","),
str(record.area).replace(".", ","), record.cadastre_number,
record.raw_address, record.raw_text, record.phone_number,
record.site, record.source_url, date_added, file
]
for index, record_write in enumerate(record_list):
ws.write(row_num, index, record_write)
path = f"ziparchive/{records.count()}_{timezone.now()}.xls"
wb.save(os.path.abspath(path))
user_file = UserFiles.objects.create(
user=user,
date_create=timezone.now(),
is_active=True,
count_files=records.count(),
status="Готово",
file=f"ziparchive/{path.split('/')[-1]}",
date_expired=timezone.now() + timezone.timedelta(days=1))
def uretimkontrol(request):
mac = request.user_agent.os.family
ip = get_client_ip(request)
ip == '192.168.1.36'
grup = request.user.grup
birim = request.user.birim
#Uretim.objects.all().delete() #Test sonuçlarını silmek için bu yorumu açabilirsiniz
fullname = request.user.first_name + ' ' + request.user.last_name
if request.method == 'POST':
if request.POST.dict()['tur'] == 'valfmontaj':
veris = json.loads(request.POST.dict()['veri'])
print(veris)
t = Uretim(tur='valfmontaj',
okunan_deger=veris[0],
personel=request.user.get_full_name())
t.save(force_insert=True)
b = Bildirim(tur="baslangic", kisi=request.user.get_full_name())
b.save(force_insert=True)
elif request.POST.dict()['tur'] == 'kurlenme':
veris = json.loads(request.POST.dict()['veri'])
'''neval
if not Uretim.objects.all():
vsn = 1
else:
a = Uretim.objects.all().order_by('-vsn').values()[0]
s = a['vsn']
vsn = s + 1
v = Valf(vsn=vsn, is_emri=veris[0])
v.save(force_insert=True)
e = Emir.objects.get(is_emri=veris[0])
e.durum = 'Aktif'
e.save()
t = Uretim(tur='montaj_kurlenme' ,vsn = vsn, is_emri = veris[0] ,personel = request.user.get_full_name(),alt_nipel_no = veris[1],bakir_membran_no = veris[2],ust_nipel_no = veris[3],manometre_no = veris[4],basincanahtari_no = veris[5],montaj_kurlenme_zamani=timezone.now()+timezone.timedelta(minutes=10))
t.save(force_insert=True)
return HttpResponse(str(vsn))
'''
print("deneme")
e = Emir.objects.get(is_emri=veris[0])
e.durum = 'Aktif'
e.save()
is_emri_adi = veris[0]
emir = Emir.objects.get(is_emri=is_emri_adi)
personel_id = request.user.id
alt_nipel_no = veris[1]
bakir_membran_no = veris[2]
ust_nipel_no = veris[3]
manometre_no = veris[4]
basincanahtari_no = veris[5]
print("deneme2")
try:
kayit_tarihi = timezone.now()
kurlenme_bitis = timezone.now() + timezone.timedelta(
minutes=10)
valf_montaj = Valf_montaj(montaj_personel_id=personel_id,
alt_nipel_no=alt_nipel_no,
bakir_membran_no=bakir_membran_no,
ust_nipel_no=ust_nipel_no,
manometre_no=manometre_no,
basincanahtari_no=basincanahtari_no,
montaj_tarihi=kayit_tarihi,
kurlenme_bitis_tarihi=kurlenme_bitis)
valf_montaj.save()
valf = Valf(is_emri=emir, valf_montaj=valf_montaj)
valf.save()
return HttpResponse(str(valf.id))
except Exception as err:
print(" KAyıt HAstası > ", err)
elif request.POST.dict()['tur'] == 'valftest':
try:
valf_seri_no = json.loads(request.POST.dict()['valf_seri_no'])
uygun = json.loads(request.POST.dict()['uygun'])
valf = Valf.objects.get(id=valf_seri_no)
personel_id = User.objects.get(id=request.user.id)
test_tarihi = timezone.now()
acma = str(uygun)
kapama = str(uygun)
sebep = str(uygun)
if (uygun == True):
sebep = None
valf_test = Valf_test(test_personel=personel_id,
test_tarihi=test_tarihi,
uygun=uygun)
valf_test.save()
valf.valf_test = valf_test
valf.save()
except Exception as err:
print(err)
elif request.POST.dict()['tur'] == 'valfgovde':
veri = json.loads(request.POST.dict()['veri'])
'''neval
v = Valf.objects.get(vsn=veri[3])
is_emri = v.is_emri
print('veri[5],sodyum miktarı:: ',veri[5] )
t = Uretim.objects.get(vsn=veri[3])
t.tur='govde_kurlenme'
t.tork_degeri = veri[0]
t.uygunluk = veri[1]
t.sebep = veri[2]
t.tsn = veri[4]
t.personel = request.user.get_full_name()
t.govde_kurlenme_zamani=timezone.now()+timezone.timedelta(minutes=10)
# t = Uretim(tur='valfgovde',tork_degeri = veri[0] ,is_emri=is_emri, uygunluk = veri[1] , sebep = veri[2],
# vsn = veri[3],tsn = veri[4], personel = request.user.get_full_name(),govde_kurlenme_zamani=timezone.now()+timezone.timedelta(minutes=10))
t.save()
'''
valf_seri_no = veri[3]
valf = Valf.objects.get(id=valf_seri_no)
valf.durum = 'valf_govde'
valf.save()
personel_id = request.user.id
kayit_tarihi = timezone.now()
kurlenme_bitis = timezone.now() + timezone.timedelta(minutes=10)
tork = veri[0]
tup_seri_no = veri[4]
sodyum_miktari = veri[5]
uygunluk = veri[1]
sebep = veri[2]
if (uygunluk == 'on'):
sebep = None
valf_govde = Valf_govde(valf=valf,
personel_id=personel_id,
kayit_tarihi=kayit_tarihi,
kurlenme_bitis=kurlenme_bitis,
tork=tork,
tup_seri_no=tup_seri_no,
sodyum_miktari=sodyum_miktari,
uygunluk=uygunluk,
sebep=sebep)
valf_govde.save()
elif request.POST.dict()['tur'] == 'fm200':
veri = json.loads(request.POST.dict()['veri'])
'''neval
v = Valf.objects.get(vsn=veri[4])
is_emri = v.is_emri
print(veri)
t = Uretim.objects.get(vsn=veri[4])
t.tur='fm200_kurlenme'
t.bos_agirlik = veri[0]
t.rekorlu_agirlik = veri[1]
t.fm200 = veri[2]
t.azot = veri[3]
t.personel = request.user.get_full_name()
t.fm200_kurlenme_zamani=timezone.now()+timezone.timedelta(minutes=10)
t.save()
'''
valf_seri_no = veri[4]
valf = Valf.objects.get(id=valf_seri_no)
valf.durum = 'valf_fm200'
valf.save()
personel_id = request.user.id
kayit_tarihi = timezone.now()
kurlenme_bitis = timezone.now() + timezone.timedelta(minutes=10)
bos_agirlik = veri[0]
rekorlu_agirlik = veri[1]
fm200 = veri[2]
azot = veri[3]
valf_fm200 = Valf_fm200(valf=valf,
personel_id=personel_id,
kayit_tarihi=kayit_tarihi,
kurlenme_bitis=kurlenme_bitis,
bos_agirlik=bos_agirlik,
rekorlu_agirlik=rekorlu_agirlik,
fm200=fm200,
azot=azot)
valf_fm200.save()
elif request.POST.dict()['tur'] == 'havuztest':
veri = json.loads(request.POST.dict()['veri'])
'''neval
print(veri)
v = Valf.objects.get(vsn=veri[0])
is_emri = v.is_emri
t = Uretim(tur='havuztest',vsn = veri[0],tsn = veri[0],is_emri=is_emri , uygunluk = veri[1] ,
acma = veri[2], kapatma = veri[3],sebep = veri[4], personel = request.user.get_full_name())
t.save(force_insert=True)
'''
print("veri", veri)
valf_seri_no = veri[0]
valf = Valf.objects.get(id=valf_seri_no)
valf.durum = 'valf_havuz_test'
valf.save()
personel_id = request.user.id
kayit_tarihi = timezone.now()
uygunluk = veri[1]
tup_cidar_sicaklik = veri[2]
tup_basinc = veri[3]
sebep = veri[4]
if (uygunluk):
sebep = None
valf_havuz = Valf_havuz(valf=valf,
personel_id=personel_id,
kayit_tarihi=kayit_tarihi,
tup_cidar_sicaklik=tup_cidar_sicaklik,
tup_basinc=tup_basinc,
uygunluk=uygunluk,
sebep=sebep)
valf_havuz.save()
elif request.POST.dict()['tur'] == 'finalmontaj':
veri = json.loads(request.POST.dict()['veri'])
'''neval
print(veri)
v = Valf.objects.get(vsn=veri[1])
is_emri = v.is_emri
t = Uretim.objects.get(vsn=veri[1])
t.tur='finalmontaj'
t.etiket_seri_no = veri[0]
t.fsn = veri[2]
t.funye_seri_omaj = veri[3]
t.basinc_anahtari_omaj = veri[4]
t. personel = request.user.get_full_name()
#t = Uretim(tur='finalmontaj',etiket_seri_no = veri[0],is_emri=is_emri , vsn = veri[1] , fsn = veri[2],
# funye_seri_omaj = veri[3],basinc_anahtari_omaj = veri[4], personel = request.user.get_full_name())
t.save()
tup_sayisi_str=Emir.objects.filter(is_emri=is_emri).values()[0]['tup_sayisi']
'''
valf_seri_no = veri[1]
valf = Valf.objects.get(id=valf_seri_no)
valf.durum = 'valf_final_montaj'
valf.save()
personel_id = request.user.id
kayit_tarihi = timezone.now()
etiket_seri_no = veri[0]
funye_seri_no = veri[2]
funye_seri_omaj = veri[3]
basinc_anahtari_omaj = veri[4]
valf_final_montaj = Valf_final_montaj(
valf=valf,
personel_id=personel_id,
kayit_tarihi=kayit_tarihi,
etiket_seri_no=etiket_seri_no,
funye_seri_no=funye_seri_no,
funye_seri_omaj=funye_seri_omaj,
basinc_anahtari_omaj=basinc_anahtari_omaj)
valf_final_montaj.save()
emir = Emir.objects.get(is_emri=valf.is_emri)
emir_tup_sayisi = int(emir.tup_sayisi)
emir_biten_valf_sayi = Valf.objects.filter(
is_emri=emir, durum='valf_final_montaj').count()
print('emir_biten_valf_sayi', emir_biten_valf_sayi)
print('emir_tup_sayisi', emir_tup_sayisi)
if (emir_biten_valf_sayi == emir_tup_sayisi):
emir.durum = 'Bitmiş'
emir.save()
b = Bildirim(tur="bitis", kisi=request.user.get_full_name())
b.save(force_insert=True)
now = timezone.now()
#montajkurlenmesi=Valf_montaj.objects.filter(kurlenme_bitis_tarihi__gte=now)
montajkurlenmesi = Valf_montaj.objects.all()
# govdekurlenmesi=Valf_govde.objects.filter(kurlenme_bitis__gte=now)
fm200kurlenmesi = Valf_fm200.objects.filter(
fm200_kurlenme_bitis_tarihi__gte=now)
acikemirleri = Emir.objects.filter(durum__in=("Aktif", "Başlanmamış"))
aktifemirler = Emir.objects.filter(durum="Aktif")
####Duplikasyonu önlemek için yaptık ###############
govde_emir = list(
dict.fromkeys(
Valf.objects.filter(valf_govde_id__isnull=False).values_list(
'is_emri_id', flat=True)))
###################################################
#return render(request,'uretim-kontrol.html',{ 'acikemirleri':acikemirleri, 'grup': grup, 'birim': birim, 'ip': ip,'now':now, 'kurlenmes':montajkurlenmesi,'fm200kurlenmes':fm200kurlenmesi, 'govdekurlenmes': govdekurlenmesi ,'server' : server})
return render(
request, 'uretim-kontrol.html', {
'grup': grup,
'birim': birim,
'ip': ip,
'now': now,
'server': server,
'acikemirleri': acikemirleri,
'fm200kurlenmes': fm200kurlenmesi,
'kurlenmes': montajkurlenmesi,
'aktifemirler': aktifemirler,
'govde_emir': govde_emir
})
def is_expired(self) -> bool:
"""Check if invite is older than INVITE_DAYS_VALIDITY days."""
return self.created_at < timezone.now() - timezone.timedelta(
INVITE_DAYS_VALIDITY)
def starting_within(self, days=0, weeks=0):
today = timezone.now()
today_with_range = today + timezone.timedelta(days=days, weeks=weeks)
return self.filter(start_date__range=(today, today_with_range))
def downloader(url, using_tor=True):
urls_bulk = []
print 'downloading {}'.format(url)
outlink_obj, created = OutLink.objects.get_or_create(url=url)
if url.startswith("mailto"):
return
# ################### CHECK DOMAIN TIMEOUT ########################
url_parse_object = urlparse(url)
domain_string = url_parse_object.netloc
try:
domain, created = Domain.objects.get_or_create(domain=domain_string)
if not created and domain.timeout and domain.last_attemp:
if domain.last_attempt + timezone.timedelta(
seconds=settings.REQUEST_DOMAIN_FALLBACK_TIME
) < timezone.now():
print('still in timeout')
return
except Exception as e:
print "something went wrong at while checking if domain in timeout: {}".format(
url)
return
if outlink_obj.download_status != OutLink.DownloadStatus.Completed:
try:
Page.objects.using('pages').get(url_hash=get_url_hash(url))
outlink_obj.download_status = True
outlink_obj.save()
print 'outlink download status changed'
return
except Page.DoesNotExist:
session = requests.session()
session.headers = {
'User-Agent':
user_agents[random.randint(0,
len(user_agents) - 1)]
}
if using_tor:
session.proxies = {
'http': 'socks5h://localhost:9050',
'https': 'socks5h://localhost:9050'
}
response = session.get(url)
else:
response = session.get(url)
if response.status_code == 200:
soup = Soup(url, response)
if soup.soup:
outlink_obj.download_status = OutLink.DownloadStatus.Completed
outlink_obj.save()
page, created = Page.objects.using('pages').get_or_create(
url=url, content=soup.html)
# print 'Page object created {}'.format(url)
if not created:
return
external_urls = soup.get_absolute_internal_links()
for url in external_urls:
if url.startswith("mailto") or url.startswith(
"tel:") or url.startswith("javascript:"):
continue
elif '#' in url:
if urlparse(url).path == url_parse_object.path:
continue
url = url.split('#')[0]
url_hash = get_url_hash(url)
# ### for performance boosting keep some local info about the outlinks.
# If the outlink exists locally then do not write at the remote DB. This will make the
# remote less busy.
outlink, created = OutLink.objects.using(
'pages').get_or_create(url_hash=url_hash, url=url)
if created:
urls_bulk.append(url)
try:
for url in urls_bulk:
OutLink.objects.create(url=url)
except Exception as e:
print(e)
print '{} outlinks created '.format(len(urls_bulk))
elif 300 <= response.status_code < 400:
outlink_obj.download_status = True
outlink_obj.is_300 = True
elif 400 <= response.status_code < 500:
outlink_obj.download_status = True
outlink_obj.is_404 = True
elif 500 <= response.status_code < 600:
outlink_obj.download_status = True
outlink_obj.is_500 = True
else:
outlink_obj.download_status = True
outlink_obj.save()
def test_complete_model_is_complete(self):
target = Task()
target.complete_time = timezone.now() - timezone.timedelta(days=1)
self.assertTrue(target.is_complete)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
five_min_delta = timezone.now() - timezone.timedelta(minutes=5)
animal = self.model.objects.filter(pk=self.kwargs['pk'])
context['visit_in_five_min'] = animal.filter(visitinganimals__visit_time__gte=five_min_delta).count()
return context
def active_invites(self) -> QuerySet:
return self.invites.filter(
created_at__gte=timezone.now() -
timezone.timedelta(days=INVITE_DAYS_VALIDITY))
