Esempio n. 1
0
class TrustedKeyGroups(Model):
    enabled = BooleanType(deserialize_from="Enabled")
    quantity = IntType(deserialize_from="Quantity", serialize_when_none=False)
    items = ListType(StringType,
                     deserialize_from="Items",
                     serialize_when_none=False)
class LockTaskDTO(Model):
    """ DTO used to lock a task for mapping """
    user_id = IntType(required=True)
    task_id = IntType(required=True)
    project_id = IntType(required=True)
    preferred_locale = StringType(default='en')
class ZMessage(Model):
    author_id = IntType(required=True)
    created_at = DateTimeType(formats='%Y-%m-%dT%H:%M:%SZ', required=True)
    uploads = ListType(StringType, default=list)  # list of upload tokens
    public = BooleanType(required=True)
class CampaignOrganisationDTO(Model):
    """ DTO used to define avaliable campaign connnected projects"""

    organisation_id = IntType()
    campaign_id = IntType()
Esempio n. 5
0
class PostSerializer(Model):
    id = IntType()
    title = StringType()
Esempio n. 6
0
class VenueResult(BetfairModel):
    venue = StringType()
    market_count = IntType()
Esempio n. 7
0
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_tender"),
            (Allow, "{}_{}".format(self.owner, self.owner_token),
             "upload_tender_documents"),
            (Allow, "{}_{}".format(self.owner,
                                   self.owner_token), "edit_complaint"),
            (Allow, "g:agreement_selection", "edit_agreement_selection"),
            (Allow, "g:agreement_selection", "edit_tender"),
        ])
        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
Esempio n. 8
0
class Alias(Model):
    quantity = IntType(deserialize_from="Quantity")
    Items = ListType(StringType,
                     deserialize_from="Items",
                     serialize_when_none=False)
