class Contract(BaseContract): """ ESCO Contract """ contractType = StringType(default='esco') fundingKind = StringType(choices=['budget', 'other'], required=True) milestones = SifterListType(ModelType(Milestone), default=list(), filter_by='status', filter_in_values=[ 'scheduled', 'pending', 'met', 'notMet', 'partiallyMet' ]) minValue = ModelType(Value, required=False, default={ 'amount': 0, 'currency': 'UAH', 'valueAddedTaxIncluded': True }) NBUdiscountRate = DecimalType(required=True, min_value=Decimal('0'), max_value=Decimal('0.99'), precision=-5) noticePublicationDate = IsoDateTimeType() value = ModelType(ESCOValue) amountPaid = ModelType(Value) yearlyPaymentsPercentageRange = DecimalType(required=True) documents = ListType(ModelType(Document), default=list()) class Options: roles = { 'plain': plain_role, 'create': contract_create_role, 'edit_active': contract_edit_role, 'edit_terminated': whitelist(), 'view': contract_view_role + whitelist('NBUdiscountRate', 'contractType', 'milestones'), 'Administrator': contract_administrator_role, 'default': schematics_default_role, } @serializable(serialized_name='amountPaid', serialize_when_none=False, type=ModelType(Value)) def contract_amountPaid(self): amount = sum([ milestone.amountPaid.amount for milestone in self.milestones if milestone.status != 'spare' ]) return Value( dict(amount=amount, currency=self.value.currency, valueAddedTaxIncluded=self.value.valueAddedTaxIncluded))
class Tender(BaseTender): """ Data regarding tender process - publicly inviting prospective contractors to submit bids for evaluation and selecting a winner or winners. """ awardCriteria = StringType( choices=[AWARD_CRITERIA_LOWEST_COST, AWARD_CRITERIA_LIFE_CYCLE_COST], default=AWARD_CRITERIA_LOWEST_COST) procurementMethodType = StringType(default="simple.defense") bids = SifterListType(ModelType(Bid, required=True), default=list(), filter_by="status", filter_in_values=["invalid", "deleted"]) def validate_criteria(self, data, value): # for deactivate validation of criteria from parent class return def validate_awardCriteria(self, data, value): if value == AWARD_CRITERIA_LIFE_CYCLE_COST: if data.get("features", []): raise ValidationError( "Can`t add features with {} awardCriteria".format( AWARD_CRITERIA_LIFE_CYCLE_COST))
class Tender(BaseTenderEU): procurementMethodType = StringType(default=CD_EU_TYPE) status = StringType(choices=[ 'draft', 'active.tendering', 'active.pre-qualification', 'active.pre-qualification.stand-still', 'active.stage2.pending', 'active.stage2.waiting', 'complete', 'cancelled', 'unsuccessful' ], default='active.tendering') # A list of all the companies who entered submissions for the tender. bids = SifterListType(ModelType(Bid), default=list(), filter_by='status', filter_in_values=['invalid', 'deleted']) TenderID = StringType(required=False) stage2TenderID = StringType(required=False) features = ListType(ModelType(Feature), validators=[validate_features_uniq]) lots = ListType(ModelType(Lot), default=list(), validators=[validate_lots_uniq]) class Options: roles = roles.copy() def get_role(self): root = self.__parent__ request = root.request if request.authenticated_role == 'Administrator': role = 'Administrator' elif request.authenticated_role == 'chronograph': role = 'chronograph' elif request.authenticated_role == 'competitive_dialogue': role = 'competitive_dialogue' else: role = 'edit_{}'.format(request.context.status) return role def __acl__(self): acl = [(Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_qualification_complaint') for i in self.bids if i.status in ['active', 'unsuccessful']] acl.extend([(Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_award_complaint') for i in self.bids if i.status == 'active']) acl.extend([ (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_tender'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'upload_tender_documents'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_complaint'), (Allow, 'g:competitive_dialogue', 'extract_credentials'), (Allow, 'g:competitive_dialogue', 'edit_tender'), ]) return acl def validate_features(self, data, features): validate_features_custom_weight(self, data, features, FEATURES_MAX_SUM)
class Tender(BaseTender): """Data regarding tender process - publicly inviting prospective contractors to submit bids for evaluation and selecting a winner or winners.""" procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) procurementMethodType = StringType(default="aboveThresholdUA.defense") procuring_entity_kinds = ["defense"] bids = SifterListType(ModelType(Bid, required=True), default=list(), filter_by="status", filter_in_values=["invalid", "deleted"]) cancellations = ListType(ModelType(Cancellation, required=True), default=list()) def validate_tenderPeriod(self, data, period): if period: _validate_tender_period_duration(data, period, TENDERING_DURATION, working_days=True) @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): end_date = calculate_tender_business_date(self.tenderPeriod.endDate, -ENQUIRY_PERIOD_TIME, self, True) clarifications_until = calculate_clarif_business_date( end_date, ENQUIRY_STAND_STILL_TIME, self, True) return EnquiryPeriod( dict( startDate=self.tenderPeriod.startDate, endDate=end_date, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=clarifications_until, )) @serializable(type=ModelType(Period)) def complaintPeriod(self): if self.tenderPeriod.startDate < COMPLAINT_OLD_SUBMIT_TIME_BEFORE: end_date = calculate_tender_business_date( self.tenderPeriod.endDate, -COMPLAINT_OLD_SUBMIT_TIME, self) else: end_date = calculate_complaint_business_date( self.tenderPeriod.endDate, -COMPLAINT_SUBMIT_TIME, self, True) return Period( dict(startDate=self.tenderPeriod.startDate, endDate=end_date)) def validate_criteria(self, data, value): if value: raise ValidationError("Rogue field")
class CloseFrameworkAgreementUA(Tender): """ OpenEU tender model """ class Options: namespace = "Tender" _core_roles = Tender.Options.roles _procurement_method_details = whitelist("procurementMethodDetails") _edit_fields = _core_roles["edit"] + whitelist( "tenderPeriod", "features", "complaintPeriod", "agreementDuration", "next_check", "procuringEntity", "guarantee", "serializable_enquiryPeriod", "minimalStep", "items", "qualificationPeriod", "value", "maxAwardsCount", "agreements", "numberOfBidders", "hasEnquiries", "serializable_guarantee", "serializable_value", "serializable_minimalStep", ) _edit_role = _edit_fields + whitelist("numberOfBids") _edit_qualification = whitelist("status") + _procurement_method_details _tendering_view_role = ( _core_roles["view"] + _edit_fields + whitelist( "auctionPeriod", "lots", "enquiryPeriod", "complaints", "auctionUrl", "awardPeriod", "qualifications", "questions", "cancellations", "awards", ) ) _view_role = _tendering_view_role + whitelist("numberOfBids", "bids") _complete_view_role = _view_role + whitelist("contractPeriod") roles = { "create": _edit_role + whitelist("mode", "procurementMethodType", "lots"), "edit_draft": _edit_role, "edit": _edit_role, "edit_active.tendering": _edit_role, "edit_active.pre-qualification": _edit_qualification, "edit_active.qualification": _edit_qualification, "edit_cancelled": _procurement_method_details, "edit_complete": _procurement_method_details, "edit_unsuccessful": _procurement_method_details, "edit_active.awarded": _procurement_method_details, "edit_active.auction": _procurement_method_details, "edit_active.pre-qualification.stand-still": _procurement_method_details, "draft": _tendering_view_role + whitelist("contractPeriod"), "active.tendering": _tendering_view_role, "cancelled": _view_role, "active.auction": _view_role, "active.pre-qualification.stand-still": _view_role, "active.qualification.stand-still": _view_role, "view": _complete_view_role, "active.qualification": _complete_view_role, "active.pre-qualification": _complete_view_role, "complete": _complete_view_role, "active.awarded": _complete_view_role, "unsuccessful": _complete_view_role, "contracting": _core_roles["contracting"] + _procurement_method_details, "chronograph": _core_roles["chronograph"] + _procurement_method_details, "chronograph_view": _core_roles["chronograph_view"] + _procurement_method_details, "auction_view": _core_roles["auction_view"] + _procurement_method_details + whitelist("milestones", "mainProcurementCategory"), "Administrator": _core_roles["Administrator"] + _procurement_method_details, "auction_post": _core_roles["auction_post"] + _procurement_method_details, "auction_patch": _core_roles["auction_patch"] + _procurement_method_details, "listing": _core_roles["listing"] + _procurement_method_details, "embedded": _core_roles["embedded"], "plain": _core_roles["plain"], "default": _core_roles["default"], } create_accreditations = (ACCR_3, ACCR_5) central_accreditations = (ACCR_5,) edit_accreditations = (ACCR_4,) procuring_entity_kinds = ["authority", "central", "defense", "general", "social", "special"] block_tender_complaint_status = ["claim", "pending", "accepted", "satisfied", "stopping"] block_complaint_status = ["pending", "accepted", "satisfied", "stopping"] auctionPeriod = ModelType(TenderAuctionPeriod, default={}) auctionUrl = URLType() awards = ListType(ModelType(Award, required=True), default=list()) awardPeriod = ModelType(Period) # The dat e or period on which an award is anticipated to be made. bids = SifterListType( BidModelType(Bid), default=list(), filter_by="status", filter_in_values=["invalid", "invalid.pre-qualification", "deleted"], ) # A list of all the companies who entered submissions for the tender. cancellations = ListType(ModelType(Cancellation, required=True), default=list()) complaints = ListType(ComplaintModelType(Complaint, required=True), default=list()) contractPeriod = ModelType(ContractPeriod, required=False) agreements = ListType(ModelType(Agreement, required=True), default=list()) documents = ListType( ModelType(EUDocument, required=True), default=list() ) # All documents and attachments related to the tender. enquiryPeriod = ModelType(EnquiryPeriod, required=False) guarantee = ModelType(Guarantee) hasEnquiries = BooleanType() # A Yes/No field as to whether enquiries were part of tender process. items = ListType( ModelType(Item, required=True), required=True, min_size=1, validators=[validate_cpv_group, validate_items_uniq, validate_classification_id], ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. features = ListType(ModelType(Feature, required=True), validators=[validate_features_uniq]) minimalStep = ModelType(Value, required=True) numberOfBidders = IntType() # The number of unique tenderers who participated in the tender maxAwardsCount = IntType(required=True, validators=[validate_max_awards_number]) lots = ListType( ModelType(Lot, required=True), min_size=1, max_size=1, default=list(), validators=[validate_lots_uniq] ) procurementMethodType = StringType(default="closeFrameworkAgreementUA") procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items being procured. qualificationPeriod = ModelType(Period) qualifications = ListType(ModelType(Qualification, required=True), default=list()) questions = ListType(ModelType(Question, required=True), default=list()) status = StringType( choices=[ "draft", "active.tendering", "active.pre-qualification", "active.pre-qualification.stand-still", "active.auction", "active.qualification", "active.qualification.stand-still", "active.awarded", "complete", "cancelled", "unsuccessful", ], default="active.tendering", ) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) title_en = StringType(required=True, min_length=1) value = ModelType(Value, required=True) # The total estimated value of the procurement. agreementDuration = IsoDurationType(required=True, validators=[validate_max_agreement_duration_period]) mainProcurementCategory = StringType(choices=["goods", "services"]) def __local_roles__(self): roles = dict([("{}_{}".format(self.owner, self.owner_token), "tender_owner")]) for i in self.bids: roles["{}_{}".format(i.owner, i.owner_token)] = "bid_owner" return roles def __acl__(self): acl = [ (Allow, "{}_{}".format(i.owner, i.owner_token), "create_qualification_complaint") for i in self.bids if i.status in ["active", "unsuccessful", "invalid.pre-qualification"] ] acl.extend( [ (Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids if i.status == "active" ] ) acl.extend( [ (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"), ] ) self._acl_cancellation_complaint(acl) return acl def check_auction_time(self): if ( self.auctionPeriod and self.auctionPeriod.startDate and self.auctionPeriod.shouldStartAfter and self.auctionPeriod.startDate > calculate_tender_business_date( parse_date(self.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True ) ): self.auctionPeriod.startDate = None for lot in self.lots: if ( lot.auctionPeriod and lot.auctionPeriod.startDate and lot.auctionPeriod.shouldStartAfter and lot.auctionPeriod.startDate > calculate_tender_business_date( parse_date(lot.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True ) ): lot.auctionPeriod.startDate = None def invalidate_bids_data(self): self.check_auction_time() self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"
class Tender(BaseTender): """ Data regarding tender process - publicly inviting prospective contractors to submit bids for evaluation and selecting a winner or winners. """ class Options: namespace = "Tender" _parent_roles = BaseTender.Options.roles _edit_role = _parent_roles["edit"] _above_fields = whitelist("complaintPeriod") _tendering_role = _parent_roles["active.tendering"] + _above_fields _view_role = _parent_roles["view"] + _above_fields _all_forbidden = whitelist() roles = { "create": _parent_roles["create"], "edit_draft": _parent_roles["edit_draft"], "edit": _edit_role, "edit_active.tendering": _edit_role, "edit_active.auction": _all_forbidden, "edit_active.qualification": _all_forbidden, "edit_active.awarded": _all_forbidden, "edit_complete": _all_forbidden, "edit_unsuccessful": _all_forbidden, "edit_cancelled": _all_forbidden, "draft": _tendering_role, "active.tendering": _tendering_role, "active.auction": _tendering_role, "view": _view_role, "active.qualification": _view_role, "active.awarded": _view_role, "complete": _view_role, "unsuccessful": _view_role, "cancelled": _view_role, "chronograph": _parent_roles["chronograph"], "chronograph_view": _parent_roles["chronograph_view"], "Administrator": _parent_roles["Administrator"], "default": _parent_roles["default"], "plain": _parent_roles["plain"], "listing": _parent_roles["listing"], "auction_view": _parent_roles["auction_view"], "auction_post": _parent_roles["auction_post"], "auction_patch": _parent_roles["auction_patch"], "contracting": _parent_roles["contracting"], } __name__ = "" enquiryPeriod = ModelType(EnquiryPeriod, required=False) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) auctionPeriod = ModelType(TenderAuctionPeriod, default={}) bids = SifterListType( ModelType(Bid, required=True), default=list(), filter_by="status", filter_in_values=["invalid", "deleted"] ) # A list of all the companies who entered submissions for the tender. awards = ListType(ModelType(Award, required=True), default=list()) contracts = ListType(ModelType(Contract, required=True), default=list()) complaints = ListType(ComplaintModelType(Complaint, required=True), default=list()) procurementMethodType = StringType(default="aboveThresholdUA") lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) status = StringType( choices=[ "draft", "active.tendering", "active.auction", "active.qualification", "active.awarded", "complete", "cancelled", "unsuccessful", ], default="active.tendering", ) items = ListType( ModelType(Item, required=True), required=True, min_size=1, validators=[ validate_cpv_group, validate_items_uniq, validate_classification_id ], ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. cancellations = ListType(ModelType(Cancellation, required=True), default=list()) create_accreditations = (ACCR_3, ACCR_5) central_accreditations = (ACCR_5, ) edit_accreditations = (ACCR_4, ) procuring_entity_kinds = ["general", "special", "defense", "central"] block_tender_complaint_status = [ "claim", "pending", "accepted", "satisfied", "stopping" ] block_complaint_status = ["pending", "accepted", "satisfied", "stopping"] def __acl__(self): acl = [(Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids if i.status == "active"] acl.extend([ (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"), ]) self._acl_cancellation_complaint(acl) return acl def validate_enquiryPeriod(self, data, period): # for deactivate validation to enquiryPeriod from parent tender return def validate_tenderPeriod(self, data, period): # data['_rev'] is None when tender was created just now if not data["_rev"] and calculate_tender_business_date( get_now(), -timedelta(minutes=10)) >= period.startDate: raise ValidationError( u"tenderPeriod.startDate should be in greater than current date" ) if period and calculate_tender_business_date( period.startDate, TENDER_PERIOD, data) > period.endDate: raise ValidationError( u"tenderPeriod should be greater than 15 days") @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): endDate = calculate_tender_business_date(self.tenderPeriod.endDate, -ENQUIRY_PERIOD_TIME, self) clarificationsUntil = calculate_clarifications_business_date( endDate, ENQUIRY_STAND_STILL_TIME, self, True) return EnquiryPeriod( dict( startDate=self.tenderPeriod.startDate, endDate=endDate, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=clarificationsUntil, )) @serializable(type=ModelType(Period)) def complaintPeriod(self): endDate = calculate_complaint_business_date(self.tenderPeriod.endDate, -COMPLAINT_SUBMIT_TIME, self) return Period( dict(startDate=self.tenderPeriod.startDate, endDate=endDate)) @serializable def numberOfBids(self): """A property that is serialized by schematics exports.""" return len([bid for bid in self.bids if bid.status == "active"]) @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] if (self.status == "active.tendering" and self.tenderPeriod.endDate and not has_unanswered_complaints(self) and not has_unanswered_questions(self)): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif (not self.lots and self.status == "active.auction" and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate): if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ): checks.append( calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ)) elif self.lots and self.status == "active.auction": for lot in self.lots: if (lot.status != "active" or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate): continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ): checks.append( calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ)) elif (not self.lots and self.status == "active.awarded" and not any( [i.status in self.block_complaint_status for i in self.complaints]) and not any([ i.status in self.block_complaint_status for a in self.awards for i in a.complaints ])): standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if a.complaintPeriod.endDate ] last_award_status = self.awards[-1].status if self.awards else "" if standStillEnds and last_award_status == "unsuccessful": checks.append(max(standStillEnds)) elif (self.lots and self.status in ["active.qualification", "active.awarded"] and not any([ i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints ])): for lot in self.lots: if lot["status"] != "active": continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any([ i["status"] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints ]) pending_awards_complaints = any([ i.status in self.block_complaint_status for a in lot_awards for i in a.complaints ]) standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if a.complaintPeriod.endDate ] last_award_status = lot_awards[-1].status if lot_awards else "" if (not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == "unsuccessful"): checks.append(max(standStillEnds)) if self.status.startswith("active"): for award in self.awards: if award.status == "active" and not any( [i.awardID == award.id for i in self.contracts]): checks.append(award.date) extend_next_check_by_complaint_period_ends(self, checks) return min(checks).isoformat() if checks else None def invalidate_bids_data(self): if (self.auctionPeriod and self.auctionPeriod.startDate and self.auctionPeriod.shouldStartAfter and self.auctionPeriod.startDate > calculate_tender_business_date( parse_date(self.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True)): self.auctionPeriod.startDate = None for lot in self.lots: if (lot.auctionPeriod and lot.auctionPeriod.startDate and lot.auctionPeriod.shouldStartAfter and lot.auctionPeriod.startDate > calculate_tender_business_date( parse_date(lot.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True)): lot.auctionPeriod.startDate = None self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"
class Tender(BaseTender): """Data regarding tender process - publicly inviting prospective contractors to submit bids for evaluation and selecting a winner or winners.""" class Options: roles = { 'plain': plain_role, 'create': create_role, 'edit': edit_role_ua, 'edit_draft': draft_role, 'edit_active.tendering': edit_role_ua, 'edit_active.auction': whitelist(), 'edit_active.qualification': whitelist(), 'edit_active.awarded': whitelist(), 'edit_complete': whitelist(), 'edit_unsuccessful': whitelist(), 'edit_cancelled': whitelist(), 'view': view_role, 'listing': listing_role, 'auction_view': auction_view_role, 'auction_post': auction_post_role, 'auction_patch': auction_patch_role, 'draft': enquiries_role, 'active.tendering': enquiries_role, 'active.auction': auction_role, 'active.qualification': view_role, 'active.awarded': view_role, 'complete': view_role, 'unsuccessful': view_role, 'cancelled': view_role, 'chronograph': chronograph_role, 'chronograph_view': chronograph_view_role, 'Administrator': Administrator_role, 'default': schematics_default_role, 'contracting': whitelist('doc_id', 'owner'), } __name__ = '' enquiryPeriod = ModelType(EnquiryPeriod, required=False) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) auctionPeriod = ModelType(TenderAuctionPeriod, default={}) bids = SifterListType( ModelType(Bid), default=list(), filter_by='status', filter_in_values=['invalid', 'deleted'] ) # A list of all the companies who entered submissions for the tender. awards = ListType(ModelType(Award), default=list()) contracts = ListType(ModelType(Contract), default=list()) complaints = ListType(ComplaintModelType(Complaint), default=list()) procurementMethodType = StringType(default="aboveThresholdUA") lots = ListType(ModelType(Lot), default=list(), validators=[validate_lots_uniq]) status = StringType(choices=[ 'draft', 'active.tendering', 'active.auction', 'active.qualification', 'active.awarded', 'complete', 'cancelled', 'unsuccessful' ], default='active.tendering') items = ListType( ModelType(Item), required=True, min_size=1, validators=[ validate_cpv_group, validate_items_uniq, validate_classification_id ] ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. cancellations = ListType(ModelType(Cancellation), default=list()) create_accreditation = 3 edit_accreditation = 4 procuring_entity_kinds = ['general', 'special', 'defense'] block_tender_complaint_status = [ 'claim', 'pending', 'accepted', 'satisfied', 'stopping' ] block_complaint_status = ['pending', 'accepted', 'satisfied', 'stopping'] def __acl__(self): acl = [(Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_award_complaint') for i in self.bids if i.status == 'active'] acl.extend([ (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_tender'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'upload_tender_documents'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_complaint'), ]) return acl def validate_tenderPeriod(self, data, period): # if data['_rev'] is None when tender was created just now if not data['_rev'] and calculate_business_date( get_now(), -timedelta(minutes=10)) >= period.startDate: raise ValidationError( u"tenderPeriod.startDate should be in greater than current date" ) if period and calculate_business_date(period.startDate, TENDER_PERIOD, data) > period.endDate: raise ValidationError( u"tenderPeriod should be greater than 15 days") @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): endDate = calculate_business_date(self.tenderPeriod.endDate, -ENQUIRY_PERIOD_TIME, self) return EnquiryPeriod( dict(startDate=self.tenderPeriod.startDate, endDate=endDate, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=calculate_business_date( endDate, ENQUIRY_STAND_STILL_TIME, self, True))) @serializable(type=ModelType(Period)) def complaintPeriod(self): normalized_end = calculate_normalized_date(self.tenderPeriod.endDate, self) return Period( dict(startDate=self.tenderPeriod.startDate, endDate=calculate_business_date(normalized_end, -COMPLAINT_SUBMIT_TIME, self))) @serializable def numberOfBids(self): """A property that is serialized by schematics exports.""" return len([bid for bid in self.bids if bid.status == "active"]) @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] if self.status == 'active.tendering' and self.tenderPeriod.endDate and \ not has_unanswered_complaints(self) and not has_unanswered_questions(self): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif not self.lots and self.status == 'active.auction' and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate: if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ): checks.append( calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ)) elif self.lots and self.status == 'active.auction': for lot in self.lots: if lot.status != 'active' or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate: continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ): checks.append( calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ)) elif not self.lots and self.status == 'active.awarded' and not any( [i.status in self.block_complaint_status for i in self.complaints]) and not any([ i.status in self.block_complaint_status for a in self.awards for i in a.complaints ]): standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if a.complaintPeriod.endDate ] last_award_status = self.awards[-1].status if self.awards else '' if standStillEnds and last_award_status == 'unsuccessful': checks.append(max(standStillEnds)) elif self.lots and self.status in [ 'active.qualification', 'active.awarded' ] and not any([ i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints ]): for lot in self.lots: if lot['status'] != 'active': continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any([ i['status'] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints ]) pending_awards_complaints = any([ i.status in self.block_complaint_status for a in lot_awards for i in a.complaints ]) standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if a.complaintPeriod.endDate ] last_award_status = lot_awards[-1].status if lot_awards else '' if not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == 'unsuccessful': checks.append(max(standStillEnds)) if self.status.startswith('active'): for award in self.awards: if award.status == 'active' and not any( [i.awardID == award.id for i in self.contracts]): checks.append(award.date) return min(checks).isoformat() if checks else None def invalidate_bids_data(self): if self.auctionPeriod and self.auctionPeriod.startDate and self.auctionPeriod.shouldStartAfter \ and self.auctionPeriod.startDate > calculate_business_date(parse_date(self.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): self.auctionPeriod.startDate = None for lot in self.lots: if lot.auctionPeriod and lot.auctionPeriod.startDate and lot.auctionPeriod.shouldStartAfter \ and lot.auctionPeriod.startDate > calculate_business_date(parse_date(lot.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): lot.auctionPeriod.startDate = None self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"
class Tender(BaseTender): """ ESCO Tender model """ class Options: namespace = "Tender" _parent_roles = BaseTender.Options.roles _all_forbidden = whitelist() _serializable_fields = whitelist( "tender_enquiryPeriod", "complaintPeriod", "next_check", "tender_minValue", "tender_guarantee", "tender_minimalStepPercentage", "tender_yearlyPaymentsPercentageRange", "tender_noticePublicationDate", ) _edit_fields = _serializable_fields + whitelist( "procuringEntity", "tenderPeriod", "NBUdiscountRate", "items", "features", "yearlyPaymentsPercentageRange", "fundingKind", # fields below are not covered "hasEnquiries", "numberOfBidders", "minimalStepPercentage", ) _read_only_fields = whitelist( "awards", "lots", "contracts", "auctionPeriod", "complaints", # fields below are not covered "auctionUrl", "awardPeriod", "questions", "cancellations", "qualifications", "qualificationPeriod", ) _tendering_role = _parent_roles["view"] + _edit_fields + _read_only_fields _view_role = _tendering_role + whitelist("bids", "numberOfBids") _pre_qualifications_role = _view_role _esco_edit_forbidden = whitelist( "minValue", "tender_minValue", "minimalStep", "tender_minimalStep", "noticePublicationDate", "tender_noticePublicationDate", ) _edit_role = _parent_roles["edit"] + _edit_fields - _esco_edit_forbidden roles = { "create": _parent_roles["create"] + _edit_fields + whitelist("lots") - _esco_edit_forbidden, "edit": _edit_role, "edit_draft": _edit_role + whitelist("status"), "edit_active.tendering": _edit_role, "edit_active.pre-qualification": whitelist("status"), "edit_active.pre-qualification.stand-still": _all_forbidden, "edit_active.auction": _all_forbidden, "edit_active.qualification": _all_forbidden, "edit_active.awarded": _all_forbidden, "edit_complete": _all_forbidden, "edit_unsuccessful": _all_forbidden, "edit_cancelled": _all_forbidden, "draft": _tendering_role, "active.tendering": _tendering_role, "active.qualification": _view_role, "active.awarded": _view_role, "complete": _view_role, "unsuccessful": _view_role, "cancelled": _view_role, "view": _view_role, "active.pre-qualification": _pre_qualifications_role, "active.pre-qualification.stand-still": _pre_qualifications_role, "active.auction": _pre_qualifications_role, "auction_view": _parent_roles["auction_view"] + whitelist( "NBUdiscountRate", "minimalStepPercentage", "yearlyPaymentsPercentageRange", "fundingKind", "procurementMethodType", "noticePublicationDate", ), "auction_post": _parent_roles["auction_post"], "auction_patch": _parent_roles["auction_patch"], "chronograph": _parent_roles["chronograph"], "chronograph_view": _parent_roles["chronograph_view"], "Administrator": _parent_roles["Administrator"] + whitelist("yearlyPaymentsPercentageRange"), "plain": _parent_roles["plain"], "listing": _parent_roles["listing"], "contracting": _parent_roles["contracting"], "default": _parent_roles["default"], } procurementMethodType = StringType(default="esco") title_en = StringType(required=True, min_length=1) items = ListType( ModelType(Item, required=True), required=True, min_size=1, validators=[validate_cpv_group, validate_items_uniq] ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. minValue = ModelType( Value, required=False, default={"amount": 0, "currency": "UAH", "valueAddedTaxIncluded": True} ) # The total estimated value of the procurement. enquiryPeriod = ModelType(EnquiryPeriod, required=False) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) auctionPeriod = ModelType(TenderAuctionPeriod, default={}) hasEnquiries = BooleanType() # A Yes/No field as to whether enquiries were part of tender process. awardCriteria = StringType(default="ratedCriteria") awardPeriod = ModelType(Period) # The date or period on which an award is anticipated to be made. numberOfBidders = IntType() # The number of unique tenderers who participated in the tender bids = SifterListType( BidModelType(Bid), default=list(), filter_by="status", filter_in_values=["invalid", "invalid.pre-qualification", "deleted"], ) # A list of all the companies who entered submissions for the tender. procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items being procured. awards = ListType(ModelType(Award, required=True), default=list()) contracts = ListType(ModelType(Contract, required=True), default=list()) minimalStep = ModelType( Value, required=False ) # Not required, blocked for create/edit, since we have minimalStepPercentage in esco minimalStepPercentage = DecimalType( required=True, min_value=Decimal("0.005"), max_value=Decimal("0.03"), precision=-5 ) questions = ListType(ModelType(Question, required=True), default=list()) complaints = ListType(ComplaintModelType(Complaint, required=True), default=list()) auctionUrl = URLType() cancellations = ListType(ModelType(Cancellation, required=True), default=list()) features = ListType(ModelType(Feature, required=True), validators=[validate_features_uniq]) lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) guarantee = ModelType(Guarantee) documents = ListType( ModelType(Document, required=True), default=list() ) # All documents and attachments related to the tender. qualifications = ListType(ModelType(Qualification, required=True), default=list()) qualificationPeriod = ModelType(Period) status = StringType( choices=[ "draft", "active.tendering", "active.pre-qualification", "active.pre-qualification.stand-still", "active.auction", "active.qualification", "active.awarded", "complete", "cancelled", "unsuccessful", ], default="active.tendering", ) NBUdiscountRate = DecimalType(required=True, min_value=Decimal("0"), max_value=Decimal("0.99"), precision=-5) fundingKind = StringType(choices=["budget", "other"], required=True, default="other") yearlyPaymentsPercentageRange = DecimalType( required=True, default=Decimal("0.8"), min_value=Decimal("0"), max_value=Decimal("1"), precision=-5 ) noticePublicationDate = IsoDateTimeType() create_accreditations = (ACCR_3, ACCR_5) central_accreditations = (ACCR_5,) edit_accreditations = (ACCR_4,) special_fields = ["fundingKind", "yearlyPaymentsPercentageRange", "status"] procuring_entity_kinds = ["authority", "central", "defense", "general", "social", "special"] block_tender_complaint_status = OpenUATender.block_tender_complaint_status block_complaint_status = OpenUATender.block_complaint_status def import_data(self, raw_data, **kw): """ Converts and imports the raw data into the instance of the model according to the fields in the model. :param raw_data: The data to be imported. """ data = self.convert(raw_data, **kw) del_keys = [ k for k in data.keys() if data[k] == self.__class__.fields[k].default or data[k] == getattr(self, k) ] for k in del_keys: if k in self.special_fields: # skip special fields :) continue del data[k] self._data.update(data) return self def __local_roles__(self): roles = dict([("{}_{}".format(self.owner, self.owner_token), "tender_owner")]) for i in self.bids: roles["{}_{}".format(i.owner, i.owner_token)] = "bid_owner" return roles def __acl__(self): acl = [ (Allow, "{}_{}".format(i.owner, i.owner_token), "create_qualification_complaint") for i in self.bids if i.status in ["active", "unsuccessful"] ] acl.extend( [ (Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids if i.status == "active" ] ) acl.extend( [ (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"), (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_contract"), (Allow, "{}_{}".format(self.owner, self.owner_token), "upload_contract_documents"), (Allow, "{}_{}".format(self.owner, self.owner_token), "upload_qualification_documents"), ] ) self._acl_cancellation_complaint(acl) return acl @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): end_date = calculate_tender_business_date(self.tenderPeriod.endDate, -QUESTIONS_STAND_STILL, self) clarifications_until = calculate_clarif_business_date(end_date, ENQUIRY_STAND_STILL_TIME, self, True) return EnquiryPeriod( dict( startDate=self.tenderPeriod.startDate, endDate=end_date, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=clarifications_until, ) ) @serializable(type=ModelType(Period)) def complaintPeriod(self): end_date = calculate_complaint_business_date(self.tenderPeriod.endDate, -COMPLAINT_SUBMIT_TIME, self) return Period(dict(startDate=self.tenderPeriod.startDate, endDate=end_date)) @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] extend_next_check_by_complaint_period_ends(self, checks) if cancellation_block_tender(self): return min(checks).isoformat() if checks else None if ( self.status == "active.tendering" and self.tenderPeriod.endDate and not has_unanswered_complaints(self) and not has_unanswered_questions(self) ): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif ( self.status == "active.pre-qualification.stand-still" and self.qualificationPeriod and self.qualificationPeriod.endDate ): active_lots = [lot.id for lot in self.lots if lot.status == "active"] if self.lots else [None] if not any( [ i.status in self.block_complaint_status for q in self.qualifications for i in q.complaints if q.lotID in active_lots ] ): checks.append(self.qualificationPeriod.endDate.astimezone(TZ)) elif ( not self.lots and self.status == "active.auction" and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate ): if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate ).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif self.lots and self.status == "active.auction": for lot in self.lots: if ( lot.status != "active" or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate ): continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate ).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif ( not self.lots and self.status == "active.awarded" and not any([i.status in self.block_complaint_status for i in self.complaints]) and not any([i.status in self.block_complaint_status for a in self.awards for i in a.complaints]) ): standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if a.complaintPeriod and a.complaintPeriod.endDate ] last_award_status = self.awards[-1].status if self.awards else "" if standStillEnds and last_award_status == "unsuccessful": checks.append(max(standStillEnds)) elif ( self.lots and self.status in ["active.qualification", "active.awarded"] and not any([i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints]) ): for lot in self.lots: if lot["status"] != "active": continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any( [i["status"] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints] ) pending_awards_complaints = any( [i.status in self.block_complaint_status for a in lot_awards for i in a.complaints] ) standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if a.complaintPeriod and a.complaintPeriod.endDate ] last_award_status = lot_awards[-1].status if lot_awards else "" if ( not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == "unsuccessful" ): checks.append(max(standStillEnds)) if self.status.startswith("active"): for award in self.awards: if award.status == "active" and not any([i.awardID == award.id for i in self.contracts]): checks.append(award.date) return min(checks).isoformat() if checks else None @serializable def numberOfBids(self): """A property that is serialized by schematics exports.""" return len([bid for bid in self.bids if bid.status in ("active", "pending")]) @serializable(serialized_name="minValue", type=ModelType(Value)) def tender_minValue(self): return ( Value( dict( amount=sum([i.minValue.amount for i in self.lots]), currency=self.minValue.currency, valueAddedTaxIncluded=self.minValue.valueAddedTaxIncluded, ) ) if self.lots else self.minValue ) @serializable(serialized_name="guarantee", serialize_when_none=False, type=ModelType(Guarantee)) def tender_guarantee(self): if self.lots: lots_amount = [i.guarantee.amount for i in self.lots if i.guarantee] if not lots_amount: return self.guarantee guarantee = {"amount": sum(lots_amount)} lots_currency = [i.guarantee.currency for i in self.lots if i.guarantee] guarantee["currency"] = lots_currency[0] if lots_currency else None if self.guarantee: guarantee["currency"] = self.guarantee.currency return Guarantee(guarantee) else: return self.guarantee @serializable(serialized_name="minimalStep", type=ModelType(Value), serialize_when_none=False) def tender_minimalStep(self): pass @serializable(serialized_name="minimalStepPercentage") def tender_minimalStepPercentage(self): return min([i.minimalStepPercentage for i in self.lots]) if self.lots else self.minimalStepPercentage @serializable(serialized_name="yearlyPaymentsPercentageRange") def tender_yearlyPaymentsPercentageRange(self): return ( min([i.yearlyPaymentsPercentageRange for i in self.lots]) if self.lots else self.yearlyPaymentsPercentageRange ) @serializable(serialized_name="noticePublicationDate", serialize_when_none=False, type=IsoDateTimeType()) def tender_noticePublicationDate(self): if not self.noticePublicationDate and self.status == "active.tendering": return self.get_root().request.now else: return self.noticePublicationDate def validate_items(self, data, items): cpv_336_group = items[0].classification.id[:3] == "336" if items else False if ( not cpv_336_group and (data.get("revisions")[0].date if data.get("revisions") else get_now()) > CPV_ITEMS_CLASS_FROM and items and len(set([i.classification.id[:4] for i in items])) != 1 ): raise ValidationError(u"CPV class of items should be identical") else: validate_cpv_group(items) def validate_features(self, data, features): if ( features and data["lots"] and any( [ round( vnmax( [ i for i in features if i.featureOf == "tenderer" or i.featureOf == "lot" and i.relatedItem == lot["id"] or i.featureOf == "item" and i.relatedItem in [j.id for j in data["items"] if j.relatedLot == lot["id"]] ] ), 15, ) > 0.25 for lot in data["lots"] ] ) ): raise ValidationError(u"Sum of max value of all features for lot should be less then or equal to 25%") elif features and not data["lots"] and round(vnmax(features), 15) > 0.25: raise ValidationError(u"Sum of max value of all features should be less then or equal to 25%") def validate_auctionUrl(self, data, url): if url and data["lots"]: raise ValidationError(u"url should be posted for each lot") def validate_minimalStep(self, data, value): pass def validate_tenderPeriod(self, data, period): if period: if is_new_created(data): _validate_tender_period_start_date(data, period) _validate_tender_period_duration(data, period, TENDERING_DURATION) def validate_awardPeriod(self, data, period): if ( period and period.startDate and data.get("auctionPeriod") and data.get("auctionPeriod").endDate and period.startDate < data.get("auctionPeriod").endDate ): raise ValidationError(u"period should begin after auctionPeriod") if ( period and period.startDate and data.get("tenderPeriod") and data.get("tenderPeriod").endDate and period.startDate < data.get("tenderPeriod").endDate ): raise ValidationError(u"period should begin after tenderPeriod") def validate_lots(self, data, value): if len(set([lot.guarantee.currency for lot in value if lot.guarantee])) > 1: raise ValidationError(u"lot guarantee currency should be identical to tender guarantee currency") if len(set([lot.fundingKind for lot in value])) > 1: raise ValidationError(u"lot funding kind should be identical to tender funding kind") def validate_yearlyPaymentsPercentageRange(self, data, value): if data["fundingKind"] == "other" and value != Decimal("0.8"): raise ValidationError("when fundingKind is other, yearlyPaymentsPercentageRange should be equal 0.8") if data["fundingKind"] == "budget" and (value > Decimal("0.8") or value < Decimal("0")): raise ValidationError( "when fundingKind is budget, yearlyPaymentsPercentageRange should be less or equal 0.8, and more or equal 0" ) def check_auction_time(self): if check_auction_period(self.auctionPeriod, self): self.auctionPeriod.startDate = None for lot in self.lots: if check_auction_period(lot.auctionPeriod, self): lot.auctionPeriod.startDate = None def invalidate_bids_data(self): self.check_auction_time() self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid" # Not required milestones def validate_milestones(self, data, value): pass
class CompetitiveDialogEU(BaseTenderEU): procurementMethodType = StringType(default=CD_EU_TYPE) status = StringType( choices=[ "draft", "active.tendering", "active.pre-qualification", "active.pre-qualification.stand-still", "active.stage2.pending", "active.stage2.waiting", "complete", "cancelled", "unsuccessful", ], default="active.tendering", ) # A list of all the companies who entered submissions for the tender. bids = SifterListType(ModelType(Bid, required=True), default=list(), filter_by="status", filter_in_values=["invalid", "deleted"]) TenderID = StringType(required=False) stage2TenderID = StringType(required=False) features = ListType(ModelType(Feature, required=True), validators=[validate_features_uniq]) lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) items = ListType( ModelType(BaseEUItem, required=True), required=True, min_size=1, validators=[validate_cpv_group, validate_items_uniq], ) mainProcurementCategory = StringType(choices=["services", "works"]) class Options: namespace = "Tender" _parent_roles = BaseTenderEU.Options.roles _stage2_id = whitelist("stage2TenderID") _pre_qualifications_role = _parent_roles[ "active.pre-qualification"] + _stage2_id - whitelist( "auctionPeriod") _view_role = _parent_roles["view"] + _stage2_id - whitelist( "auctionPeriod") _tendering_role = _parent_roles[ "active.tendering"] + _stage2_id - whitelist("auctionPeriod") roles = { "create": _parent_roles["create"], "active.pre-qualification": _pre_qualifications_role, "active.pre-qualification.stand-still": _pre_qualifications_role, "active.stage2.pending": _pre_qualifications_role, "active.stage2.waiting": _pre_qualifications_role, "edit_active.stage2.pending": whitelist("status"), "draft": _tendering_role, "active.tendering": _tendering_role, "complete": _view_role, "unsuccessful": _view_role, "view": _view_role, "cancelled": _view_role, "chronograph": _parent_roles["chronograph"], "chronograph_view": _parent_roles["chronograph_view"], "Administrator": _parent_roles["Administrator"], "default": _parent_roles["default"], "plain": _parent_roles["plain"], "contracting": _parent_roles["contracting"], "listing": _parent_roles["listing"], "competitive_dialogue": whitelist("status", "stage2TenderID"), } def get_role(self): root = self.__parent__ request = root.request if request.authenticated_role == "Administrator": role = "Administrator" elif request.authenticated_role == "chronograph": role = "chronograph" elif request.authenticated_role == "competitive_dialogue": role = "competitive_dialogue" else: role = "edit_{}".format(request.context.status) return role def __acl__(self): acl = [(Allow, "{}_{}".format(i.owner, i.owner_token), "create_qualification_complaint") for i in self.bids if i.status in ["active", "unsuccessful"]] acl.extend([(Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids if i.status == "active"]) acl.extend([ (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"), (Allow, "g:competitive_dialogue", "extract_credentials"), (Allow, "g:competitive_dialogue", "edit_tender"), (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_cancellation"), (Allow, "{}_{}".format(self.owner, self.owner_token), "upload_qualification_documents"), ]) self._acl_cancellation_complaint(acl) return acl def validate_features(self, data, features): validate_features_custom_weight(self, data, features, FEATURES_MAX_SUM)
class Tender(BaseTender): """ ESCO Tender model """ class Options: roles = { 'plain': plain_role, 'create': create_role_eu + blacklist('minValue', 'tender_minValue', 'minimalStep', 'tender_minimalStep'), 'edit': edit_role_eu + blacklist('minValue', 'tender_minValue', 'minimalStep', 'tender_minimalStep'), 'edit_draft': edit_role_eu + blacklist('minValue', 'tender_minValue', 'minimalStep', 'tender_minimalStep'), 'edit_active.tendering': edit_role_eu + blacklist('minValue', 'tender_minValue', 'minimalStep', 'tender_minimalStep'), 'edit_active.pre-qualification': whitelist('status'), 'edit_active.pre-qualification.stand-still': whitelist(), 'edit_active.auction': whitelist(), 'edit_active.qualification': whitelist(), 'edit_active.awarded': whitelist(), 'edit_complete': whitelist(), 'edit_unsuccessful': whitelist(), 'edit_cancelled': whitelist(), 'view': view_role, 'listing': listing_role, 'auction_view': auction_view_role + whitelist('NBUdiscountRate', 'minimalStepPercentage'), 'auction_post': auction_post_role, 'auction_patch': auction_patch_role, 'draft': enquiries_role, 'active.tendering': enquiries_role, 'active.pre-qualification': pre_qualifications_role, 'active.pre-qualification.stand-still': pre_qualifications_role, 'active.auction': pre_qualifications_role, 'active.qualification': view_role, 'active.awarded': view_role, 'complete': view_role, 'unsuccessful': view_role, 'cancelled': view_role, 'chronograph': chronograph_role, 'chronograph_view': chronograph_view_role, 'Administrator': Administrator_role, 'default': schematics_default_role, 'contracting': whitelist('doc_id', 'owner'), } procurementMethodType = StringType(default="esco") title_en = StringType(required=True, min_length=1) items = ListType(ModelType(Item), required=True, min_size=1, validators=[validate_cpv_group, validate_items_uniq]) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. minValue = ModelType(Value, required=False, default={'amount': 0, 'currency': 'UAH', 'valueAddedTaxIncluded': True}) # The total estimated value of the procurement. enquiryPeriod = ModelType(EnquiryPeriod, required=False) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) auctionPeriod = ModelType(TenderAuctionPeriod, default={}) hasEnquiries = BooleanType() # A Yes/No field as to whether enquiries were part of tender process. awardPeriod = ModelType(Period) # The date or period on which an award is anticipated to be made. numberOfBidders = IntType() # The number of unique tenderers who participated in the tender bids = SifterListType(BidModelType(Bid), default=list(), filter_by='status', filter_in_values=['invalid', 'invalid.pre-qualification', 'deleted']) # A list of all the companies who entered submissions for the tender. procuringEntity = ModelType(ProcuringEntity, required=True) # The entity managing the procurement, which may be different from the buyer who is paying / using the items being procured. awards = ListType(ModelType(Award), default=list()) contracts = ListType(ModelType(Contract), default=list()) minimalStep = ModelType(Value, required=False) # Not required, blocked for create/edit, since we have minimalStepPercentage in esco minimalStepPercentage = FloatType(required=True, min_value=0.005, max_value=0.03) questions = ListType(ModelType(Question), default=list()) complaints = ListType(ComplaintModelType(Complaint), default=list()) auctionUrl = URLType() cancellations = ListType(ModelType(Cancellation), default=list()) features = ListType(ModelType(Feature), validators=[validate_features_uniq]) lots = ListType(ModelType(Lot), default=list(), validators=[validate_lots_uniq]) guarantee = ModelType(Guarantee) documents = ListType(ModelType(Document), default=list()) # All documents and attachments related to the tender. qualifications = ListType(ModelType(Qualification), default=list()) qualificationPeriod = ModelType(Period) status = StringType(choices=['draft', 'active.tendering', 'active.pre-qualification', 'active.pre-qualification.stand-still', 'active.auction', 'active.qualification', 'active.awarded', 'complete', 'cancelled', 'unsuccessful'], default='active.tendering') NBUdiscountRate = FloatType(required=True, min_value=0, max_value=0.99) fundingKind = StringType(choices=['budget', 'other']) submissionMethodDetails = StringType(default="quick(mode:no-auction)") # TODO: temporary decision, while esco auction is not ready. Remove after adding auction. Remove function "check_submission_method_details" in openprocurement.tender.esco.subscribers create_accreditation = 3 edit_accreditation = 4 procuring_entity_kinds = ['general', 'special', 'defense'] block_tender_complaint_status = OpenUATender.block_tender_complaint_status block_complaint_status = OpenUATender.block_complaint_status def __local_roles__(self): roles = dict([('{}_{}'.format(self.owner, self.owner_token), 'tender_owner')]) for i in self.bids: roles['{}_{}'.format(i.owner, i.owner_token)] = 'bid_owner' return roles def __acl__(self): acl = [ (Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_qualification_complaint') for i in self.bids if i.status in ['active', 'unsuccessful'] ] acl.extend([ (Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_award_complaint') for i in self.bids if i.status == 'active' ]) acl.extend([ (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_tender'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'upload_tender_documents'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_complaint'), ]) return acl @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): endDate = calculate_business_date(self.tenderPeriod.endDate, -QUESTIONS_STAND_STILL, self) return EnquiryPeriod(dict(startDate=self.tenderPeriod.startDate, endDate=endDate, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=calculate_business_date(endDate, ENQUIRY_STAND_STILL_TIME, self, True))) @serializable(type=ModelType(Period)) def complaintPeriod(self): normalized_end = calculate_normalized_date(self.tenderPeriod.endDate, self) return Period(dict(startDate=self.tenderPeriod.startDate, endDate=calculate_business_date(normalized_end, -COMPLAINT_SUBMIT_TIME, self))) @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] if self.status == 'active.tendering' and self.tenderPeriod.endDate and \ not has_unanswered_complaints(self) and not has_unanswered_questions(self): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif self.status == 'active.pre-qualification.stand-still' and self.qualificationPeriod and self.qualificationPeriod.endDate: active_lots = [lot.id for lot in self.lots if lot.status == 'active'] if self.lots else [None] if not any([ i.status in self.block_complaint_status for q in self.qualifications for i in q.complaints if q.lotID in active_lots ]): checks.append(self.qualificationPeriod.endDate.astimezone(TZ)) elif not self.lots and self.status == 'active.auction' and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate: if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time(self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ): checks.append(calc_auction_end_time(self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ)) elif self.lots and self.status == 'active.auction': for lot in self.lots: if lot.status != 'active' or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate: continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) elif now < calc_auction_end_time(lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ): checks.append(calc_auction_end_time(lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ)) elif not self.lots and self.status == 'active.awarded' and not any([ i.status in self.block_complaint_status for i in self.complaints ]) and not any([ i.status in self.block_complaint_status for a in self.awards for i in a.complaints ]): standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if a.complaintPeriod.endDate ] last_award_status = self.awards[-1].status if self.awards else '' if standStillEnds and last_award_status == 'unsuccessful': checks.append(max(standStillEnds)) elif self.lots and self.status in ['active.qualification', 'active.awarded'] and not any([ i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints ]): for lot in self.lots: if lot['status'] != 'active': continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any([ i['status'] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints ]) pending_awards_complaints = any([ i.status in self.block_complaint_status for a in lot_awards for i in a.complaints ]) standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if a.complaintPeriod.endDate ] last_award_status = lot_awards[-1].status if lot_awards else '' if not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == 'unsuccessful': checks.append(max(standStillEnds)) if self.status.startswith('active'): for award in self.awards: if award.status == 'active' and not any([i.awardID == award.id for i in self.contracts]): checks.append(award.date) return min(checks).isoformat() if checks else None @serializable def numberOfBids(self): """A property that is serialized by schematics exports.""" return len([bid for bid in self.bids if bid.status in ("active", "pending",)]) @serializable(serialized_name="minValue", type=ModelType(Value)) def tender_minValue(self): return Value(dict(amount=sum([i.minValue.amount for i in self.lots]), currency=self.minValue.currency, valueAddedTaxIncluded=self.minValue.valueAddedTaxIncluded)) if self.lots else self.minValue @serializable(serialized_name="guarantee", serialize_when_none=False, type=ModelType(Guarantee)) def tender_guarantee(self): if self.lots: lots_amount = [i.guarantee.amount for i in self.lots if i.guarantee] if not lots_amount: return self.guarantee guarantee = {'amount': sum(lots_amount)} lots_currency = [i.guarantee.currency for i in self.lots if i.guarantee] guarantee['currency'] = lots_currency[0] if lots_currency else None if self.guarantee: guarantee['currency'] = self.guarantee.currency return Guarantee(guarantee) else: return self.guarantee @serializable(serialized_name="minimalStep", type=ModelType(Value), serialize_when_none=False) def tender_minimalStep(self): pass # return Value(dict(amount=min([i.minimalStep.amount for i in self.lots]), # currency=self.minimalStep.currency, # valueAddedTaxIncluded=self.minimalStep.valueAddedTaxIncluded)) if self.lots else self.minimalStep @serializable(serialized_name="minimalStepPercentage") def tender_minimalStepPercentage(self): return min([i.minimalStepPercentage for i in self.lots]) if self.lots else self.minimalStepPercentage def validate_items(self, data, items): cpv_336_group = items[0].classification.id[:3] == '336' if items else False if not cpv_336_group and (data.get('revisions')[0].date if data.get('revisions') else get_now()) > CPV_ITEMS_CLASS_FROM and items and len(set([i.classification.id[:4] for i in items])) != 1: raise ValidationError(u"CPV class of items should be identical") else: validate_cpv_group(items) def validate_features(self, data, features): if features and data['lots'] and any([ round(vnmax([ i for i in features if i.featureOf == 'tenderer' or i.featureOf == 'lot' and i.relatedItem == lot['id'] or i.featureOf == 'item' and i.relatedItem in [j.id for j in data['items'] if j.relatedLot == lot['id']] ]), 15) > 0.3 for lot in data['lots'] ]): raise ValidationError(u"Sum of max value of all features for lot should be less then or equal to 30%") elif features and not data['lots'] and round(vnmax(features), 15) > 0.3: raise ValidationError(u"Sum of max value of all features should be less then or equal to 30%") def validate_auctionUrl(self, data, url): if url and data['lots']: raise ValidationError(u"url should be posted for each lot") def validate_minimalStep(self, data, value): if value and value.amount and data.get('minValue'): if data.get('minValue').currency != value.currency: raise ValidationError(u"currency should be identical to currency of minValue of tender") if data.get('minValue').valueAddedTaxIncluded != value.valueAddedTaxIncluded: raise ValidationError(u"valueAddedTaxIncluded should be identical to valueAddedTaxIncluded of minValue of tender") def validate_tenderPeriod(self, data, period): # if data['_rev'] is None when tender was created just now if not data['_rev'] and calculate_business_date(get_now(), -timedelta(minutes=10)) >= period.startDate: raise ValidationError(u"tenderPeriod.startDate should be in greater than current date") if period and calculate_business_date(period.startDate, TENDERING_DURATION, data) > period.endDate: raise ValidationError(u"tenderPeriod should be greater than {} days".format(TENDERING_DAYS)) def validate_awardPeriod(self, data, period): if period and period.startDate and data.get('auctionPeriod') and data.get('auctionPeriod').endDate and period.startDate < data.get('auctionPeriod').endDate: raise ValidationError(u"period should begin after auctionPeriod") if period and period.startDate and data.get('tenderPeriod') and data.get('tenderPeriod').endDate and period.startDate < data.get('tenderPeriod').endDate: raise ValidationError(u"period should begin after tenderPeriod") def validate_lots(self, data, value): if len(set([lot.guarantee.currency for lot in value if lot.guarantee])) > 1: raise ValidationError(u"lot guarantee currency should be identical to tender guarantee currency") if len(set([lot.fundingKind for lot in value])) > 1: raise ValidationError(u"lot funding kind should be identical to tender funding kind") def check_auction_time(self): if self.auctionPeriod and self.auctionPeriod.startDate and self.auctionPeriod.shouldStartAfter \ and self.auctionPeriod.startDate > calculate_business_date(parse_date(self.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): self.auctionPeriod.startDate = None for lot in self.lots: if lot.auctionPeriod and lot.auctionPeriod.startDate and lot.auctionPeriod.shouldStartAfter \ and lot.auctionPeriod.startDate > calculate_business_date(parse_date(lot.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): lot.auctionPeriod.startDate = None def invalidate_bids_data(self): self.check_auction_time() self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"
class Tender(BaseTender): """ OpenEU tender model """ class Options: namespace = "Tender" _parent_roles = BaseTender.Options.roles _edit_role = _parent_roles["edit"] - whitelist("enquiryPeriod") _read_fields = whitelist("qualifications", "qualificationPeriod", "complaintPeriod") _tendering_role = _parent_roles[ "active.tendering"] + _read_fields + whitelist( "tender_enquiryPeriod") _view_role = _parent_roles["view"] + _read_fields _pre_qualifications_role = _view_role _all_forbidden = whitelist() roles = { "create": _parent_roles["create"] - whitelist("enquiryPeriod") + whitelist("awardCriteria"), "edit": _edit_role, "edit_draft": _edit_role + whitelist("status"), "edit_active.tendering": _edit_role, "edit_active.pre-qualification": whitelist("status"), "edit_active.pre-qualification.stand-still": _all_forbidden, "edit_active.auction": _all_forbidden, "edit_active.qualification": _all_forbidden, "edit_active.awarded": _all_forbidden, "edit_complete": _all_forbidden, "edit_unsuccessful": _all_forbidden, "edit_cancelled": _all_forbidden, "active.pre-qualification": _pre_qualifications_role, "active.pre-qualification.stand-still": _pre_qualifications_role, "active.auction": _pre_qualifications_role, "draft": _tendering_role, "active.tendering": _tendering_role, "active.qualification": _view_role, "active.awarded": _view_role, "complete": _view_role, "unsuccessful": _view_role, "cancelled": _view_role, "view": _view_role, "auction_view": _parent_roles["auction_view"], "auction_post": _parent_roles["auction_post"], "auction_patch": _parent_roles["auction_patch"], "chronograph": _parent_roles["chronograph"], "chronograph_view": _parent_roles["chronograph_view"], "Administrator": _parent_roles["Administrator"], "default": _parent_roles["default"], "plain": _parent_roles["plain"], "contracting": _parent_roles["contracting"], "listing": _parent_roles["listing"], } awardCriteria = StringType( choices=[AWARD_CRITERIA_LOWEST_COST, AWARD_CRITERIA_LIFE_CYCLE_COST], default=AWARD_CRITERIA_LOWEST_COST) procurementMethodType = StringType(default="aboveThresholdEU") title_en = StringType(required=True, min_length=1) enquiryPeriod = ModelType(EnquiryPeriod, required=False) tenderPeriod = ModelType(PeriodStartEndRequired, required=True) auctionPeriod = ModelType(TenderAuctionPeriod, default={}) documents = ListType( ModelType(EUDocument, required=True), default=list()) # All documents and attachments related to the tender. items = ListType( ModelType(Item, required=True), required=True, min_size=1, validators=[ validate_cpv_group, validate_items_uniq, validate_classification_id ], ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. complaints = ListType(ComplaintModelType(Complaint, required=True), default=list()) contracts = ListType(ModelType(Contract, required=True), default=list()) cancellations = ListType(ModelType(Cancellation, required=True), default=list()) awards = ListType(ModelType(Award, required=True), default=list()) procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items being procured. bids = SifterListType( BidModelType(Bid), default=list(), filter_by="status", filter_in_values=["invalid", "invalid.pre-qualification", "deleted"], ) # A list of all the companies who entered submissions for the tender. qualifications = ListType(ModelType(Qualification, required=True), default=list()) qualificationPeriod = ModelType(Period) lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) status = StringType( choices=[ "draft", "active.tendering", "active.pre-qualification", "active.pre-qualification.stand-still", "active.auction", "active.qualification", "active.awarded", "complete", "cancelled", "unsuccessful", ], default="active.tendering", ) create_accreditations = (ACCR_3, ACCR_5) central_accreditations = (ACCR_5, ) edit_accreditations = (ACCR_4, ) procuring_entity_kinds = [ "authority", "central", "defense", "general", "social", "special" ] block_tender_complaint_status = OpenUATender.block_tender_complaint_status block_complaint_status = OpenUATender.block_complaint_status def __acl__(self): acl = [(Allow, "{}_{}".format(i.owner, i.owner_token), "create_qualification_complaint") for i in self.bids if i.status in ["active", "unsuccessful"]] acl.extend([(Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids if i.status == "active"]) acl.extend([ (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"), (Allow, "{}_{}".format(self.owner, self.owner_token), "edit_contract"), (Allow, "{}_{}".format(self.owner, self.owner_token), "upload_contract_documents"), (Allow, "{}_{}".format(self.owner, self.owner_token), "upload_qualification_documents"), ]) self._acl_cancellation_complaint(acl) return acl def validate_awardCriteria(self, data, value): if value == AWARD_CRITERIA_LIFE_CYCLE_COST: if data.get("features", []): raise ValidationError( "Can`t add features with {} awardCriteria".format( AWARD_CRITERIA_LIFE_CYCLE_COST)) def validate_enquiryPeriod(self, data, period): # for deactivate validation to enquiryPeriod from parent class return @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): end_date = calculate_tender_business_date(self.tenderPeriod.endDate, -QUESTIONS_STAND_STILL, self) clarifications_until = calculate_clarif_business_date( end_date, ENQUIRY_STAND_STILL_TIME, self, True) return EnquiryPeriod( dict( startDate=self.tenderPeriod.startDate, endDate=end_date, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=clarifications_until, )) @serializable(type=ModelType(Period)) def complaintPeriod(self): end_date = calculate_complaint_business_date(self.tenderPeriod.endDate, -COMPLAINT_SUBMIT_TIME, self) return Period( dict(startDate=self.tenderPeriod.startDate, endDate=end_date)) @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] extend_next_check_by_complaint_period_ends(self, checks) if cancellation_block_tender(self): return min(checks).isoformat() if checks else None if (self.status == "active.tendering" and self.tenderPeriod.endDate and not has_unanswered_complaints(self) and not has_unanswered_questions(self)): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif (self.status == "active.pre-qualification.stand-still" and self.qualificationPeriod and self.qualificationPeriod.endDate): active_lots = [ lot.id for lot in self.lots if lot.status == "active" ] if self.lots else [None] if not any([ i.status in self.block_complaint_status for q in self.qualifications for i in q.complaints if q.lotID in active_lots ]): checks.append(self.qualificationPeriod.endDate.astimezone(TZ)) elif (not self.lots and self.status == "active.auction" and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate): if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif self.lots and self.status == "active.auction": for lot in self.lots: if (lot.status != "active" or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate): continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif (not self.lots and self.status == "active.awarded" and not any( [i.status in self.block_complaint_status for i in self.complaints]) and not any([ i.status in self.block_complaint_status for a in self.awards for i in a.complaints ])): standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if a.complaintPeriod and a.complaintPeriod.endDate ] last_award_status = self.awards[-1].status if self.awards else "" if standStillEnds and last_award_status == "unsuccessful": checks.append(max(standStillEnds)) elif (self.lots and self.status in ["active.qualification", "active.awarded"] and not any([ i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints ])): for lot in self.lots: if lot["status"] != "active": continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any([ i["status"] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints ]) pending_awards_complaints = any([ i.status in self.block_complaint_status for a in lot_awards for i in a.complaints ]) standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if a.complaintPeriod and a.complaintPeriod.endDate ] last_award_status = lot_awards[-1].status if lot_awards else "" if (not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == "unsuccessful"): checks.append(max(standStillEnds)) if self.status and self.status.startswith("active"): for award in self.awards: if award.status == "active" and not any( [i.awardID == award.id for i in self.contracts]): checks.append(award.date) return min(checks).isoformat() if checks else None def validate_tenderPeriod(self, data, period): if is_new_created(data): _validate_tender_period_start_date(data, period) _validate_tender_period_duration(data, period, TENDERING_DURATION) @serializable def numberOfBids(self): """A property that is serialized by schematics exports.""" return len( [bid for bid in self.bids if bid.status in ("active", "pending")]) def check_auction_time(self): if check_auction_period(self.auctionPeriod, self): self.auctionPeriod.startDate = None for lot in self.lots: if check_auction_period(lot.auctionPeriod, self): lot.auctionPeriod.startDate = None def invalidate_bids_data(self): self.check_auction_time() self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"
class Tender(BaseTender): """Data regarding tender process - publicly inviting prospective contractors to submit bids for evaluation and selecting a winner or winners.""" procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items lots = ListType(ModelType(Lot, required=True), default=list(), validators=[validate_lots_uniq]) procurementMethodType = StringType(default="aboveThresholdUA.defense") procuring_entity_kinds = ["defense"] bids = SifterListType(ModelType(Bid, required=True), default=list(), filter_by="status", filter_in_values=["invalid", "deleted"]) cancellations = ListType(ModelType(Cancellation, required=True), default=list()) def validate_tenderPeriod(self, data, period): if period: _validate_tender_period_duration(data, period, TENDERING_DURATION, working_days=True) @serializable(serialized_name="enquiryPeriod", type=ModelType(EnquiryPeriod)) def tender_enquiryPeriod(self): end_date = calculate_tender_business_date(self.tenderPeriod.endDate, -ENQUIRY_PERIOD_TIME, self, True) clarifications_until = calculate_clarif_business_date( end_date, ENQUIRY_STAND_STILL_TIME, self, True) return EnquiryPeriod( dict( startDate=self.tenderPeriod.startDate, endDate=end_date, invalidationDate=self.enquiryPeriod and self.enquiryPeriod.invalidationDate, clarificationsUntil=clarifications_until, )) @serializable(type=ModelType(Period)) def complaintPeriod(self): if self.tenderPeriod.startDate < COMPLAINT_OLD_SUBMIT_TIME_BEFORE: end_date = calculate_tender_business_date( self.tenderPeriod.endDate, -COMPLAINT_OLD_SUBMIT_TIME, self) else: end_date = calculate_complaint_business_date( self.tenderPeriod.endDate, -COMPLAINT_SUBMIT_TIME, self, True) return Period( dict(startDate=self.tenderPeriod.startDate, endDate=end_date)) def validate_criteria(self, data, value): if value: raise ValidationError("Rogue field") @serializable(serialize_when_none=False) def next_check(self): now = get_now() checks = [] extend_next_check_by_complaint_period_ends(self, checks) if cancellation_block_tender(self): return min(checks).isoformat() if checks else None if (self.status == "active.tendering" and self.tenderPeriod.endDate and not has_unanswered_complaints(self) and not has_unanswered_questions(self)): checks.append(self.tenderPeriod.endDate.astimezone(TZ)) elif (not self.lots and self.status == "active.auction" and self.auctionPeriod and self.auctionPeriod.startDate and not self.auctionPeriod.endDate): if now < self.auctionPeriod.startDate: checks.append(self.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( self.numberOfBids, self.auctionPeriod.startDate).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif self.lots and self.status == "active.auction": for lot in self.lots: if (lot.status != "active" or not lot.auctionPeriod or not lot.auctionPeriod.startDate or lot.auctionPeriod.endDate): continue if now < lot.auctionPeriod.startDate: checks.append(lot.auctionPeriod.startDate.astimezone(TZ)) else: auction_end_time = calc_auction_end_time( lot.numberOfBids, lot.auctionPeriod.startDate).astimezone(TZ) if now < auction_end_time: checks.append(auction_end_time) elif (not self.lots and self.status == "active.awarded" and not any( [i.status in self.block_complaint_status for i in self.complaints]) and not any([ i.status in self.block_complaint_status for a in self.awards for i in a.complaints ])): first_revision_date = get_first_revision_date(self) new_defence_complaints = NEW_DEFENSE_COMPLAINTS_FROM < first_revision_date < NEW_DEFENSE_COMPLAINTS_TO standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in self.awards if (a.complaintPeriod and a.complaintPeriod.endDate and ( a.status != "cancelled" if new_defence_complaints else True )) ] last_award_status = self.awards[-1].status if self.awards else "" if standStillEnds and last_award_status == "unsuccessful": checks.append(max(standStillEnds)) elif (self.lots and self.status in ["active.qualification", "active.awarded"] and not any([ i.status in self.block_complaint_status and i.relatedLot is None for i in self.complaints ])): for lot in self.lots: if lot["status"] != "active": continue lot_awards = [i for i in self.awards if i.lotID == lot.id] pending_complaints = any([ i["status"] in self.block_complaint_status and i.relatedLot == lot.id for i in self.complaints ]) pending_awards_complaints = any([ i.status in self.block_complaint_status for a in lot_awards for i in a.complaints ]) first_revision_date = get_first_revision_date(self) new_defence_complaints = NEW_DEFENSE_COMPLAINTS_FROM < first_revision_date < NEW_DEFENSE_COMPLAINTS_TO standStillEnds = [ a.complaintPeriod.endDate.astimezone(TZ) for a in lot_awards if (a.complaintPeriod and a.complaintPeriod.endDate and ( a.status != "cancelled" if new_defence_complaints else True)) ] last_award_status = lot_awards[-1].status if lot_awards else "" if (not pending_complaints and not pending_awards_complaints and standStillEnds and last_award_status == "unsuccessful"): checks.append(max(standStillEnds)) if self.status.startswith("active"): for award in self.awards: if award.status == "active" and not any( [i.awardID == award.id for i in self.contracts]): checks.append(award.date) return min(checks).isoformat() if checks else None
class CloseFrameworkAgreementUA(Tender): """ OpenEU tender model """ class Options: namespace = 'Tender' roles = RolesFromCsv('CloseFrameworkAgreementUA.csv', relative_to=__file__) create_accreditation = 3 edit_accreditation = 4 procuring_entity_kinds = ['general', 'special', 'defense'] block_tender_complaint_status = [ 'claim', 'pending', 'accepted', 'satisfied', 'stopping' ] block_complaint_status = ['pending', 'accepted', 'satisfied', 'stopping'] auctionPeriod = ModelType(TenderAuctionPeriod, default={}) auctionUrl = URLType() awards = ListType(ModelType(Award), default=list()) awardPeriod = ModelType( Period ) # The dat e or period on which an award is anticipated to be made. bids = SifterListType( BidModelType(Bid), default=list(), filter_by='status', filter_in_values=['invalid', 'invalid.pre-qualification', 'deleted'] ) # A list of all the companies who entered submissions for the tender. cancellations = ListType(ModelType(Cancellation), default=list()) complaints = ListType(ComplaintModelType(Complaint), default=list()) contractPeriod = ModelType(ContractPeriod, required=False) agreements = ListType(ModelType(Agreement), default=list()) documents = ListType( ModelType(EUDocument), default=list()) # All documents and attachments related to the tender. enquiryPeriod = ModelType(EnquiryPeriod, required=False) guarantee = ModelType(Guarantee) hasEnquiries = BooleanType( ) # A Yes/No field as to whether enquiries were part of tender process. items = ListType( ModelType(Item), required=True, min_size=1, validators=[validate_cpv_group, validate_items_uniq] ) # The goods and services to be purchased, broken into line items wherever possible. Items should not be duplicated, but a quantity of 2 specified instead. features = ListType(ModelType(Feature), validators=[validate_features_uniq]) minimalStep = ModelType(Value, required=True) numberOfBidders = IntType( ) # The number of unique tenderers who participated in the tender maxAwardsCount = IntType(required=True, validators=[validate_max_awards_number]) lots = ListType(ModelType(Lot), min_size=1, max_size=1, default=list(), validators=[validate_lots_uniq]) procurementMethodType = StringType(default="closeFrameworkAgreementUA") procuringEntity = ModelType( ProcuringEntity, required=True ) # The entity managing the procurement, which may be different from the buyer who is paying / using the items being procured. qualificationPeriod = ModelType(Period) qualifications = ListType(ModelType(Qualification), default=list()) questions = ListType(ModelType(Question), default=list()) status = StringType(choices=[ 'draft', 'active.tendering', 'active.pre-qualification', 'active.pre-qualification.stand-still', 'active.auction', 'active.qualification', 'active.qualification.stand-still', 'active.awarded', 'complete', 'cancelled', 'unsuccessful' ], default='active.tendering') tenderPeriod = ModelType(PeriodStartEndRequired, required=True) title_en = StringType(required=True, min_length=1) value = ModelType( Value, required=True) # The total estimated value of the procurement. agreementDuration = IsoDurationType( required=True, validators=[validate_max_agreement_duration_period]) def __local_roles__(self): roles = dict([('{}_{}'.format(self.owner, self.owner_token), 'tender_owner')]) for i in self.bids: roles['{}_{}'.format(i.owner, i.owner_token)] = 'bid_owner' return roles def __acl__(self): acl = [(Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_qualification_complaint') for i in self.bids if i.status in ['active', 'unsuccessful', 'invalid.pre-qualification']] acl.extend([(Allow, '{}_{}'.format(i.owner, i.owner_token), 'create_award_complaint') for i in self.bids if i.status == 'active']) acl.extend([ (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_tender'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'upload_tender_documents'), (Allow, '{}_{}'.format(self.owner, self.owner_token), 'edit_complaint'), ]) return acl def check_auction_time(self): if self.auctionPeriod and self.auctionPeriod.startDate and self.auctionPeriod.shouldStartAfter \ and self.auctionPeriod.startDate > calculate_business_date(parse_date(self.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): self.auctionPeriod.startDate = None for lot in self.lots: if lot.auctionPeriod and lot.auctionPeriod.startDate and lot.auctionPeriod.shouldStartAfter \ and lot.auctionPeriod.startDate > calculate_business_date(parse_date(lot.auctionPeriod.shouldStartAfter), AUCTION_PERIOD_TIME, self, True): lot.auctionPeriod.startDate = None def invalidate_bids_data(self): self.check_auction_time() self.enquiryPeriod.invalidationDate = get_now() for bid in self.bids: if bid.status not in ["deleted", "draft"]: bid.status = "invalid"