Esempio n. 1
0
 def collection_post(self):
     """Tender Bid Document Upload
     """
     tender = self.request.validated['tender']
     if tender.status not in [
             'active.tendering', 'active.auction', 'active.qualification'
     ]:
         self.request.errors.add(
             'body', 'data', 'Can\'t add document in current tender status')
         self.request.errors.status = 403
         return
     src = tender.serialize("plain")
     data = self.request.validated['file']
     document = Document()
     document.id = generate_id()
     document.title = data.filename
     document.format = data.type
     key = generate_id()
     document.url = self.request.route_url(
         'Tender Bid Documents',
         tender_id=tender.id,
         bid_id=self.request.validated['bid_id'],
         id=document.id,
         _query={'download': key})
     self.request.validated['bid'].documents.append(document)
     upload_file(tender, document, key, data.file, self.request)
     save_tender(tender, src, self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url(
         'Tender Bid Documents',
         tender_id=tender.id,
         bid_id=self.request.validated['bid_id'],
         id=document.id)
     return {'data': document.serialize("view")}
Esempio n. 2
0
def set_ownership(item):
    item.owner_token = generate_id()
    access = {"token": item.owner_token}
    if isinstance(getattr(type(item), "transfer_token", None), StringType):
        transfer = generate_id()
        item.transfer_token = sha512(transfer).hexdigest()
        access["transfer"] = transfer
    return access
Esempio n. 3
0
    def collection_post(self):
        transfer_id = generate_id()
        transfer = self.request.validated["transfer"]
        transfer.id = transfer_id

        access_token = transfer.access_token
        transfer_token = transfer.transfer_token
        set_ownership(transfer,
                      self.request,
                      access_token=access_token,
                      transfer_token=transfer_token)

        self.request.validated["transfer"] = transfer
        if save_transfer(self.request):
            self.LOGGER.info(
                "Created transfer {}".format(transfer.id),
                extra=context_unpack(self.request,
                                     {"MESSAGE_ID": "transfer_create"},
                                     {"transfer_id": transfer.id}),
            )
            self.request.response.status = 201
            return {
                "data": transfer.serialize("view"),
                "access": {
                    "token": access_token,
                    "transfer": transfer_token
                }
            }
 def post(self):
     """
     Creating new submission
     """
     submission_id = generate_id()
     submission = self.request.validated["submission"]
     submission.id = submission_id
     framework = self.request.validated["framework"]
     submission.submissionType = framework["frameworkType"]
     submission.mode = framework.get("mode")
     if self.request.json["data"].get("status") == "draft":
         submission.status = "draft"
     access = set_ownership(submission, self.request)
     self.request.validated["submission"] = submission
     self.request.validated["submission_src"] = {}
     if save_submission(self.request):
         self.LOGGER.info(
             "Created submission {}".format(submission_id),
             extra=context_unpack(
                 self.request,
                 {"MESSAGE_ID": "submission_create"},
                 {
                     "submission_id": submission_id,
                     "submission_mode": submission.mode
                 },
             ),
         )
         self.request.response.status = 201
         self.request.response.headers["Location"] = self.request.route_url(
             "{}:Submission".format(submission.submissionType),
             submission_id=submission_id)
         return {"data": submission.serialize("view"), "access": access}
 def put(self):
     """Tender Document Update"""
     tender = self.request.validated['tender']
     first_document = self.request.validated['documents'][0]
     if tender.status != 'active.enquiries':
         self.request.errors.add('body', 'data', 'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     if self.request.content_type == 'multipart/form-data':
         data = self.request.validated['file']
         filename = data.filename
         content_type = data.type
         in_file = data.file
     else:
         filename = first_document.title
         content_type = self.request.content_type
         in_file = self.request.body_file
     document = Document()
     document.id = self.request.validated['id']
     document.title = filename
     document.format = content_type
     document.datePublished = first_document.datePublished
     key = generate_id()
     document.url = self.request.route_url('Tender Documents', tender_id=tender.id, id=document.id, _query={'download': key})
     src = tender.serialize("plain")
     tender.documents.append(document)
     upload_file(tender, document, key, in_file, self.request)
     save_tender(tender, src, self.request)
     return {'data': document.serialize("view")}
    def create_qualification(self):
        submission = self.request.context
        framework = self.request.validated["framework"]

        qualification_id = generate_id()
        qualification_data = {
            "id": qualification_id,
            "frameworkID": framework["_id"],
            "submissionID": submission.id,
            "framework_owner": framework["owner"],
            "framework_token": framework["owner_token"],
            "qualificationType": framework["frameworkType"],
            "mode": framework.get("type")
        }
        qualification = Qualification(qualification_data)
        self.request.validated["qualification_src"] = {}
        self.request.validated["qualification"] = qualification

        if save_qualification(self.request):
            submission.qualificationID = qualification_id
            self.LOGGER.info(
                "Created qualification {}".format(qualification_id),
                extra=context_unpack(
                    self.request,
                    {"MESSAGE_ID": "qualification_create"},
                    {"qualification_id": qualification_id,
                     "qualification_mode": qualification.mode},
                ),
            )
Esempio n. 7
0
    def post(self):
        """This API request is targeted to creating new Lot."""
        lot_id = generate_id()
        lot = self.request.validated['lot']
        lot.id = lot_id
        if not lot.get('lotID'):
            lot.lotID = generate_lot_id(get_now(), self.db, self.server_id)
        self.request.registry.notify(LotInitializeEvent(lot))

        default_status = type(lot).fields['status'].default
        status = self.request.json_body['data'].get('status', default_status)
        if status == 'draft':
            lot.status = status
        else:
            self.request.errors.add('body', 'status',
                                    'You can create only in draft status')
            self.request.errors.status = 403
            return

        acc = set_ownership(lot, self.request)
        self.request.validated['lot'] = lot
        self.request.validated['lot_src'] = {}
        if save_lot(self.request):
            self.LOGGER.info('Created lot {} ({})'.format(lot_id, lot.lotID),
                             extra=context_unpack(self.request,
                                                  {'MESSAGE_ID': 'lot_create'},
                                                  {
                                                      'lot_id': lot_id,
                                                      'lotID': lot.lotID
                                                  }))
            self.request.response.status = 201
            self.request.response.headers['Location'] = self.request.route_url(
                '{}:Lot'.format(lot.lotType), lot_id=lot_id)
            return {'data': lot.serialize(lot.status), 'access': acc}
Esempio n. 8
0
    def create_agreement_contract(self):
        db = self.request.registry.db
        qualification = self.request.validated["qualification"]
        framework = self.request.validated["framework"]
        agreement_data = get_agreement_by_id(db, framework.agreementID)
        submission_data = get_submission_by_id(db, qualification.submissionID)
        if agreement_data["status"] != "active":
            return

        contract_id = generate_id()
        first_milestone_data = {
            "type": "activation",
            "documents": qualification.documents
        }
        contract_data = {
            "id": contract_id,
            "qualificationID": qualification.id,
            "status": "active",
            "suppliers": submission_data["tenderers"],
            "milestones": [first_milestone_data],
        }
        new_contracts = deepcopy(agreement_data.get("contracts", []))
        new_contracts.append(contract_data)

        apply_patch(self.request,
                    data={"contracts": new_contracts},
                    src=agreement_data,
                    obj_name="agreement")
        self.LOGGER.info(
            "Updated agreement {} with contract {}".format(
                agreement_data["_id"], contract_id),
            extra=context_unpack(self.request,
                                 {"MESSAGE_ID": "qualification_patch"}))
Esempio n. 9
0
    def post(self):
        """This API request is targeted to creating new Asset."""
        self.request.registry.getAdapter(self.request.validated['asset'],
                                         IAssetManager).create_asset(
                                             self.request)

        asset_id = generate_id()
        asset = self.request.validated['asset']
        asset.id = asset_id
        if not asset.get('assetID'):
            asset.assetID = generate_asset_id(get_now(), self.db,
                                              self.server_id)
        self.request.registry.notify(AssetInitializeEvent(asset))
        if self.request.json_body['data'].get('status') == 'draft':
            asset.status = 'draft'
        acc = set_ownership(asset, self.request)
        self.request.validated['asset'] = asset
        self.request.validated['asset_src'] = {}
        if save_asset(self.request):
            self.LOGGER.info(
                'Created asset {} ({})'.format(asset_id, asset.assetID),
                extra=context_unpack(self.request,
                                     {'MESSAGE_ID': 'asset_create'}, {
                                         'asset_id': asset_id,
                                         'assetID': asset.assetID
                                     }))
            self.request.response.status = 201
            self.request.response.headers['Location'] = self.request.route_url(
                'Asset', asset_id=asset_id)
            return {'data': asset.serialize(asset.status), 'access': acc}
 def put(self):
     """Tender Complaint Document Update"""
     tender = self.request.validated['tender']
     if tender.status not in ['active.enquiries', 'active.tendering', 'active.auction', 'active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     first_document = self.request.validated['documents'][0]
     src = tender.serialize("plain")
     if self.request.content_type == 'multipart/form-data':
         data = self.request.validated['file']
         filename = data.filename
         content_type = data.type
         in_file = data.file
     else:
         filename = first_document.title
         content_type = self.request.content_type
         in_file = self.request.body_file
     document = Document()
     document.id = self.request.matchdict['id']
     document.title = filename
     document.format = content_type
     document.datePublished = first_document.datePublished
     key = generate_id()
     document.url = self.request.route_url('Tender Complaint Documents', tender_id=tender.id, complaint_id=self.request.validated['complaint_id'], id=document.id, _query={'download': key})
     self.request.validated['complaint'].documents.append(document)
     upload_file(tender, document, key, in_file, self.request)
     save_tender(tender, src, self.request)
     return {'data': document.serialize("view")}
def upload_file(request, blacklisted_fields=DOCUMENT_BLACKLISTED_FIELDS):
    first_document = (
        request.validated["documents"][0]
        if "documents" in request.validated and request.validated["documents"]
        else None
    )
    if request.content_type == "multipart/form-data":
        data = request.validated["file"]
        filename = get_filename(data)
        content_type = data.type
        in_file = data.file
    else:
        filename = first_document.title
        content_type = request.content_type
        in_file = request.body_file

    if hasattr(request.context, "documents"):
        # upload new document
        model = type(request.context).documents.model_class
    else:
        # update document
        model = type(request.context)
    document = model({"title": filename, "format": content_type})
    document.__parent__ = request.context
    if "document_id" in request.validated:
        document.id = request.validated["document_id"]
    if first_document:
        for attr_name in type(first_document)._fields:
            if attr_name not in blacklisted_fields:
                setattr(document, attr_name, getattr(first_document, attr_name))
    key = generate_id()
    document_route = request.matched_route.name.replace("collection_", "")
    document_path = request.current_route_path(
        _route_name=document_route, document_id=document.id, _query={"download": key}
    )
    document.url = "/" + "/".join(document_path.split("/")[3:])
    conn = getattr(request.registry, "s3_connection", None)
    if conn:
        bucket = conn.get_bucket(request.registry.bucket_name)
        filename = "{}/{}/{}".format(request.validated["plan_id"], document.id, key)
        key = bucket.new_key(filename)
        key.set_metadata("Content-Type", document.format)
        key.set_metadata(
            "Content-Disposition", build_header(document.title, filename_compat=quote(document.title.encode("utf-8")))
        )
        key.set_contents_from_file(in_file)
        key.set_acl("private")
    else:
        filename = "{}_{}".format(document.id, key)
        request.validated["plan"]["_attachments"][filename] = {
            "content_type": document.format,
            "data": b64encode(in_file.read()),
        }
    update_logging_context(request, {"file_size": in_file.tell()})
    return document
 def collection_post(self):
     """Tender Document Upload"""
     tender = self.request.validated['tender']
     if tender.status != 'active.enquiries':
         self.request.errors.add('body', 'data', 'Can\'t add document in current tender status')
         self.request.errors.status = 403
         return
     src = tender.serialize("plain")
     data = self.request.validated['file']
     document = Document()
     document.id = generate_id()
     document.title = data.filename
     document.format = data.type
     key = generate_id()
     document.url = self.request.route_url('Tender Documents', tender_id=tender.id, id=document.id, _query={'download': key})
     tender.documents.append(document)
     upload_file(tender, document, key, data.file, self.request)
     save_tender(tender, src, self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url('Tender Documents', tender_id=tender.id, id=document.id)
     return {'data': document.serialize("view")}
 def post(self):
     inspection = self.request.validated['inspection']
     inspection.id = generate_id()
     inspection.inspection_id = generate_inspection_id(get_now(), self.db, self.server_id)
     set_author(inspection.documents, self.request, 'author')
     save_inspection(self.request, date_modified=inspection.dateCreated)
     LOGGER.info('Created inspection {}'.format(inspection.id),
                 extra=context_unpack(self.request,
                                      {'MESSAGE_ID': 'inspection_create'},
                                      {'MONITORING_ID': inspection.id}))
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url(
         'Inspection', inspection_id=inspection.id)
     return {'data': inspection.serialize('view')}
def upload_file(request, blacklisted_fields=DOCUMENT_BLACKLISTED_FIELDS):
    first_document = request.validated['documents'][0] if 'documents' in request.validated and request.validated['documents'] else None
    if request.content_type == 'multipart/form-data':
        data = request.validated['file']
        filename = get_filename(data)
        content_type = data.type
        in_file = data.file
    else:
        filename = first_document.title
        content_type = request.content_type
        in_file = request.body_file

    if hasattr(request.context, "documents"):
        # upload new document
        model = type(request.context).documents.model_class
    else:
        # update document
        model = type(request.context)
    document = model({'title': filename, 'format': content_type})
    document.__parent__ = request.context
    if 'document_id' in request.validated:
        document.id = request.validated['document_id']
    if first_document:
        for attr_name in type(first_document)._fields:
            if attr_name not in blacklisted_fields:
                setattr(document, attr_name, getattr(first_document, attr_name))
    key = generate_id()
    document_route = request.matched_route.name.replace("collection_", "")
    document_path = request.current_route_path(_route_name=document_route, document_id=document.id, _query={'download': key})
    document.url = '/' + '/'.join(document_path.split('/')[3:])
    conn = getattr(request.registry, 's3_connection', None)
    if conn:
        bucket = conn.get_bucket(request.registry.bucket_name)
        filename = "{}/{}/{}".format(request.validated['contract_id'],
                                     document.id, key)
        key = bucket.new_key(filename)
        key.set_metadata('Content-Type', document.format)
        key.set_metadata("Content-Disposition", build_header(document.title, filename_compat=quote(document.title.encode('utf-8'))))
        key.set_contents_from_file(in_file)
        key.set_acl('private')
    else:
        filename = "{}_{}".format(document.id, key)
        request.validated['contract']['_attachments'][filename] = {
            "content_type": document.format,
            "data": b64encode(in_file.read())
        }
    update_logging_context(request, {'file_size': in_file.tell()})
    return document
Esempio n. 15
0
def upload_file(request, blacklisted_fields=DOCUMENT_BLACKLISTED_FIELDS):
    first_document = request.validated['documents'][0] if 'documents' in request.validated and request.validated['documents'] else None
    if request.content_type == 'multipart/form-data':
        data = request.validated['file']
        filename = get_filename(data)
        content_type = data.type
        in_file = data.file
    else:
        filename = first_document.title
        content_type = request.content_type
        in_file = request.body_file

    if hasattr(request.context, "documents"):
        # upload new document
        model = type(request.context).documents.model_class
    else:
        # update document
        model = type(request.context)
    document = model({'title': filename, 'format': content_type})
    document.__parent__ = request.context
    if 'document_id' in request.validated:
        document.id = request.validated['document_id']
    if first_document:
        for attr_name in type(first_document)._fields:
            if attr_name not in blacklisted_fields:
                setattr(document, attr_name, getattr(first_document, attr_name))
    key = generate_id()
    document_route = request.matched_route.name.replace("collection_", "")
    document_path = request.current_route_path(_route_name=document_route, document_id=document.id, _query={'download': key})
    document.url = '/' + '/'.join(document_path.split('/')[3:])
    conn = getattr(request.registry, 's3_connection', None)
    if conn:
        bucket = conn.get_bucket(request.registry.bucket_name)
        filename = "{}/{}/{}".format(request.validated['auction_id'], document.id, key)
        key = bucket.new_key(filename)
        key.set_metadata('Content-Type', document.format)
        key.set_metadata("Content-Disposition", build_header(document.title, filename_compat=quote(document.title.encode('utf-8'))))
        key.set_contents_from_file(in_file)
        key.set_acl('private')
    else:
        filename = "{}_{}".format(document.id, key)
        request.validated['auction']['_attachments'][filename] = {
            "content_type": document.format,
            "data": b64encode(in_file.read())
        }
    update_logging_context(request, {'file_size': in_file.tell()})
    return document
Esempio n. 16
0
    def create_agreement_contract(self):
        qualification = self.request.validated["qualification"]
        framework = self.request.validated["framework"]
        agreement_data = get_agreement_by_id(self.request,
                                             framework.agreementID)
        if not agreement_data:
            raise_operation_error(
                self.request,
                "agreementID must be one of exists agreement",
            )
        submission_data = get_submission_by_id(self.request,
                                               qualification.submissionID)
        if not agreement_data:
            raise_operation_error(
                self.request,
                "submissionID must be one of exists submission",
            )
        if agreement_data["status"] != "active":
            return

        contract_id = generate_id()
        first_milestone_data = {
            "type": "activation",
            "dueDate": framework.get("qualificationPeriod").get("endDate")
        }
        contract_data = {
            "id": contract_id,
            "qualificationID": qualification.id,
            "submissionID": submission_data["_id"],
            "status": "active",
            "suppliers": submission_data["tenderers"],
            "milestones": [first_milestone_data],
        }
        new_contracts = deepcopy(agreement_data.get("contracts", []))
        new_contracts.append(contract_data)

        apply_patch(self.request,
                    data={"contracts": new_contracts},
                    src=agreement_data,
                    obj_name="agreement")
        self.LOGGER.info(
            "Updated agreement {} with contract {}".format(
                agreement_data["_id"], contract_id),
            extra=context_unpack(self.request,
                                 {"MESSAGE_ID": "qualification_patch"}))
Esempio n. 17
0
    def post(self):
        agreement = self.request.validated["agreement"]
        if not agreement.id:
            agreement_id = generate_id()
            agreement.id = agreement_id
        if not agreement.get("agreementID"):
            agreement.prettyID = generate_agreementID(get_now(), self.db,
                                                      self.server_id)

        # Unify when cfa moved from tenders to frameworks
        framework = self.request.validated.get("framework")
        if framework:
            agreement.submissionType = framework["frameworkType"]
            agreement.mode = framework.get("mode")
            upload_objects_documents(
                self.request,
                agreement,
                route_kwargs={"agreement_id": agreement.id},
                route_prefix=framework["frameworkType"])

        access = set_ownership(agreement, self.request)
        self.request.validated["agreement"] = agreement
        self.request.validated["agreement_src"] = {}
        if save_agreement(self.request):
            self.LOGGER.info(
                "Created agreement {} ({})".format(agreement.id,
                                                   agreement.agreementID),
                extra=context_unpack(
                    self.request,
                    {"MESSAGE_ID": "agreement_create"},
                    {
                        "agreement_id": agreement.id,
                        "agreementID": agreement.agreementID
                    },
                ),
            )
            self.request.response.status = 201
            self.request.response.headers["Location"] = self.request.route_url(
                "{}.Agreement".format(agreement.agreementType),
                agreement_id=agreement.id)
            return {"data": agreement.serialize("view"), "access": access}
Esempio n. 18
0
    def post(self):
        """This API request is targeted to creating new Auctions by procuring organizations.
        """
        auction = self.request.validated['auction']

        if auction['_internal_type'] == 'geb':
            manager = self.request.registry.queryMultiAdapter(
                (self.request, auction), IManager)
            applicant = self.request.validated['auction']
            auction = manager.create(applicant)
            if not auction:
                return
        else:
            self.request.registry.getAdapter(
                auction, IAuctionManager).create_auction(self.request)
            auction_id = generate_id()
            auction.id = auction_id
            auction.auctionID = generate_auction_id(get_now(), self.db,
                                                    self.server_id)
            if hasattr(auction, "initialize"):
                auction.initialize()
            status = self.request.json_body['data'].get('status')
            if status and status in ['draft', 'pending.verification']:
                auction.status = status
        acc = set_ownership(auction, self.request)
        self.request.validated['auction'] = auction
        self.request.validated['auction_src'] = {}
        if save_auction(self.request):
            self.LOGGER.info(
                'Created auction {} ({})'.format(auction['id'],
                                                 auction.auctionID),
                extra=context_unpack(self.request,
                                     {'MESSAGE_ID': 'auction_create'}, {
                                         'auction_id': auction['id'],
                                         'auctionID': auction.auctionID
                                     }))
            self.request.response.status = 201
            auction_route_name = get_auction_route_name(self.request, auction)
            self.request.response.headers['Location'] = self.request.route_url(
                route_name=auction_route_name, auction_id=auction['id'])
            return {'data': auction.serialize(auction.status), 'access': acc}
    def post(self):
        monitor = self.request.validated['monitor']
        monitor.id = generate_id()

        set_ownership(monitor, self.request)
        self.request.validated['monitor'] = monitor
        self.request.validated['monitor_src'] = {}
        if save_monitor(self.request):
            LOGGER.info('Created monitor {}'.format(monitor.id),
                        extra=context_unpack(self.request,
                                             {'MESSAGE_ID': 'monitor_create'},
                                             {'monitor_id': monitor.id}))
            self.request.response.status = 201
            self.request.response.headers['Location'] = self.request.route_url(
                'Monitor', monitor_id=monitor.id)
            return {
                'data': monitor.serialize("view"),
                'access': {
                    'token': monitor.owner_token
                }
            }
Esempio n. 20
0
    def ensure_agreement(self):
        framework_data = self.request.validated["framework_src"]
        agreementID = framework_data.get("agreementID")
        if agreementID:
            agreement = get_agreement_by_id(self.request, agreementID)
            if not agreement:
                raise_operation_error(
                    self.request,
                    "agreementID must be one of exists agreement",
                )
            self.request.validated["agreement"] = agreement = Agreement(
                agreement)
            agreement.__parent__ = self.request.validated[
                "qualification"].__parent__
            self.request.validated["agreement_src"] = agreement.serialize(
                "plain")
        else:
            agreement_id = generate_id()
            now = get_now()
            transfer = generate_id()
            transfer_token = sha512(transfer.encode("utf-8")).hexdigest()
            agreement_data = {
                "id":
                agreement_id,
                "agreementID":
                generate_agreementID(
                    get_now(), self.request.registry.databases.agreements,
                    self.server_id),
                "frameworkID":
                framework_data["id"],
                "agreementType":
                framework_data["frameworkType"],
                "status":
                "active",
                "period": {
                    "startDate":
                    now,
                    "endDate":
                    framework_data.get("qualificationPeriod").get("endDate")
                },
                "procuringEntity":
                framework_data.get("procuringEntity"),
                "classification":
                framework_data.get("classification"),
                "additionalClassifications":
                framework_data.get("additionalClassifications"),
                "contracts": [],
                "owner":
                framework_data["owner"],
                "owner_token":
                framework_data["owner_token"],
                "mode":
                framework_data.get("mode"),
                "dateModified":
                now,
                "date":
                now,
                "transfer_token":
                transfer_token,
                "frameworkDetails":
                framework_data.get("frameworkDetails"),
            }
            agreement = Agreement(agreement_data)

            self.request.validated["agreement_src"] = {}
            self.request.validated["agreement"] = agreement
            if save_agreement(self.request):
                self.LOGGER.info(
                    "Created agreement {}".format(agreement_id),
                    extra=context_unpack(
                        self.request,
                        {"MESSAGE_ID": "agreement_create"},
                        {
                            "agreement_id": agreement_id,
                            "agreement_mode": agreement.mode
                        },
                    ),
                )

                framework_data_updated = {"agreementID": agreement_id}
                apply_patch(self.request,
                            data=framework_data_updated,
                            src=self.request.validated["framework_src"],
                            obj_name="framework")
                self.LOGGER.info(
                    "Updated framework {} with agreementID".format(
                        framework_data["id"]),
                    extra=context_unpack(
                        self.request, {"MESSAGE_ID": "qualification_patch"}))
def set_ownership(item):
    item.owner_token = generate_id()
Esempio n. 22
0
File: plan.py Progetto: lttga/op2
    def post(self):
        """This API request is targeted to creating new Plan by procuring organizations.

        Creating new Plan

        -------------------

        Example request to create plan:

        .. sourcecode:: http

            POST /plans HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "name": "proj_name",
                            "id": "proj_id"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.10/plans/84582807b5654bee9e216adb05e57d39
            Content-Type: application/json

            {
                "access": {
                    "token": "e4c75de4320649a4bbbdfa180e7a9ef2"
                },
                "data": {
                    "items": [
                        {
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні"
                                },
                                {
                                    "scheme": "КЕКВ",
                                    "id": "123",
                                    "description": "-"
                                }
                            ],
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "id": "8cd4abfd0bbb489a83a81dec1393ab8d",
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "quantity": 760
                        }
                    ],
                    "planID": "UA-2015-11-26-000001",
                    "budget": {
                        "amountNet": 12222,
                        "description": "budget_description",
                        "project": {
                            "id": "proj_id",
                            "name": "proj_name"
                        },
                        "currency": "UAH",
                        "amount": 10000,
                        "id": "budget_id"
                    },
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "tender": {
                        "procurementMethod": "open",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "id": "ac658c4ff7ab47dea27e32d15a655ddb"
                }
}
        """
        plan_id = generate_id()
        plan = self.request.validated["plan"]
        plan.id = plan_id

        plan.planID = generate_plan_id(get_now(), self.db, self.server_id)
        access = set_ownership(plan, self.request)
        self.request.validated["plan"] = plan
        self.request.validated["plan_src"] = {}
        if save_plan(self.request):
            LOGGER.info(
                "Created plan {} ({})".format(plan_id, plan.planID),
                extra=context_unpack(self.request,
                                     {"MESSAGE_ID": "plan_create"}, {
                                         "plan_id": plan_id,
                                         "planID": plan.planID
                                     }),
            )
            self.request.response.status = 201
            self.request.response.headers["Location"] = self.request.route_url(
                "Plan", plan_id=plan_id)
            return {"data": plan.serialize("view"), "access": access}
Esempio n. 23
0
    def collection_post(self):
        """This API request is targeted to creating new Plan by procuring organizations.

        Creating new Plan

        -------------------

        Example request to create plan:

        .. sourcecode:: http

            POST /plans HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "name": "proj_name",
                            "id": "proj_id"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.10/plans/84582807b5654bee9e216adb05e57d39
            Content-Type: application/json

            {
                "access": {
                    "token": "174fd98e4e7347eb863f125c9e561b27"
                },
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "id": "84582807b5654bee9e216adb05e57d39",
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "id": "proj_id",
                            "name": "proj_name"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }
        """
        plan_data = self.request.validated['data']
        plan_id = generate_id()
        plan = Plan(plan_data)
        plan.__parent__ = self.request.context
        plan.id = plan_id

        plan.planID = generate_plan_id(get_now(), self.db_plan, self.server_id)
        set_ownership(plan, self.request)
        self.request.validated['plan'] = plan
        self.request.validated['plan_src'] = {}
        if save_plan(self.request):
            LOGGER.info('Created plan {} ({})'.format(plan_id, plan.planID),
                        extra=context_unpack(self.request,
                                             {'MESSAGE_ID': 'plan_create'}, {
                                                 'plan_id': plan_id,
                                                 'planID': plan.planID
                                             }))
            self.request.response.status = 201
            self.request.response.headers['Location'] = self.request.route_url(
                'Plan', plan_id=plan_id)
            return {
                'data': plan.serialize('create'),
                'access': {
                    'token': plan.owner_token
                }
            }
def set_ownership(item):
    item.owner_token = generate_id()
def set_ownership(item, request):
    item.owner_token = generate_id()
Esempio n. 26
0
    def collection_post(self):
        """This API request is targeted to creating new Tenders by procuring organizations.

        Creating new Tender
        -------------------

        Example request to create tender:

        .. sourcecode:: http

            POST /tenders HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "procuringEntity": {
                        "id": {
                            "name": "Державне управління справами",
                            "scheme": "https://ns.openprocurement.org/ua/edrpou",
                            "uid": "00037256",
                            "uri": "http://www.dus.gov.ua/"
                        },
                        "address": {
                            "countryName": "Україна",
                            "postalCode": "01220",
                            "region": "м. Київ",
                            "locality": "м. Київ",
                            "streetAddress": "вул. Банкова, 11, корпус 1"
                        }
                    },
                    "value": {
                        "amount": 500,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    },
                    "itemsToBeProcured": [
                        {
                            "description": "футляри до державних нагород",
                            "primaryClassification": {
                                "scheme": "CPV",
                                "id": "44617100-9",
                                "description": "Cartons"
                            },
                            "additionalClassification": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "17.21.1",
                                    "description": "папір і картон гофровані, паперова й картонна тара"
                                }
                            ],
                            "unitOfMeasure": "item",
                            "quantity": 5
                        }
                    ],
                    "enquiryPeriod": {
                        "endDate": "2014-10-31T00:00:00"
                    },
                    "tenderPeriod": {
                        "startDate": "2014-11-03T00:00:00",
                        "endDate": "2014-11-06T10:00:00"
                    },
                    "awardPeriod": {
                        "endDate": "2014-11-13T00:00:00"
                    },
                    "deliveryDate": {
                        "endDate": "2014-11-20T00:00:00"
                    },
                    "minimalStep": {
                        "amount": 35,
                        "currency": "UAH"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.1/tenders/64e93250be76435397e8c992ed4214d1
            Content-Type: application/json

            {
                "data": {
                    "id": "64e93250be76435397e8c992ed4214d1",
                    "tenderID": "UA-64e93250be76435397e8c992ed4214d1",
                    "dateModified": "2014-10-27T08:06:58.158Z",
                    "procuringEntity": {
                        "id": {
                            "name": "Державне управління справами",
                            "scheme": "https://ns.openprocurement.org/ua/edrpou",
                            "uid": "00037256",
                            "uri": "http://www.dus.gov.ua/"
                        },
                        "address": {
                            "countryName": "Україна",
                            "postalCode": "01220",
                            "region": "м. Київ",
                            "locality": "м. Київ",
                            "streetAddress": "вул. Банкова, 11, корпус 1"
                        }
                    },
                    "value": {
                        "amount": 500,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    },
                    "itemsToBeProcured": [
                        {
                            "description": "футляри до державних нагород",
                            "primaryClassification": {
                                "scheme": "CPV",
                                "id": "44617100-9",
                                "description": "Cartons"
                            },
                            "additionalClassification": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "17.21.1",
                                    "description": "папір і картон гофровані, паперова й картонна тара"
                                }
                            ],
                            "unitOfMeasure": "item",
                            "quantity": 5
                        }
                    ],
                    "enquiryPeriod": {
                        "endDate": "2014-10-31T00:00:00"
                    },
                    "tenderPeriod": {
                        "startDate": "2014-11-03T00:00:00",
                        "endDate": "2014-11-06T10:00:00"
                    },
                    "awardPeriod": {
                        "endDate": "2014-11-13T00:00:00"
                    },
                    "deliveryDate": {
                        "endDate": "2014-11-20T00:00:00"
                    },
                    "minimalStep": {
                        "amount": 35,
                        "currency": "UAH"
                    }
                }
            }

        """
        tender_data = self.request.validated['data']
        tender_id = generate_id()
        tender = Tender(tender_data)
        tender.id = tender_id
        tender.enquiryPeriod.startDate = get_now()
        tender.tenderID = generate_tender_id(tender.enquiryPeriod.startDate, self.db)
        if not tender.tenderPeriod.startDate:
            tender.tenderPeriod.startDate = tender.enquiryPeriod.endDate
        set_ownership(tender, self.request)
        self.request.validated['tender'] = tender
        self.request.validated['tender_src'] = {}
        save_tender(self.request)
        self.request.response.status = 201
        self.request.response.headers[
            'Location'] = self.request.route_url('Tender', tender_id=tender_id)
        return {
            'data': tender.serialize(tender.status),
            'access': {
                'token': tender.owner_token
            }
        }
    def post(self):
        """This API request is targeted to creating new Plan by procuring organizations.

        Creating new Plan

        -------------------

        Example request to create plan:

        .. sourcecode:: http

            POST /plans HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "name": "proj_name",
                            "id": "proj_id"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.10/plans/84582807b5654bee9e216adb05e57d39
            Content-Type: application/json

            {
                "access": {
                    "token": "e4c75de4320649a4bbbdfa180e7a9ef2"
                },
                "data": {
                    "items": [
                        {
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні"
                                },
                                {
                                    "scheme": "КЕКВ",
                                    "id": "123",
                                    "description": "-"
                                }
                            ],
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "id": "8cd4abfd0bbb489a83a81dec1393ab8d",
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "quantity": 760
                        }
                    ],
                    "planID": "UA-2015-11-26-000001",
                    "budget": {
                        "amountNet": 12222,
                        "description": "budget_description",
                        "project": {
                            "id": "proj_id",
                            "name": "proj_name"
                        },
                        "currency": "UAH",
                        "amount": 10000,
                        "id": "budget_id"
                    },
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "tender": {
                        "procurementMethod": "open",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "id": "ac658c4ff7ab47dea27e32d15a655ddb"
                }
}
        """
        plan_id = generate_id()
        plan = self.request.validated["plan"]
        plan.id = plan_id

        plan.planID = generate_plan_id(get_now(), self.db, self.server_id)
        set_ownership(plan, self.request)
        self.request.validated["plan"] = plan
        self.request.validated["plan_src"] = {}
        if save_plan(self.request):
            LOGGER.info(
                "Created plan {} ({})".format(plan_id, plan.planID),
                extra=context_unpack(
                    self.request, {"MESSAGE_ID": "plan_create"}, {"plan_id": plan_id, "planID": plan.planID}
                ),
            )
            self.request.response.status = 201
            self.request.response.headers["Location"] = self.request.route_url("Plan", plan_id=plan_id)
            return {"data": plan.serialize("create"), "access": {"token": plan.owner_token}}
    def collection_post(self):
        """This API request is targeted to creating new Plan by procuring organizations.

        Creating new Plan

        -------------------

        Example request to create plan:

        .. sourcecode:: http

            POST /plans HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "name": "proj_name",
                            "id": "proj_id"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.10/plans/84582807b5654bee9e216adb05e57d39
            Content-Type: application/json

            {
                "access": {
                    "token": "174fd98e4e7347eb863f125c9e561b27"
                },
                "data": {
                    "tender": {
                        "procurementMethod": "допорогові закупівлі",
                        "tenderPeriod": {
                            "startDate": "2015-05-09T23:11:39.720908+03:00"
                        }
                    },
                    "items": [
                        {
                            "classification": {
                                "scheme": "CPV",
                                "description": "Роботи з будування пневматичних будівель",
                                "id": "45217000-1"
                            },
                            "additionalClassifications": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "28.29.39-10.00",
                                    "description": "Прилади контролювання маси та прилади контрольні автоматичні з максимальною масою зважування не більше ніж 5000 кг"
                                }
                            ],
                            "deliveryDate": {
                                "endDate": "2015-05-11T23:11:39.721063+03:00"
                            },
                            "id": "84582807b5654bee9e216adb05e57d39",
                            "unit": {
                                "code": "KGM",
                                "name": "кг"
                            },
                            "quantity": 760
                        }
                    ],
                    "procuringEntity": {
                        "identifier": {
                            "scheme": "UA-EDR",
                            "id": "111983",
                            "legalName": "ДП Державне Уравління Справами"
                        },
                        "name": "ДУС"
                    },
                    "budget": {
                        "project": {
                            "id": "proj_id",
                            "name": "proj_name"
                        },
                        "amount": 10000,
                        "amountNet": 12222,
                        "id": "budget_id",
                        "description": "budget_description"
                    }
                }
            }
        """
        plan_data = self.request.validated['data']
        plan_id = generate_id()
        plan = Plan(plan_data)
        plan.__parent__ = self.request.context
        plan.id = plan_id

        plan.planID = generate_plan_id(get_now(), self.db_plan, self.server_id)
        set_ownership(plan, self.request)
        self.request.validated['plan'] = plan
        self.request.validated['plan_src'] = {}
        if save_plan(self.request):
            LOGGER.info('Created plan {} ({})'.format(plan_id, plan.planID),
                        extra=context_unpack(self.request, {'MESSAGE_ID': 'plan_create'},
                                             {'plan_id': plan_id, 'planID': plan.planID}))
            self.request.response.status = 201
            self.request.response.headers[
                'Location'] = self.request.route_url('Plan', plan_id=plan_id)
            return {
                'data': plan.serialize('create'),
                'access': {
                    'token': plan.owner_token
                }
            }
Esempio n. 29
0
    def post(self):
        """This API request is targeted to creating new Frameworks by procuring organizations.

        Creating new Framework
        -------------------

        Example request to create framework:

        .. sourcecode:: http

            POST /frameworks HTTP/1.1
            Host: example.com
            Accept: application/json

            {
              "data": {
                "description": "Назва предмета закупівлі",
                "classification": {
                  "scheme": "ДК021",
                  "description": "Mustard seeds",
                  "id": "03111600-8"
                },
                "title": "Узагальнена назва закупівлі",
                "qualificationPeriod": {
                  "endDate": "2021-02-07T14:33:22.129267+02:00"
                },
                "additionalClassifications": [
                  {
                    "scheme": "ДК003",
                    "id": "17.21.1",
                    "description": "папір і картон гофровані, паперова й картонна тара"
                  }
                ],
                "procuringEntity": {
                  "contactPoint": {
                    "telephone": "0440000000",
                    "email": "*****@*****.**",
                    "name": "Назва організації(ЦЗО)"
                  },
                  "identifier": {
                    "scheme": "UA-EDR",
                    "id": "40996564",
                    "legalName": "Назва організації(ЦЗО)"
                  },
                  "kind": "central",
                  "name": "Повна назва юридичної організації.",
                  "address": {
                    "countryName": "Україна",
                    "postalCode": "01220",
                    "region": "м. Київ",
                    "streetAddress": "вул. Банкова, 11, корпус 1",
                    "locality": "м. Київ"
                  }
                }
              }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.1/frameworks/40b48e4878534db1bf228d5928f8f1d9
            Content-Type: application/json

            {
                "data": {
                    "status": "draft",
                    "description": "Назва предмета закупівлі",
                    "classification": {
                      "scheme": "ДК021",
                      "description": "Mustard seeds",
                      "id": "03111600-8"
                    },
                    "prettyID": "UA-F-2020-09-08-000001",
                    "qualificationPeriod": {
                      "endDate": "2021-02-07T14:33:22.129267+02:00"
                    },
                    "frameworkType": "electronicCatalogue",
                    "dateModified": "2020-09-08T01:00:00+03:00",
                    "date": "2020-09-08T01:00:00+03:00",
                    "additionalClassifications": [
                      {
                        "scheme": "ДК003",
                        "id": "17.21.1",
                        "description": "папір і картон гофровані, паперова й картонна тара"
                      }
                    ],
                    "procuringEntity": {
                      "contactPoint": {
                        "email": "*****@*****.**",
                        "telephone": "0440000000",
                        "name": "Назва організації(ЦЗО)"
                      },
                      "identifier": {
                        "scheme": "UA-EDR",
                        "id": "40996564",
                        "legalName": "Назва організації(ЦЗО)"
                      },
                      "name": "Повна назва юридичної організації.",
                      "kind": "central",
                      "address": {
                        "countryName": "Україна",
                        "postalCode": "01220",
                        "streetAddress": "вул. Банкова, 11, корпус 1",
                        "region": "м. Київ",
                        "locality": "м. Київ"
                      }
                    },
                    "owner": "broker",
                    "title": "Узагальнена назва закупівлі",
                    "id": "40b48e4878534db1bf228d5928f8f1d9"
                }
            }
        """
        framework_id = generate_id()
        framework = self.request.validated["framework"]
        framework.id = framework_id
        if not framework.get("prettyID"):
            framework.prettyID = generate_framework_pretty_id(
                get_now(), self.db, self.server_id)
        access = set_ownership(framework, self.request)
        self.request.validated["framework"] = framework
        self.request.validated["framework_src"] = {}
        if save_framework(self.request):
            self.LOGGER.info(
                "Created framework {} ({})".format(framework_id,
                                                   framework.prettyID),
                extra=context_unpack(
                    self.request,
                    {"MESSAGE_ID": "framework_create"},
                    {
                        "framework_id": framework_id,
                        "prettyID": framework.prettyID,
                        "framework_mode": framework.mode
                    },
                ),
            )
            self.request.response.status = 201
            self.request.response.headers["Location"] = self.request.route_url(
                "{}:Framework".format(framework.frameworkType),
                framework_id=framework_id)
            return {
                "data": framework.serialize(framework.status),
                "access": access
            }
Esempio n. 30
0
    def post(self):
        """This API request is targeted to creating new Tenders by procuring organizations.

        Creating new Tender
        -------------------

        Example request to create tender:

        .. sourcecode:: http

            POST /tenders HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "procuringEntity": {
                        "id": {
                            "name": "Державне управління справами",
                            "scheme": "https://ns.openprocurement.org/ua/edrpou",
                            "uid": "00037256",
                            "uri": "http://www.dus.gov.ua/"
                        },
                        "address": {
                            "countryName": "Україна",
                            "postalCode": "01220",
                            "region": "м. Київ",
                            "locality": "м. Київ",
                            "streetAddress": "вул. Банкова, 11, корпус 1"
                        }
                    },
                    "value": {
                        "amount": 500,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    },
                    "itemsToBeProcured": [
                        {
                            "description": "футляри до державних нагород",
                            "primaryClassification": {
                                "scheme": "CPV",
                                "id": "44617100-9",
                                "description": "Cartons"
                            },
                            "additionalClassification": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "17.21.1",
                                    "description": "папір і картон гофровані, паперова й картонна тара"
                                }
                            ],
                            "unitOfMeasure": "item",
                            "quantity": 5
                        }
                    ],
                    "enquiryPeriod": {
                        "endDate": "2014-10-31T00:00:00"
                    },
                    "tenderPeriod": {
                        "startDate": "2014-11-03T00:00:00",
                        "endDate": "2014-11-06T10:00:00"
                    },
                    "awardPeriod": {
                        "endDate": "2014-11-13T00:00:00"
                    },
                    "deliveryDate": {
                        "endDate": "2014-11-20T00:00:00"
                    },
                    "minimalStep": {
                        "amount": 35,
                        "currency": "UAH"
                    }
                }
            }

        This is what one should expect in response:

        .. sourcecode:: http

            HTTP/1.1 201 Created
            Location: http://localhost/api/0.1/tenders/64e93250be76435397e8c992ed4214d1
            Content-Type: application/json

            {
                "data": {
                    "id": "64e93250be76435397e8c992ed4214d1",
                    "tenderID": "UA-64e93250be76435397e8c992ed4214d1",
                    "dateModified": "2014-10-27T08:06:58.158Z",
                    "procuringEntity": {
                        "id": {
                            "name": "Державне управління справами",
                            "scheme": "https://ns.openprocurement.org/ua/edrpou",
                            "uid": "00037256",
                            "uri": "http://www.dus.gov.ua/"
                        },
                        "address": {
                            "countryName": "Україна",
                            "postalCode": "01220",
                            "region": "м. Київ",
                            "locality": "м. Київ",
                            "streetAddress": "вул. Банкова, 11, корпус 1"
                        }
                    },
                    "value": {
                        "amount": 500,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    },
                    "itemsToBeProcured": [
                        {
                            "description": "футляри до державних нагород",
                            "primaryClassification": {
                                "scheme": "CPV",
                                "id": "44617100-9",
                                "description": "Cartons"
                            },
                            "additionalClassification": [
                                {
                                    "scheme": "ДКПП",
                                    "id": "17.21.1",
                                    "description": "папір і картон гофровані, паперова й картонна тара"
                                }
                            ],
                            "unitOfMeasure": "item",
                            "quantity": 5
                        }
                    ],
                    "enquiryPeriod": {
                        "endDate": "2014-10-31T00:00:00"
                    },
                    "tenderPeriod": {
                        "startDate": "2014-11-03T00:00:00",
                        "endDate": "2014-11-06T10:00:00"
                    },
                    "awardPeriod": {
                        "endDate": "2014-11-13T00:00:00"
                    },
                    "deliveryDate": {
                        "endDate": "2014-11-20T00:00:00"
                    },
                    "minimalStep": {
                        "amount": 35,
                        "currency": "UAH"
                    }
                }
            }

        """
        tender_id = generate_id()
        tender = self.request.validated['tender']
        tender.id = tender_id
        tender.tenderID = generate_tender_id(get_now(), self.db,
                                             self.server_id)
        if hasattr(tender, "initialize"):
            tender.initialize()
        set_ownership(tender, self.request)
        self.request.validated['tender'] = tender
        self.request.validated['tender_src'] = {}
        if save_tender(self.request):
            self.LOGGER.info(
                'Created tender {} ({})'.format(tender_id, tender.tenderID),
                extra=context_unpack(self.request,
                                     {'MESSAGE_ID': 'tender_create'}, {
                                         'tender_id': tender_id,
                                         'tenderID': tender.tenderID
                                     }))
            self.request.response.status = 201
            self.request.response.headers['Location'] = self.request.route_url(
                'Tender', tender_id=tender_id)
            return {
                'data': tender.serialize(tender.status),
                'access': {
                    'token': tender.owner_token
                }
            }
Esempio n. 31
0
def set_ownership(item, request):
    item.owner_token = generate_id()