def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
self._endDate = ccbd(instance.time,
timedelta(days=0),
specific_hour=23) + timedelta(minutes=59)
elif instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=16)
return self
def enquiry_switch_to_active_qualification(test_case):
# end active.enquiry Period
# chronograph check
# minNumberOfQualifiedBids = 1
# if is 1 bid in status 'active'
# switch procedure to 'active.qualification'
context = test_case.procedure.snapshot(fixture=END_ACTIVE_ENQUIRY_AUCTION_QUALIFICATION)
bid = context['bids'][0]
auction = context['auction']
entrypoint = '/auctions/{}'.format(auction['data']['id'])
# get auctionPeriod.enquiryPeriod.EndDate
response = test_case.app.get(entrypoint)
data = response.json['data']
enquiry_end = parse_date(data['enquiryPeriod']['endDate'])
# simulate enquiryPeriod.endDate
with freeze_time(enquiry_end):
request_data = {'data': {'id': auction['data']['id']}}
response = test_case.app.patch_json(entrypoint, request_data)
test_case.assertEqual(response.status, '200 OK')
test_case.assertEqual(response.json['data']["status"], 'active.qualification')
response = test_case.app.get('/auctions/{}/awards'.format(auction['data']['id']))
# check generated award
awards = response.json['data']
award = awards[0]
test_case.assertEqual(len(awards), 1)
test_case.assertIsNotNone(award.get('verificationPeriod'))
test_case.assertIsNotNone(award.get('signingPeriod'))
test_case.assertEqual(award['status'], 'pending')
test_case.assertEqual(award['bid_id'], bid['data']['id'])
# check generated verificationPeriod
entrypoint = '/auctions/{}'.format(auction['data']['id'])
response = test_case.app.get(entrypoint)
auction = response.json['data']
enquiryPeriod_end_date = parse_date(auction['enquiryPeriod']['endDate'])
expected_end_date = ccbd(enquiryPeriod_end_date, timedelta(days=1), specific_hour=18, working_days=True)
verification_end_date = parse_date(award['verificationPeriod']['endDate'])
test_case.assertEqual(verification_end_date, expected_end_date)
# check generated signing
signing_end_date = parse_date(award['signingPeriod']['endDate'])
expected_end_date = ccbd(verification_end_date, timedelta(days=0), specific_hour=23) + timedelta(minutes=59)
test_case.assertEqual(signing_end_date, expected_end_date)
def check_generated_enquiry_period(test_case):
# phase commit
next_status = 'active.rectification'
request_data = {"data": {'status': next_status}}
auth = test_case.app.authorization
test_case.app.authorization = ('Basic', ('{}'.format(test_case.auction['access']['owner']), ''))
response = test_case.app.get(test_case.ENTRYPOINTS['get_auction'], request_data)
auction_start_date = parse_date(response.json['data']['auctionPeriod']['startDate'])
response = test_case.app.patch_json(test_case.ENTRYPOINTS['patch_auction'], request_data)
test_case.app.authorization = auth
enquiry_period = response.json['data']['enquiryPeriod']
enquiry_period_start_date = parse_date(enquiry_period['startDate'])
enquiry_period_end_date = parse_date(enquiry_period['endDate'])
# check if start date is equal to rectification period startDate
rectification_period = response.json['data']['rectificationPeriod']
rectification_period_start_date = parse_date(rectification_period['startDate'])
test_case.assertEqual(rectification_period_start_date, enquiry_period_start_date)
# check if end date ends in 20:00 hour
expected_end_time = time(hour=20, minute=0)
test_case.assertEqual(expected_end_time, enquiry_period_end_date.time())
# check difference of equiryPeriod endDate and auction startDate
expected_end_date = ccbd(auction_start_date, -timedelta(days=1),
specific_hour=20)
test_case.assertEqual(expected_end_date, enquiry_period_end_date)
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'shouldStartAfter':
self._shouldStartAfter = instance.time
elif instance.period == 'rectificationPeriod':
self._shouldStartAfter = ccbd(instance.time, timedelta(days=14))
elif instance.period == 'tenderPeriod':
self._shouldStartAfter = ccbd(instance.time, timedelta(days=14))
elif instance.period == 'auctionDate':
self._shouldStartAfter = ccbd(instance.time, timedelta(days=14))
elif instance.period == 'enquiryPeriod':
if instance.state == 'start':
self._shouldStartAfter = ccbd(instance.time,
timedelta(days=14))
elif instance.state == 'end':
self._shouldStartAfter = instance.time
return self
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
self._endDate = ccbd(instance.time,
timedelta(days=0),
specific_hour=18)
elif instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=16)
elif instance.period == 'signingPeriod':
self._startDate = instance.signingPeriod.startDate
self._endDate = ccbd(instance.signingPeriod.startDate,
-timedelta(days=0),
specific_hour=18)
return self
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=16)
elif instance.period == 'qualificationPeriod':
self._startDate = instance.auctionPeriod.endDate
return self
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
self._endDate = ccbd(instance.auctionPeriod.shouldStartAfter,
-timedelta(days=1),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(instance.time, -timedelta(days=14))
elif instance.period == 'rectificationPeriod':
self._startDate = instance.time
self._endDate = ccbd(instance.auctionPeriod.shouldStartAfter,
-timedelta(days=1),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'tenderPeriod':
self._startDate = ccbd(instance.tenderPeriod.startDate,
-timedelta(days=2))
self._endDate = ccbd(instance.auctionPeriod.shouldStartAfter,
-timedelta(days=1),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'auctionDate':
self._startDate = ccbd(instance.auctionDate.date,
timedelta(days=1))
self._endDate = ccbd(instance.auctionPeriod.shouldStartAfter,
-timedelta(days=1),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'auctionPeriod':
self._startDate = ccbd(instance.time, -timedelta(days=18))
self._endDate = ccbd(instance.time,
-timedelta(days=1),
specific_hour=self.specific_hour)
return self
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
elif instance.period == 'rectificationPeriod':
# auction starts 14 days after the rectificationPeriod start
self._startDate = ccbd(instance.time, timedelta(days=14))
elif instance.period == 'tenderPeriod':
# auction starts 12 days after the tenderPeriod start
self._startDate = ccbd(instance.time, timedelta(days=12))
elif instance.period == 'enquiryPeriod':
if instance.state == 'start':
# auction starts 12 days after the enquiryPeriod start
self._startDate = ccbd(instance.time, timedelta(days=12))
elif instance.state == 'end':
# auction starts in same time as enquiryPeriod end
self._startDate = instance.time
elif instance.period == 'qualificationPeriod':
# auction starts day defore qualification Period start
self._startDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=10)
# auction ends day defore at 17 00 qualification Period start
self._endDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=16)
elif instance.period == 'awardPeriod':
# auction starts day defore qualification Period start
self._startDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=10)
# auction ends day defore at 17 00 qualification Period start
self._endDate = ccbd(instance.time,
-timedelta(days=0),
specific_hour=16)
elif instance.period == 'auctionDate':
# Procedure starts 14 days after
self._startDate = ccbd(instance.time, timedelta(days=14))
return self
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
self._endDate = ccbd(self._startDate, self.duration)
elif instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(self._endDate, -self.duration)
elif instance.period == 'tenderPeriod':
self._endDate = instance.tenderPeriod.startDate
self._startDate = ccbd(self._endDate, -self.duration)
elif instance.period == 'enquiryPeriod':
self._endDate = instance.tenderPeriod.startDate
self._startDate = ccbd(self._endDate, -self.duration)
elif instance.period == 'auctionDate':
self._startDate = ccbd(instance.auctionDate.date,
timedelta(days=3))
self._endDate = ccbd(self._startDate, self.duration)
elif instance.period == 'auctionPeriod':
self._startDate = ccbd(instance.time, -timedelta(days=18))
self._endDate = ccbd(instance.time, -timedelta(days=14))
return self
from datetime import timedelta
from copy import deepcopy
from openprocurement.auctions.geb.tests.fixtures.active_qualification import (
AUCTION as ACTIVE_QUALIFICATION_AUCTION)
from openprocurement.auctions.core.utils import get_now
from openprocurement.auctions.geb.tests.fixtures.calculator import (Calculator)
from openprocurement.auctions.geb.tests.fixtures.awards import (AWARD_ACTIVE)
from openprocurement.auctions.geb.tests.fixtures.contracts import (
CONTRACT_PENDING, CONTRACT_PENDING_WITH_DOCUMENT)
from openprocurement.auctions.geb.utils import (
calculate_certainly_business_date as ccbd)
awarded_period_start = ccbd(get_now(), -timedelta(days=1), specific_hour=17)
calculator = Calculator(awarded_period_start, 'awardPeriod', 'end')
auction = deepcopy(ACTIVE_QUALIFICATION_AUCTION)
auction['status'] = 'active.awarded'
auction["rectificationPeriod"] = {
"startDate": calculator.rectificationPeriod.startDate.isoformat(),
"endDate": calculator.rectificationPeriod.endDate.isoformat()
}
auction["tenderPeriod"] = {
"startDate": calculator.tenderPeriod.startDate.isoformat(),
"endDate": calculator.tenderPeriod.endDate.isoformat()
}
auction["enquiryPeriod"] = {
"startDate": calculator.enquiryPeriod.startDate.isoformat(),
"endDate": calculator.enquiryPeriod.endDate.isoformat()
}
auction["auctionPeriod"] = {
"startDate": calculator.auctionPeriod.startDate.isoformat(),
def __get__(self, instance, owner):
self._date = ccbd(instance.rectificationPeriod.startDate,
-timedelta(days=2))
return self
from copy import deepcopy
from uuid import uuid4
from datetime import timedelta
from openprocurement.auctions.core.utils import (get_now)
from openprocurement.auctions.geb.tests.fixtures.calculator import (
ContractCalculator as Calculator)
from openprocurement.auctions.geb.tests.fixtures.common import (
test_organization)
from openprocurement.auctions.geb.tests.fixtures.documents import (
CONTRACT_DOCUMENT)
from openprocurement.auctions.geb.tests.fixtures.items import (TEST_ITEM)
from openprocurement.auctions.geb.utils import (
calculate_certainly_business_date as ccbd)
signing_period_start = ccbd(get_now(), -timedelta(days=1), specific_hour=16)
calculator = Calculator(signing_period_start, 'signingPeriod', 'start')
CONTRACT_PENDING = {
"status": "pending",
"signingPeriod": {
"startDate": calculator.signingPeriod.startDate.isoformat(),
"endDate": calculator.signingPeriod.endDate.isoformat()
},
"items": [TEST_ITEM],
"suppliers": [test_organization],
"value": {
"currency": "UAH",
"amount": 200,
"valueAddedTaxIncluded": True
},
def module_auction_switch_to_qualification(test_case):
context = test_case.procedure.snapshot(fixture=AUCTION_WITH_URLS)
auction = context['auction']
bids = context['bids']
auction_url = '/auctions/{}/auction'.format(auction['data']['id'])
# create module auction results
bid_value = {"value": {"currency": "UAH", "valueAddedTaxIncluded": True}}
loser = deepcopy(bid_value)
loser['id'] = bids[0]['data']['id']
loser['value']['amount'] = auction['data']['value']['amount']
winner = deepcopy(bid_value)
winner['id'] = bids[1]['data']['id']
winner['value']['amount'] = auction['data']['value']['amount'] + auction[
'data']['minimalStep']['amount']
request_data = {'bids': [loser, winner]}
# get auctionPeriod.startDate
entrypoint = '/auctions/{}'.format(auction['data']['id'])
response = test_case.app.get(entrypoint)
data = response.json['data']
auction_start_date = parse_date(data['auctionPeriod']['startDate'])
# simulate valid auction time
# set 'now' to 14:00 next day of auctionPeriod.startDate
valid_auction_time = set_specific_hour(
auction_start_date + timedelta(days=1), 14)
with freeze_time(valid_auction_time):
response = test_case.app.post_json(auction_url, {'data': request_data})
expected_http_status = '200 OK'
test_case.assertEqual(response.status, expected_http_status)
# check generated auction status
entrypoint = '/auctions/{}'.format(auction['data']['id'])
response = test_case.app.get(entrypoint)
test_case.assertEqual(response.json['data']['status'],
'active.qualification')
# check generated award
response = test_case.app.get('/auctions/{}/awards'.format(
auction['data']['id']))
awards = response.json['data']
test_case.assertEqual(len(awards), 1)
award = awards[0]
test_case.assertIsNotNone(award.get('verificationPeriod'))
test_case.assertIsNotNone(award.get('signingPeriod'))
test_case.assertEqual(award['bid_id'], winner['id'])
test_case.assertEqual(award['status'], 'pending')
# check generated verificationPeriod
entrypoint = '/auctions/{}'.format(auction['data']['id'])
response = test_case.app.get(entrypoint)
auction = response.json['data']
auction_period_end_date = parse_date(auction['auctionPeriod']['endDate'])
verification_start_date = parse_date(
award['verificationPeriod']['startDate'])
verification_end_date = parse_date(award['verificationPeriod']['endDate'])
expected_end_date = set_specific_hour(auction_period_end_date, 18)
test_case.assertEqual(verification_end_date, expected_end_date)
# check generated signing
signing_end_date = parse_date(award['signingPeriod']['endDate'])
signing_start_date = parse_date(award['signingPeriod']['startDate'])
expected_end_date = ccbd(verification_end_date,
timedelta(days=0),
specific_hour=23) + timedelta(minutes=59)
test_case.assertEqual(signing_end_date, expected_end_date)
test_case.assertEqual(signing_start_date, verification_start_date)
# check generated awardPeriod
auction = response.json['data']
award_period_start = parse_date(auction['awardPeriod']['startDate'])
test_case.assertEqual(award_period_start, verification_start_date)
from copy import deepcopy
from openprocurement.auctions.geb.tests.fixtures.active_auction import (
AUCTION as ACTIVE_AUCTION_AUCTION)
from openprocurement.auctions.core.utils import get_now
from openprocurement.auctions.geb.tests.fixtures.calculator import (Calculator)
from openprocurement.auctions.geb.tests.fixtures.awards import (
AWARD_PENDING, AWARD_PENDING_WITH_PROTOCOL)
from openprocurement.auctions.geb.tests.fixtures.documents import (
AUCTION_DOCUMENT_AUDIT)
from openprocurement.auctions.geb.utils import (
calculate_certainly_business_date as ccbd)
qualification_period_start = ccbd(get_now(),
-timedelta(days=1),
specific_hour=16)
calculator = Calculator(qualification_period_start, 'qualificationPeriod',
'start')
auction = deepcopy(ACTIVE_AUCTION_AUCTION)
auction['status'] = 'active.qualification'
auction['documents'] = [AUCTION_DOCUMENT_AUDIT]
auction["rectificationPeriod"] = {
"startDate": calculator.rectificationPeriod.startDate.isoformat(),
"endDate": calculator.rectificationPeriod.endDate.isoformat()
}
auction["tenderPeriod"] = {
"startDate": calculator.tenderPeriod.startDate.isoformat(),
"endDate": calculator.tenderPeriod.endDate.isoformat()
}
auction["enquiryPeriod"] = {
def __get__(self, instance, owner):
if instance.period == self.name:
if instance.state == 'start':
self._startDate = instance.time
self._endDate = ccbd(instance.auctionPeriod.startDate,
-timedelta(days=4),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.state == 'end':
self._endDate = instance.time
self._startDate = ccbd(self._endDate, -timedelta(days=10))
elif instance.period == 'rectificationPeriod':
self._startDate = instance.rectificationPeriod.endDate
self._endDate = ccbd(instance.auctionPeriod.startDate,
-timedelta(days=4),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'enquiryPeriod':
self._startDate = ccbd(instance.enquiryPeriod.startDate,
timedelta(days=2))
self._endDate = ccbd(instance.auctionPeriod.startDate,
-timedelta(days=4),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'auctionDate':
self._startDate = ccbd(self.auctionDate.date, timedelta(days=5))
self._endDate = ccbd(instance.auctionPeriod.startDate,
-timedelta(days=4),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'auctionPeriod':
self._startDate = ccbd(instance.time, -timedelta(days=16))
self._endDate = ccbd(instance.time,
-timedelta(days=4),
working_days=self.working_days,
specific_hour=self.specific_hour)
elif instance.period == 'qualificationPeriod':
self._startDate = ccbd(instance.time, -timedelta(days=15))
self._endDate = ccbd(instance.time, -timedelta(days=4))
elif instance.period == 'awardPeriod':
self._startDate = ccbd(instance.time, -timedelta(days=15))
self._endDate = ccbd(instance.time, -timedelta(days=4))
return self