class CFASelectionUATender(BaseTender):
"""Data regarding tender process - publicly inviting prospective contractors
to submit bids for evaluation and selecting a winner or winners.
"""
class Options:
namespace = "Tender"
_core_roles = BaseTender.Options.roles
_not_implemented = whitelist("mainProcurementCategory", "milestones")
_base_edit = (
_core_roles["edit"]
- _not_implemented
+ whitelist(
"procuringEntity",
"numberOfBidders",
"serializable_guarantee",
"items",
"next_check",
"tender_guarantee",
"numberOfBids",
"agreements",
"hasEnquiries",
)
)
_edit_role = _base_edit + whitelist(
"enquiryPeriod", "tender_minimalStep", "contracts", "tenderPeriod", "features", "serializable_minimalStep"
)
_draft_view_role = (
_core_roles["view"]
- _not_implemented
+ whitelist(
"tender_guarantee",
"awardPeriod",
"auctionUrl",
"auctionPeriod",
"next_check",
"procuringEntity",
"questions",
"complaints",
"lots",
"items",
"cancellations",
"contracts",
"agreements",
"numberOfBidders",
"awards",
"serializable_guarantee",
"hasEnquiries",
)
)
_view_tendering_role = _draft_view_role + whitelist(
"tender_value",
"tenderPeriod",
"features",
"enquiryPeriod",
"tender_minimalStep",
"serializable_value",
"serializable_minimalStep",
)
_view_role = _view_tendering_role + whitelist("bids", "numberOfBids")
_procurement_method_details = whitelist("procurementMethodDetails")
roles = {
"create": _base_edit + whitelist("lots", "procurementMethodType", "mode"),
"edit_draft": _core_roles["edit_draft"] + _procurement_method_details,
"edit_draft.pending": whitelist("agreements", "unsuccessfulReason") + _procurement_method_details,
"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.tendering": _procurement_method_details,
"edit_active.qualification": _procurement_method_details,
"edit_active.enquiries": whitelist(
"description",
"description_en",
"description_ru",
"documents",
"items",
"lots",
"procurementMethodDetails",
"serializable_guarantee",
"tenderPeriod",
"tender_guarantee",
"title",
"title_en",
"title_ru",
),
"edit": _edit_role,
"edit_agreement_selection": whitelist("agreements", "procurementMethodDetails", "status"),
"active.tendering": _view_tendering_role,
"active.enquiries": _view_tendering_role,
"active.auction": _view_tendering_role,
"draft": _draft_view_role,
"draft.pending": _draft_view_role + whitelist("features"),
"draft.unsuccessful": _draft_view_role + whitelist("features", "unsuccessfulReason"),
"active.awarded": _view_role,
"unsuccessful": _view_role,
"cancelled": _view_role,
"view": _view_role,
"active.qualification": _view_role,
"complete": _view_role,
"chronograph": _core_roles["chronograph"] + _procurement_method_details,
"chronograph_view": _core_roles["chronograph_view"] + whitelist("agreements") + _procurement_method_details,
"Administrator": _core_roles["Administrator"] + _procurement_method_details,
"contracting": _core_roles["contracting"] + _procurement_method_details,
"auction_post": _core_roles["auction_post"] + _procurement_method_details,
"auction_patch": _core_roles["auction_patch"] + _procurement_method_details,
"auction_view": _core_roles["auction_view"]
- whitelist("minimalStep")
+ whitelist("serializable_minimalStep")
+ _procurement_method_details,
"listing": _core_roles["listing"] + _procurement_method_details,
"embedded": _core_roles["embedded"],
"plain": _core_roles["plain"],
"default": _core_roles["default"],
}
items = ListType(
ModelType(Item, required=True), min_size=1, validators=[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.
value = ModelType(Value) # The total estimated value of the procurement.
enquiryPeriod = ModelType(
PeriodEndRequired, required=False
) # The period during which enquiries may be made and will be answered.
tenderPeriod = ModelType(
PeriodEndRequired, required=False
) # The period when the tender is open for submissions. The end date is the closing date for tender submissions.
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 = ListType(
ModelType(Bid, required=True), default=list()
) # 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())
auctionPeriod = ModelType(TenderAuctionPeriod, default={})
minimalStep = ModelType(Value, required=False)
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], min_size=1, max_size=1
)
guarantee = ModelType(Guarantee)
status = StringType(
choices=[
"draft",
"draft.pending",
"draft.unsuccessful",
"active.enquiries",
"active.tendering",
"active.auction",
"active.qualification",
"active.awarded",
"complete",
"cancelled",
"unsuccessful",
],
default="draft",
) # TODO Refactoring status
agreements = ListType(ModelType(Agreement, required=True), default=list(), min_size=1, max_size=1)
procurementMethod = StringType(choices=["open", "selective", "limited"], default="selective")
procurementMethodType = StringType(default="closeFrameworkAgreementSelectionUA")
unsuccessfulReason = ListType(StringType, serialize_when_none=False)
procuring_entity_kinds = ["general", "special", "defense", "central", "other"]
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 == "auction":
role = "auction_{}".format(request.method.lower())
elif request.authenticated_role == "contracting":
role = "contracting"
elif request.authenticated_role == "agreement_selection":
role = "edit_{}".format(request.authenticated_role)
else:
role = "edit_{}".format(request.context.status)
return role
def __acl__(self):
acl = [(Allow, "{}_{}".format(i.owner, i.owner_token), "create_award_complaint") for i in self.bids]
acl.extend(
[
(Allow, "{}_{}".format(self.owner, self.owner_token), "edit_complaint"),
(Allow, "g:agreement_selection", "edit_agreement_selection"),
(Allow, "g:agreement_selection", "edit_tender"),
(Allow, "g:brokers", "create_cancellation_complaint")
]
)
self._acl_cancellation(acl)
return acl
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
# Non-required mainProcurementCategory
def validate_mainProcurementCategory(self, data, value):
pass
# Not required milestones
def validate_milestones(self, data, value):
pass
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,
'edit_draft': draft_role,
'edit_active.enquiries': edit_role,
'edit_active.tendering': 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,
'auction_post': auction_post_role,
'auction_patch': auction_patch_role,
'draft': enquiries_role,
'active.enquiries': 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'),
}
items = ListType(
ModelType(Item),
required=True,
min_size=1,
validators=[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.
value = ModelType(
Value, required=True) # The total estimated value of the procurement.
enquiryPeriod = ModelType(
PeriodEndRequired, required=True
) # The period during which enquiries may be made and will be answered.
tenderPeriod = ModelType(
PeriodEndRequired, required=True
) # The period when the tender is open for submissions. The end date is the closing date for tender submissions.
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 = ListType(ModelType(Bid), default=list(
)) # 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())
auctionPeriod = ModelType(TenderAuctionPeriod, default={})
minimalStep = ModelType(Value, required=True)
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)
procurementMethodType = StringType(default="belowThreshold")
procuring_entity_kinds = ['general', 'special', 'defense', 'other']
block_complaint_status = ['answered', 'pending']
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
@serializable(serialize_when_none=False)
def next_check(self):
now = get_now()
checks = []
if self.status == 'active.enquiries' and self.tenderPeriod.startDate:
checks.append(self.tenderPeriod.startDate.astimezone(TZ))
elif self.status == 'active.enquiries' and self.enquiryPeriod.endDate:
checks.append(self.enquiryPeriod.endDate.astimezone(TZ))
elif self.status == 'active.tendering' and self.tenderPeriod.endDate:
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'):
from openprocurement.tender.core.utils import calculate_business_date
for complaint in self.complaints:
if complaint.status == 'answered' and complaint.dateAnswered:
checks.append(
calculate_business_date(complaint.dateAnswered,
COMPLAINT_STAND_STILL_TIME,
self))
elif complaint.status == 'pending':
checks.append(self.dateModified)
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)
for complaint in award.complaints:
if complaint.status == 'answered' and complaint.dateAnswered:
checks.append(
calculate_business_date(
complaint.dateAnswered,
COMPLAINT_STAND_STILL_TIME, self))
elif complaint.status == 'pending':
checks.append(self.dateModified)
return min(checks).isoformat() if checks else None
@serializable
def numberOfBids(self):
"""A property that is serialized by schematics exports."""
return len(self.bids)
@serializable(serialized_name="value", type=ModelType(Value))
def tender_value(self):
return Value(
dict(amount=sum([i.value.amount for i in self.lots]),
currency=self.value.currency,
valueAddedTaxIncluded=self.value.valueAddedTaxIncluded)
) if self.lots else self.value
@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))
def tender_minimalStep(self):
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
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('value'):
if data.get('value').amount < value.amount:
raise ValidationError(
u"value should be less than value of tender")
if data.get('value').currency != value.currency:
raise ValidationError(
u"currency should be identical to currency of value of tender"
)
if data.get('value'
).valueAddedTaxIncluded != value.valueAddedTaxIncluded:
raise ValidationError(
u"valueAddedTaxIncluded should be identical to valueAddedTaxIncluded of value of tender"
)
def validate_tenderPeriod(self, data, period):
if period and period.startDate and data.get(
'enquiryPeriod') and data.get(
'enquiryPeriod').endDate and period.startDate < data.get(
'enquiryPeriod').endDate:
raise ValidationError(u"period should begin after enquiryPeriod")
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"
)
class Stack(Model):
name = StringType(required=True)
stack_name = StringType(serialize_when_none=False)
region = StringType(serialize_when_none=False)
profile = StringType(serialize_when_none=False)
class_path = StringType(serialize_when_none=False)
template_path = StringType(serialize_when_none=False)
description = StringType(serialize_when_none=False)
requires = ListType(StringType, serialize_when_none=False)
required_by = ListType(StringType, serialize_when_none=False)
locked = BooleanType(default=False)
enabled = BooleanType(default=True)
protected = BooleanType(default=False)
variables = DictType(AnyType, serialize_when_none=False)
parameters = DictType(AnyType, serialize_when_none=False)
tags = DictType(StringType, serialize_when_none=False)
stack_policy_path = StringType(serialize_when_none=False)
def validate_class_path(self, data, value):
if value and data["template_path"]:
raise ValidationError("template_path cannot be present when "
"class_path is provided.")
self.validate_stack_source(data)
def validate_template_path(self, data, value):
if value and data["class_path"]:
raise ValidationError("class_path cannot be present when "
"template_path is provided.")
self.validate_stack_source(data)
def validate_stack_source(self, data):
# Locked stacks don't actually need a template, since they're
# read-only.
if data["locked"]:
return
if not (data["class_path"] or data["template_path"]):
raise ValidationError("class_path or template_path is required.")
def validate_parameters(self, data, value):
if value:
stack_name = data['name']
raise ValidationError(
"DEPRECATION: Stack definition %s contains "
"deprecated 'parameters', rather than 'variables'. You are"
" required to update your config. See https://stacker.rea"
"dthedocs.io/en/latest/config.html#variables for "
"additional information." % stack_name)
return value
class Value(Guarantee):
valueAddedTaxIncluded = BooleanType(required=True, default=True)
class Bid(BaseBid):
class Options:
roles = {
"Administrator":
Administrator_bid_role,
"embedded":
view_bid_role,
"view":
view_bid_role,
"create":
whitelist(
"value",
"tenderers",
"parameters",
"lotValues",
"status",
"selfQualified",
"selfEligible",
"subcontractingDetails",
"documents",
"financialDocuments",
"eligibilityDocuments",
"qualificationDocuments",
),
"edit":
whitelist("value", "tenderers", "parameters", "lotValues",
"status", "subcontractingDetails"),
"auction_view":
whitelist("value", "lotValues", "id", "date", "parameters",
"participationUrl", "status"),
"auction_post":
whitelist("value", "lotValues", "id", "date"),
"auction_patch":
whitelist("id", "lotValues", "participationUrl"),
"active.enquiries":
whitelist(),
"active.tendering":
whitelist(),
"active.pre-qualification":
whitelist("id", "status", "documents", "eligibilityDocuments",
"tenderers"),
"active.pre-qualification.stand-still":
whitelist("id", "status", "documents", "eligibilityDocuments",
"tenderers"),
"active.auction":
whitelist("id", "status", "documents", "eligibilityDocuments",
"tenderers"),
"active.qualification":
view_bid_role,
"active.awarded":
view_bid_role,
"complete":
view_bid_role,
"unsuccessful":
view_bid_role,
"bid.unsuccessful":
whitelist(
"id",
"status",
"tenderers",
"documents",
"eligibilityDocuments",
"parameters",
"selfQualified",
"selfEligible",
"subcontractingDetails",
),
"cancelled":
view_bid_role,
"invalid":
whitelist("id", "status"),
"invalid.pre-qualification":
whitelist("id", "status", "documents", "eligibilityDocuments",
"tenderers"),
"deleted":
whitelist("id", "status"),
}
documents = ListType(ConfidentialDocumentModelType(EUConfidentialDocument,
required=True),
default=list())
financialDocuments = ListType(ConfidentialDocumentModelType(
EUConfidentialDocument, required=True),
default=list())
eligibilityDocuments = ListType(ConfidentialDocumentModelType(
EUConfidentialDocument, required=True),
default=list())
qualificationDocuments = ListType(ConfidentialDocumentModelType(
EUConfidentialDocument, required=True),
default=list())
lotValues = ListType(ModelType(LotValue, required=True), default=list())
selfQualified = BooleanType(required=True, choices=[True])
selfEligible = BooleanType(required=True, choices=[True])
subcontractingDetails = StringType()
parameters = ListType(ModelType(Parameter, required=True),
default=list(),
validators=[validate_parameters_uniq])
status = StringType(
choices=[
"draft", "pending", "active", "invalid",
"invalid.pre-qualification", "unsuccessful", "deleted"
],
default="pending",
)
def serialize(self, role=None):
if role and role != "create" and self.status in [
"invalid", "invalid.pre-qualification", "deleted"
]:
role = self.status
elif role and role != "create" and self.status == "unsuccessful":
role = "bid.unsuccessful"
return super(Bid, self).serialize(role)
@serializable(serialized_name="status")
def serialize_status(self):
if self.status in [
"draft",
"invalid",
"invalid.pre-qualification",
"unsuccessful",
"deleted",
] or self.__parent__.status in ["active.tendering", "cancelled"]:
return self.status
if self.__parent__.lots:
active_lots = [
lot.id for lot in self.__parent__.lots
if lot.status in ("active", "complete")
]
if not self.lotValues:
return "invalid"
elif [
i.relatedLot for i in self.lotValues
if i.status == "pending" and i.relatedLot in active_lots
]:
return "pending"
elif [
i.relatedLot for i in self.lotValues
if i.status == "active" and i.relatedLot in active_lots
]:
return "active"
else:
return "unsuccessful"
return self.status
@bids_validation_wrapper
def validate_value(self, data, value):
BaseBid._validator_functions["value"](self, data, value)
@bids_validation_wrapper
def validate_lotValues(self, data, lotValues):
BaseBid._validator_functions["lotValues"](self, data, lotValues)
@bids_validation_wrapper
def validate_participationUrl(self, data, participationUrl):
BaseBid._validator_functions["participationUrl"](self, data,
participationUrl)
@bids_validation_wrapper
def validate_parameters(self, data, parameters):
BaseBid._validator_functions["parameters"](self, data, parameters)
class BootDiagnostics(Model):
# belongs to the VmScaleSet >> VirtualMachineScaleSetVMProfile >> DiagnosticsProfile
enabled = BooleanType(serialize_when_none=False)
storage_uri = StringType(serialize_when_none=False)
class DiskEncryptionSettings(Model):
disk_encryption_key = ModelType(KeyVaultSecretReference,
serialize_when_none=False)
enabled = BooleanType(serialize_when_none=False)
key_encryption_key = ModelType(KeyVaultKeyReference,
serialize_when_none=False)
class WebserverConfiguration(Model):
address = StringType(default="0.0.0.0")
port = IntType(default=80)
default_index = StringType(required=False, default="main-stable")
support_legacy_uris = BooleanType(default=False, required=True)
class SecurityProfile(Model): # belongs to VmScaleSet
encryption_at_host = BooleanType(default=False, serialize_when_none=False)
class EmailNotification(Model):
custom_emails = ListType(StringType, serialize_when_none=False)
send_to_subscription_administrator = BooleanType(serialize_when_none=False)
send_to_subscription_co_administrators = BooleanType(
serialize_when_none=False)
class TerminateNotificationProfile(
Model): # belongs to VmScaleSet >> ScheduledEventsProfile
enable = BooleanType(serialize_when_none=False)
not_before_timeout = StringType(default='PT5M', serialize_when_none=False)
class AutomaticRepairsPolicy(Model): # belongs to VmScaleSet
enabled = BooleanType(default=False)
grace_period = StringType(serialize_when_none=False)
class LinuxConfiguration(
Model): # belongs to VmScaleSet >> VirtualMachineScaleSetOSProfile
disable_password_authentication = BooleanType(serialize_when_none=False)
provision_vm_agent = BooleanType(serialize_when_none=False, default=True)
ssh = ModelType(SshConfiguration, serialize_when_none=False)
class GridDTO(Model):
""" Describes JSON model used for creating grids """
area_of_interest = BaseType(required=True,
serialized_name='areaOfInterest')
grid = BaseType(required=True)
clip_to_aoi = BooleanType(required=True, serialized_name='clipToAoi')
class VirtualMachineScaleSetVMProtectionPolicy(Model):
protect_from_scale_in = BooleanType(default=False)
protect_from_scale_set_actions = BooleanType(default=False)
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,
"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"]
procuring_entity_kinds = ["general", "special", "defense", "central"]
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"),
])
self._acl_cancellation_complaint(acl)
return acl
@serializable(serialized_name="enquiryPeriod",
type=ModelType(EnquiryPeriod))
def tender_enquiryPeriod(self):
endDate = calculate_tender_business_date(self.tenderPeriod.endDate,
-QUESTIONS_STAND_STILL, 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(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)
pending_cancellations = [
i for i in self.cancellations
if i.status == "pending" and i.complaintPeriod
]
for cancellation in pending_cancellations:
checks.append(cancellation.complaintPeriod.endDate.astimezone(TZ))
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 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, 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 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 (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"
# Not required milestones
def validate_milestones(self, data, value):
pass
class NetworkInterfaceReference(Model):
id = StringType(serialize_when_none=False)
primary = BooleanType(serialize_when_none=False)
class Configuration(Model, PropertyMixin):
filepath = StringType(required=True)
webserver = ModelType(WebserverConfiguration, required=True, default=WebserverConfiguration)
rpcserver = ModelType(RPCServerConfiguration, required=True, default=RPCServerConfiguration)
ftpserver = ModelType(FtpServerConfiguration, required=True, default=FtpServerConfiguration)
remote_servers = ListType(ModelType(RemoteConfiguration), required=True,
default=[RemoteConfiguration(dict(address="repo.infinidat.com"))])
base_directory = StringType(default=get_base_directory())
logging_level = IntType(default=logging.DEBUG)
development_mode = BooleanType(default=False)
production_mode = BooleanType(default=True)
indexes = ListType(StringType(), required=True, default=['main-stable', 'main-unstable'])
@classmethod
def get_default_config_file(cls):
return path.join(get_base_directory(), 'config.json')
def to_builtins(self):
from json import dumps
method = getattr(self, "to_python") if hasattr(self, "to_python") else getattr(self, "serialize")
return method()
def to_json(self):
from json import dumps
method = getattr(self, "to_python") if hasattr(self, "to_python") else getattr(self, "serialize")
return dumps(self.to_builtins(), indent=4)
def reload_configuration_from_disk(self):
with fopen(self.filepath) as fd:
kwargs = decode(fd.read())
kwargs['filepath'] = self.filepath
for key, value in kwargs.items():
setattr(self, key, value)
return self
@classmethod
def from_disk(cls, filepath):
filepath = filepath or cls.get_default_config_file()
if not path.exists(filepath):
self = cls()
self.filepath = filepath
else:
with fopen(filepath) as fd:
kwargs = decode(fd.read())
kwargs['filepath'] = filepath
self = cls()
for key, value in kwargs.items():
setattr(self, key, value)
assert self.webserver.default_index is None or self.webserver.default_index in self.indexes
return self
def to_disk(self):
if not path.exists(path.dirname(self.filepath)):
makedirs(path.dirname(self.filepath))
with fopen(self.filepath, 'w') as fd:
fd.write(self.to_json())
def _reset_configuration(self):
"""Private method to reset Configuration instance to default values"""
configuration_fields_to_reset = list(self.keys())
configuration_fields_to_reset.remove('filepath')
for field in configuration_fields_to_reset:
self._data[field] = Configuration()._data[field]
def reset_to_production_defaults(self):
self._reset_configuration()
self.to_disk()
def reset_to_development_defaults(self):
self._reset_configuration()
self.webserver.address, self.webserver.port = "127.0.0.1", 8000
self.rpcserver.address, self.rpcserver.port = "127.0.0.1", 8001
self.ftpserver.address, self.ftpserver.port = "127.0.0.1", 8002
self.production_mode = False
self.development_mode = True
self.to_disk()
def get_indexers(self, index_name):
from .indexers import get_indexers
return get_indexers(self, index_name)
class AdditionalCapabilities(Model): # belongs to VmScaleSet
ultra_ssd_enabled = BooleanType(serialize_when_none=False)
class Status(Model):
healthy = BooleanType()
languages = ListType(StringType())
mapping = ListType(StringType())
version = StringType()
class AutomaticOSUpgradePolicy(Model
): # belongs to VmScaleSet >> UpgradePolicy
disable_automatic_rollback = BooleanType(default=False,
serialize_when_none=False)
enable_automatic_os_upgrade = BooleanType(default=False)