Esempio n. 9
0
class Origins(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(ModelType(OriginsItems),
                     deserialize_from="Items",
                     serialize_when_none=False)
Esempio n. 10
0
class OriginSslProtocols(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(StringType,
                     deserialize_from="Items",
                     choices=('SSLv3', 'TLSv1', 'TLSv1.1', 'TLSv1.2'))
Esempio n. 11
0
class CustomErrorResponses(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(ModelType(CustomErrorResponsesItems),
                     deserialize_from="Items",
                     serialize_when_none=False)
Esempio n. 12
0
class CacheBehaviors(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(ModelType(CacheBehaviorsItems),
                     deserialize_from="Items",
                     serialize_when_none=False)
Esempio n. 13
0
class LambdaFunctionAssociations(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(ModelType(LambdaFunctionAssociationsItems),
                     deserialize_from="Items",
                     serialize_when_none=False)
Esempio n. 14
0
class CachedMethods(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(StringType,
                     deserialize_from="Items",
                     choices=('GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'OPTIONS',
                              'DELETE'))
Esempio n. 15
0
class MarketTypeResult(BetfairModel):
    market_type = StringType()
    market_count = IntType()
Esempio n. 16
0
class Tender(BaseTender):
    """ ESCO Tender model """
    class Options:
        roles = {
            'plain':
            plain_role,
            'create':
            create_role_eu +
            blacklist('minValue', 'tender_minValue', 'minimalStep',
                      'tender_minimalStep', 'noticePublicationDate',
                      'tender_noticePublicationDate'),
            'edit':
            edit_role_eu +
            blacklist('minValue', 'tender_minValue', 'minimalStep',
                      'tender_minimalStep', 'noticePublicationDate',
                      'tender_noticePublicationDate'),
            'edit_draft':
            edit_role_eu +
            blacklist('minValue', 'tender_minValue', 'minimalStep',
                      'tender_minimalStep', 'noticePublicationDate',
                      'tender_noticePublicationDate'),
            'edit_active.tendering':
            edit_role_eu +
            blacklist('minValue', 'tender_minValue', 'minimalStep',
                      'tender_minimalStep', 'noticePublicationDate',
                      'tender_noticePublicationDate'),
            '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',
                      'yearlyPaymentsPercentageRange', 'fundingKind',
                      'procurementMethodType', 'noticePublicationDate'),
            '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.
    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), 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 = DecimalType(required=True,
                                        min_value=Decimal('0.005'),
                                        max_value=Decimal('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 = 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'))
    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
    noticePublicationDate = IsoDateTimeType()

    create_accreditation = 3
    edit_accreditation = 4
    special_fields = ['fundingKind', 'yearlyPaymentsPercentageRange']
    procuring_entity_kinds = ['general', 'special', 'defense']
    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_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

    @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.__parent__.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

    #     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 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_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"
Esempio n. 17
0
class TimeRangeResult(BetfairModel):

    time_range = ModelType(TimeRange)
    market_count = IntType()
Esempio n. 18
0
class RunnerProfitAndLoss(BetfairModel):
    selection_id = IntType()
    if_win = FloatType()
    if_lose = FloatType()
Esempio n. 19
0
class RunnerCatalog(BetfairModel):
    selection_id = IntType(required=True)
    runner_name = StringType(required=True)
    handicap = FloatType(required=True)
    sort_priority = IntType(required=True)
    metadata = DictType(StringType)
Esempio n. 20
0
class ExBestOffersOverrides(BetfairModel):
    best_prices_depth = IntType()
    rollup_model = EnumType(constants.RollupModel)
    rollup_limit = IntType()
    rollup_liability_threshold = FloatType()
    rollup_liability_factor = IntType()
Esempio n. 21
0
class CampaignProjectDTO(Model):
    """ DTO used to define avaliable campaign connnected projects"""

    project_id = IntType()
    campaign_id = IntType()
Esempio n. 22
0
class CompetitionResult(BetfairModel):

    competition = ModelType(Competition)
    market_count = IntType()
    competition_region = StringType()
Esempio n. 23
0
class PersonSerializer(Model):
    id = IntType()
    name = StringType()
Esempio n. 24
0
class CountryCodeResult(BetfairModel):
    country_code = StringType()
    market_count = IntType()
Esempio n. 25
0
def player_schema():
    schema = Schema('Player', Field('id', IntType()),
                    Field('first_name', StringType(required=True)),
                    Field('last_name', StringType(required=True)))
    return schema
Esempio n. 26
0
class EventResult(BetfairModel):

    event = ModelType(Event)
    market_count = IntType()
Esempio n. 27
0
class Connection(Model):
    host = StringType(
        default="",
        required=True,
    )
    port = IntType(
        min_value=1000,
        max_value=65000,
        default=None,
        required=False,
    )
    allowed_hosts = ListType(
        field=StringType,
        min_size=0,
        required=True,
        min_length=1,
    )

    @classmethod
    def from_ini(cls, ini):
        port = field_from_ini(
            cls.port,
            ini,
            'DeviceLink',
            'port',
        )
        port = (None if port == FORBID_DEVICE_LINK_CONNECTIONS_FLAG else port)

        return cls({
            'host':
            field_from_ini(
                cls.host,
                ini,
                'DeviceLink',
                'host',
            ),
            'port':
            port,
            'allowed_hosts': (field_from_ini(
                cls.allowed_hosts,
                ini,
                'DeviceLink',
                'IPS',
                default="",
            ).split()),
        })

    def to_ini(self, ini):
        port = (FORBID_DEVICE_LINK_CONNECTIONS_FLAG
                if self.port is None else self.port)
        allowed_hosts = ' '.join(self.allowed_hosts)

        field_to_ini(port, ini, 'DeviceLink', 'port')
        field_to_ini(self.host, ini, 'DeviceLink', 'host')
        field_to_ini(allowed_hosts, ini, 'DeviceLink', 'IPS')

    @classmethod
    def default(cls):
        return cls({
            'host': cls.host.default,
            'port': cls.port.default,
            'allowed_hosts': [],
        })
Esempio n. 28
0
class EventTypeResult(BetfairModel):

    event_type = ModelType(EventType)
    market_count = IntType()
class ZTicketUpdate(Model):
    id = IntType(required=True)
    # API for updating requires single comment
    comment = ModelType(ZMessageUpdate, required=True)
Esempio n. 30
0
class QueryStringCacheKeys(Model):
    quantity = IntType(deserialize_from="Quantity")
    items = ListType(StringType,
                     deserialize_from="Items",
                     serialize_when_none=False)