Beispiel #1
0
    def patch(self):
        """Tender Edit (partial)

        For example here is how procuring entity can change number of items to be procured and total Value of a tender:

        .. sourcecode:: http

            PATCH /tenders/4879d3f8ee2443169b5fbbc9f89fa607 HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "value": {
                        "amount": 600
                    },
                    "itemsToBeProcured": [
                        {
                            "quantity": 6
                        }
                    ]
                }
            }

        And here is the response to be expected:

        .. sourcecode:: http

            HTTP/1.0 200 OK
            Content-Type: application/json

            {
                "data": {
                    "id": "4879d3f8ee2443169b5fbbc9f89fa607",
                    "tenderID": "UA-64e93250be76435397e8c992ed4214d1",
                    "dateModified": "2014-10-27T08:12:34.956Z",
                    "value": {
                        "amount": 600
                    },
                    "itemsToBeProcured": [
                        {
                            "quantity": 6
                        }
                    ]
                }
            }

        """
        tender = self.request.validated['tender']
        if tender.status in ['complete', 'unsuccessful']:
            self.request.errors.add('body', 'data',
                                    'Can\'t change tender in current status')
            self.request.errors.status = 403
            return
        src = tender.serialize("plain")
        tender_data = filter_data(self.request.validated['data'])
        if tender_data:
            tender.import_data(apply_data_patch(src, tender_data))
            save_tender(tender, src, self.request)
        return {'data': tender.serialize(tender.status)}
Beispiel #2
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")}
 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 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 patch(self):
        """Tender Edit (partial)

        For example here is how procuring entity can change number of items to be procured and total Value of a tender:

        .. sourcecode:: http

            PATCH /tenders/4879d3f8ee2443169b5fbbc9f89fa607 HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "value": {
                        "amount": 600
                    },
                    "itemsToBeProcured": [
                        {
                            "quantity": 6
                        }
                    ]
                }
            }

        And here is the response to be expected:

        .. sourcecode:: http

            HTTP/1.0 200 OK
            Content-Type: application/json

            {
                "data": {
                    "id": "4879d3f8ee2443169b5fbbc9f89fa607",
                    "tenderID": "UA-64e93250be76435397e8c992ed4214d1",
                    "dateModified": "2014-10-27T08:12:34.956Z",
                    "value": {
                        "amount": 600
                    },
                    "itemsToBeProcured": [
                        {
                            "quantity": 6
                        }
                    ]
                }
            }

        """
        tender = self.request.validated['tender']
        if tender.status in ['complete', 'unsuccessful']:
            self.request.errors.add('body', 'data', 'Can\'t change tender in current status')
            self.request.errors.status = 403
            return
        src = tender.serialize("plain")
        tender_data = filter_data(self.request.validated['data'])
        if tender_data:
            tender.import_data(apply_data_patch(src, tender_data))
            save_tender(tender, src, self.request)
        return {'data': tender.serialize(tender.status)}
 def patch(self):
     """Post an Answer
     """
     tender = self.request.validated['tender']
     question = self.request.validated['question']
     question_data = filter_data(self.request.validated['data'])
     if question_data:
         src = tender.serialize("plain")
         question.import_data(apply_data_patch(question.serialize(), question_data))
         save_tender(tender, src, self.request)
     return {'data': question.serialize(self.request.validated['tender'].status)}
 def put(self):
     """Tender Document Update"""
     tender = self.request.validated['tender']
     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
     document = upload_file(self.request)
     tender.documents.append(document)
     save_tender(self.request)
     return {'data': document.serialize("view")}
 def put(self):
     """Tender Bid Document Update"""
     tender = self.request.validated['tender']
     if tender.status not in ['active.tendering', 'active.auction', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['bid'].documents.append(document)
     save_tender(self.request)
     return {'data': document.serialize("view")}
 def collection_post(self):
     """Post a question
     """
     tender = self.request.validated['tender']
     question_data = filter_data(self.request.validated['data'])
     question = Question(question_data)
     src = tender.serialize("plain")
     tender.questions.append(question)
     save_tender(tender, src, self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url('Tender Questions', tender_id=tender.id, id=question['id'])
     return {'data': question.serialize("view")}
 def put(self):
     """Tender Edit (full)"""
     tender = self.request.validated['tender']
     if tender.status in ['complete', 'unsuccessful']:
         self.request.errors.add('body', 'data', 'Can\'t change tender in current status')
         self.request.errors.status = 403
         return
     src = tender.serialize("plain")
     tender_data = filter_data(self.request.validated['data'])
     tender.import_data(tender_data)
     save_tender(tender, src, self.request)
     return {'data': tender.serialize(tender.status)}
Beispiel #11
0
 def put(self):
     """Tender Edit (full)"""
     tender = self.request.validated['tender']
     if tender.status in ['complete', 'unsuccessful']:
         self.request.errors.add('body', 'data',
                                 'Can\'t change tender in current status')
         self.request.errors.status = 403
         return
     src = tender.serialize("plain")
     tender_data = filter_data(self.request.validated['data'])
     tender.import_data(tender_data)
     save_tender(tender, src, self.request)
     return {'data': tender.serialize(tender.status)}
 def patch(self):
     """Update of contract
     """
     if self.request.validated['tender_status'] not in ['active.awarded', 'complete']:
         self.request.errors.add('body', 'data', 'Can\'t update contract in current tender status')
         self.request.errors.status = 403
         return
     contract = self.request.validated['contract']
     contract_data = self.request.validated['data']
     if contract_data:
         contract.import_data(apply_data_patch(contract.serialize(), contract_data))
         save_tender(self.request)
     return {'data': contract.serialize()}
 def patch(self):
     """Tender Bid Document Update"""
     if self.request.validated['tender_status'] not in ['active.tendering', 'active.auction', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     document = self.request.validated['document']
     document_data = self.request.validated['data']
     if document_data:
         document.import_data(document_data)
         document.dateModified = None
         save_tender(self.request)
     return {'data': document.serialize("view")}
Beispiel #14
0
 def collection_post(self):
     """Post a question
     """
     tender = self.request.validated['tender']
     question_data = filter_data(self.request.validated['data'])
     question = Question(question_data)
     src = tender.serialize("plain")
     tender.questions.append(question)
     save_tender(tender, src, self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url(
         'Tender Questions', tender_id=tender.id, id=question['id'])
     return {'data': question.serialize("view")}
 def patch(self):
     """Tender Document Update"""
     if self.request.validated['tender_status'] != 'active.enquiries':
         self.request.errors.add('body', 'data', 'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     document = self.request.validated['document']
     document_data = self.request.validated['data']
     if document_data:
         document.import_data(document_data)
         document.dateModified = None
         save_tender(self.request)
     return {'data': document.serialize("view")}
Beispiel #16
0
 def patch(self):
     """Post a complaint resolution
     """
     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 complaint in current tender status')
         self.request.errors.status = 403
         return
     complaint = self.request.validated['complaint']
     if complaint.status != 'pending':
         self.request.errors.add('body', 'data', 'Can\'t update complaint in current status')
         self.request.errors.status = 403
         return
     complaint_data = self.request.validated['data']
     if complaint_data:
         if complaint_data.get('status', '') == 'cancelled':
             self.request.errors.add('body', 'data', 'Can\'t cancel complaint')
             self.request.errors.status = 403
             return
         complaint.import_data(apply_data_patch(complaint.serialize(), complaint_data))
         if complaint.status == 'resolved' and tender.status != 'active.enquiries':
             for i in tender.complaints:
                 if i.status == 'pending':
                     i.status = 'cancelled'
             tender.status = 'cancelled'
         elif complaint.status in ['declined', 'invalid'] and tender.status == 'active.awarded':
             pending_complaints = [
                 i
                 for i in tender.complaints
                 if i.status == 'pending'
             ]
             pending_awards_complaints = [
                 i
                 for a in tender.awards
                 for i in a.complaints
                 if i.status == 'pending'
             ]
             stand_still_time_expired = tender.awardPeriod.endDate + STAND_STILL_TIME < get_now()
             if not pending_complaints and not pending_awards_complaints and stand_still_time_expired:
                 active_awards = [
                     a
                     for a in tender.awards
                     if a.status == 'active'
                 ]
                 if active_awards:
                     tender.status = 'complete'
                 else:
                     tender.status = 'unsuccessful'
         save_tender(self.request)
     return {'data': complaint.serialize("view")}
    def patch(self):
        """Update of proposal

        Example request to change bid proposal:

        .. sourcecode:: http

            PATCH /tenders/4879d3f8ee2443169b5fbbc9f89fa607/bids/71b6c23ed8944d688e92a31ec8c3f61a HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "value": {
                        "amount": 600
                    }
                }
            }

        And here is the response to be expected:

        .. sourcecode:: http

            HTTP/1.0 200 OK
            Content-Type: application/json

            {
                "data": {
                    "value": {
                        "amount": 600,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    }
                }
            }

        """
        tender = self.request.validated['tender']
        if tender.status != 'active.tendering':
            self.request.errors.add(
                'body', 'data', 'Can\'t change bid in current tender status')
            self.request.errors.status = 403
            return
        bid = self.request.validated['bid']
        bid_data = filter_data(self.request.validated['data'])
        if bid_data:
            src = tender.serialize("plain")
            bid.import_data(apply_data_patch(bid.serialize(), bid_data))
            save_tender(tender, src, self.request)
        return {'data': bid.serialize("view")}
 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
     document = upload_file(self.request)
     tender.documents.append(document)
     save_tender(self.request)
     self.request.response.status = 201
     document_route = self.request.matched_route.name.replace("collection_", "")
     self.request.response.headers['Location'] = self.request.current_route_url(_route_name=document_route, document_id=document.id, _query={})
     return {'data': document.serialize("view")}
Beispiel #19
0
 def patch(self):
     """Post an Answer
     """
     tender = self.request.validated['tender']
     question = self.request.validated['question']
     question_data = filter_data(self.request.validated['data'])
     if question_data:
         src = tender.serialize("plain")
         question.import_data(
             apply_data_patch(question.serialize(), question_data))
         save_tender(tender, src, self.request)
     return {
         'data': question.serialize(self.request.validated['tender'].status)
     }
 def patch(self):
     """Tender Document Update"""
     tender = self.request.validated['tender']
     document = self.request.validated['document']
     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
     document_data = filter_data(self.request.validated['data'])
     if document_data:
         src = tender.serialize("plain")
         document.import_data(document_data)
         save_tender(tender, src, self.request)
     return {'data': document.serialize("view")}
 def patch(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
     document = self.request.validated['document']
     document_data = filter_data(self.request.validated['data'])
     if document_data:
         src = tender.serialize("plain")
         document.import_data(document_data)
         save_tender(tender, src, self.request)
     return {'data': document.serialize("view")}
    def patch(self):
        """Update of proposal

        Example request to change bid proposal:

        .. sourcecode:: http

            PATCH /tenders/4879d3f8ee2443169b5fbbc9f89fa607/bids/71b6c23ed8944d688e92a31ec8c3f61a HTTP/1.1
            Host: example.com
            Accept: application/json

            {
                "data": {
                    "value": {
                        "amount": 600
                    }
                }
            }

        And here is the response to be expected:

        .. sourcecode:: http

            HTTP/1.0 200 OK
            Content-Type: application/json

            {
                "data": {
                    "value": {
                        "amount": 600,
                        "currency": "UAH",
                        "valueAddedTaxIncluded": true
                    }
                }
            }

        """
        tender = self.request.validated['tender']
        if tender.status != 'active.tendering':
            self.request.errors.add('body', 'data', 'Can\'t change bid in current tender status')
            self.request.errors.status = 403
            return
        bid = self.request.validated['bid']
        bid_data = filter_data(self.request.validated['data'])
        if bid_data:
            src = tender.serialize("plain")
            bid.import_data(apply_data_patch(bid.serialize(), bid_data))
            save_tender(tender, src, self.request)
        return {'data': bid.serialize("view")}
 def patch(self):
     """Post a complaint resolution
     """
     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 complaint in current tender status')
         self.request.errors.status = 403
         return
     complaint = self.request.validated['complaint']
     complaint_data = filter_data(self.request.validated['data'])
     if complaint_data:
         src = tender.serialize("plain")
         complaint.import_data(apply_data_patch(complaint.serialize(), complaint_data))
         save_tender(tender, src, self.request)
     return {'data': complaint.serialize("view")}
 def collection_post(self):
     """Post a complaint for award
     """
     tender = self.request.validated['tender']
     if tender.status not in ['active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t add complaint in current tender status')
         self.request.errors.status = 403
         return
     complaint_data = self.request.validated['data']
     complaint = Complaint(complaint_data)
     self.request.validated['award'].complaints.append(complaint)
     save_tender(self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url('Tender Award Complaints', tender_id=tender.id, award_id=self.request.validated['award_id'], complaint_id=complaint['id'])
     return {'data': complaint.serialize("view")}
 def collection_post(self):
     """Tender Award Complaint Document Upload
     """
     if not self.validate_complaint_document('add'):
         return
     document = upload_file(self.request)
     document.author = self.request.authenticated_role
     self.context.documents.append(document)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender award complaint document {}'.format(
                 document.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_award_complaint_document_create'},
                 {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace(
             "collection_", "")
         self.request.response.headers[
             'Location'] = self.request.current_route_url(
                 _route_name=document_route,
                 document_id=document.id,
                 _query={})
         return {'data': document.serialize("view")}
 def put(self):
     """Tender Award Document Update"""
     if self.request.validated['tender_status'] != 'active.qualification':
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if any([
             i.status != 'active'
             for i in self.request.validated['tender'].lots
             if i.id == self.request.validated['award'].lotID
     ]):
         self.request.errors.add(
             'body', 'data',
             'Can update document only in active lot status')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['award'].documents.append(document)
     if save_tender(self.request):
         self.LOGGER.info('Updated tender award document {}'.format(
             self.request.context.id),
                          extra=context_unpack(
                              self.request,
                              {'MESSAGE_ID': 'tender_award_document_put'}))
         return {'data': document.serialize("view")}
 def put(self):
     """Tender Award Contract Document Update"""
     if self.request.validated['tender_status'] not in [
             'active.awarded', 'complete'
     ]:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     contract = self.request.validated['contract']
     if contract.status not in ['pending', 'active']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current contract status')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['contract'].documents.append(document)
     if save_tender(self.request):
         LOGGER.info(
             'Updated tender award contract document {}'.format(
                 self.request.context.id),
             extra={'MESSAGE_ID': 'tender_award_contract_document_put'})
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Tender Bid Document Upload
     """
     if self.request.validated['tender_status'] not in ['active.tendering', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t add document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] == 'active.qualification' and not [i for i in self.request.validated['tender'].awards if i.status == 'pending' and i.bid_id == self.request.validated['bid_id']]:
         self.request.errors.add('body', 'data', 'Can\'t add document because award of bid is not in pending state')
         self.request.errors.status = 403
         return
     if self.context.status in ['invalid', 'unsuccessful', 'deleted']:
         self.request.errors.add('body', 'data', 'Can\'t add document to \'{}\' bid'.format(self.context.status))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     getattr(self.context, self.container).append(document)
     if self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].modified = False
     if save_tender(self.request):
         self.LOGGER.info('Created tender bid document {}'.format(document.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_bid_document_create'}, {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers['Location'] = self.request.current_route_url(_route_name=document_route, document_id=document.id, _query={})
         return {'data': document.serialize("view")}
Beispiel #29
0
 def collection_post(self):
     """Post a contract for award
     """
     tender = self.request.validated['tender']
     if tender.status not in ['active']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add contract in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     contract = self.request.validated['contract']
     tender.contracts.append(contract)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender contract {}'.format(contract.id),
             extra=context_unpack(self.request,
                                  {'MESSAGE_ID': 'tender_contract_create'},
                                  {'contract_id': contract.id}))
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Contracts',
             tender_id=tender.id,
             contract_id=contract['id'])
         return {'data': contract.serialize()}
Beispiel #30
0
 def collection_post(self):
     """Tender Document Upload"""
     if self.request.validated['tender_status'] != 'active':
         self.request.errors.add(
             'body', 'data',
             'Can\'t add document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['tender'].documents.append(document)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender document {}'.format(document.id),
             extra=context_unpack(self.request,
                                  {'MESSAGE_ID': 'tender_document_create'},
                                  {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace(
             "collection_", "")
         self.request.response.headers[
             'Location'] = self.request.current_route_url(
                 _route_name=document_route,
                 document_id=document.id,
                 _query={})
         return {'data': document.serialize("view")}
Beispiel #31
0
 def patch(self):
     """Post a cancellation resolution
     """
     tender = self.request.validated['tender']
     if tender.status in ['complete', 'cancelled', 'unsuccessful']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update cancellation in current ({}) tender status'.
             format(tender.status))
         self.request.errors.status = 403
         return
     if any([
             i.status != 'active' for i in tender.lots
             if i.id == self.request.context.relatedLot
     ]):
         self.request.errors.add(
             'body', 'data',
             'Can update cancellation only in active lot status')
         self.request.errors.status = 403
         return
     apply_patch(self.request,
                 save=False,
                 src=self.request.context.serialize())
     if self.request.context.relatedLot and self.request.context.status == 'active':
         self.cancel_lot()
     elif self.request.context.status == 'active':
         self.cancel_tender()
     if save_tender(self.request):
         self.LOGGER.info('Updated tender cancellation {}'.format(
             self.request.context.id),
                          extra=context_unpack(
                              self.request,
                              {'MESSAGE_ID': 'tender_cancellation_patch'}))
         return {'data': self.request.context.serialize("view")}
 def put(self):
     """Tender Award Complaint Document Update"""
     if self.request.authenticated_role != self.context.author:
         self.request.errors.add('url', 'role', 'Can update document only author')
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] not in ['active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if any([i.status != 'active' for i in self.request.validated['tender'].lots if i.id == self.request.validated['award'].lotID]):
         self.request.errors.add('body', 'data', 'Can update document only in active lot status')
         self.request.errors.status = 403
         return
     if self.request.validated['complaint'].status not in STATUS4ROLE.get(self.request.authenticated_role, []):
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) complaint status'.format(self.request.validated['complaint'].status))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     document.author = self.request.authenticated_role
     self.request.validated['complaint'].documents.append(document)
     if save_tender(self.request):
         LOGGER.info('Updated tender award complaint document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_award_complaint_document_put'}))
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Post a cancellation
     """
     tender = self.request.validated["tender"]
     if tender.status in ["complete", "cancelled", "unsuccessful"]:
         self.request.errors.add(
             "body", "data", "Can't add cancellation in current ({}) tender status".format(tender.status)
         )
         self.request.errors.status = 403
         return
     cancellation = self.request.validated["cancellation"]
     if cancellation.status == "active":
         tender.status = "cancelled"
     tender.cancellations.append(cancellation)
     if save_tender(self.request):
         self.LOGGER.info(
             "Created tender cancellation {}".format(cancellation.id),
             extra=context_unpack(
                 self.request, {"MESSAGE_ID": "tender_cancellation_create"}, {"cancellation_id": cancellation.id}
             ),
         )
         self.request.response.status = 201
         self.request.response.headers["Location"] = self.request.route_url(
             "Tender Cancellations", tender_id=tender.id, cancellation_id=cancellation.id
         )
         return {"data": cancellation.serialize("view")}
Beispiel #34
0
 def collection_post(self):
     """Post a question
     """
     tender = self.request.validated['tender']
     now = get_now()
     if now < tender.enquiryPeriod.startDate or now > tender.enquiryPeriod.endDate:
         self.request.errors.add('body', 'data',
                                 'Can add question only in enquiryPeriod')
         self.request.errors.status = 403
         return
     question = self.request.validated['question']
     if any([
             i.status != 'active' for i in tender.lots
             if i.id == question.relatedItem
     ]):
         self.request.errors.add(
             'body', 'data', 'Can add question only in active lot status')
         self.request.errors.status = 403
         return
     tender.questions.append(question)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender question {}'.format(question.id),
             extra=context_unpack(self.request,
                                  {'MESSAGE_ID': 'tender_question_create'},
                                  {'question_id': question.id}))
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Questions',
             tender_id=tender.id,
             question_id=question.id)
         return {'data': question.serialize("view")}
 def collection_post(self):
     """Tender Bid Document Upload
     """
     if self.request.validated["tender_status"] not in ["active.tendering", "active.qualification"]:
         self.request.errors.add(
             "body",
             "data",
             "Can't add document in current ({}) tender status".format(self.request.validated["tender_status"]),
         )
         self.request.errors.status = 403
         return
     if self.request.validated["tender_status"] == "active.qualification" and not [
         i
         for i in self.request.validated["tender"].awards
         if i.status == "pending" and i.bid_id == self.request.validated["bid_id"]
     ]:
         self.request.errors.add("body", "data", "Can't add document because award of bid is not in pending state")
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.context.documents.append(document)
     if save_tender(self.request):
         LOGGER.info(
             "Created tender bid document {}".format(document.id),
             extra=context_unpack(
                 self.request, {"MESSAGE_ID": "tender_bid_document_create"}, {"document_id": document.id}
             ),
         )
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers["Location"] = self.request.current_route_url(
             _route_name=document_route, document_id=document.id, _query={}
         )
         return {"data": document.serialize("view")}
 def put(self):
     """Tender Bid Document Update"""
     if self.request.validated["tender_status"] not in ["active.tendering", "active.qualification"]:
         self.request.errors.add(
             "body",
             "data",
             "Can't update document in current ({}) tender status".format(self.request.validated["tender_status"]),
         )
         self.request.errors.status = 403
         return
     if self.request.validated["tender_status"] == "active.qualification" and not [
         i
         for i in self.request.validated["tender"].awards
         if i.status == "pending" and i.bid_id == self.request.validated["bid_id"]
     ]:
         self.request.errors.add(
             "body", "data", "Can't update document because award of bid is not in pending state"
         )
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated["bid"].documents.append(document)
     if save_tender(self.request):
         LOGGER.info(
             "Updated tender bid document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_bid_document_put"}),
         )
         return {"data": document.serialize("view")}
    def post(self):
        complaint = self.request.context
        tender = self.request.validated['tender']
        qualification_id = self.request.validated['qualification_id']
        location = self.request.route_path(
            'Tender EU Qualification Complaints',
            tender_id=tender.id,
            qualification_id=qualification_id,
            complaint_id=complaint.id)
        location = location[len(ROUTE_PREFIX):]  # strips /api/<version>

        if change_ownership(self.request, location) and save_tender(
                self.request):
            self.LOGGER.info(
                'Updated qualification {} complaint {} ownership of tender {}'.
                format(complaint.id, qualification_id, tender.id),
                extra=context_unpack(
                    self.request,
                    {'MESSAGE_ID': 'qualification_complaint_ownership_update'},
                    {
                        'complaint_id': complaint.id,
                        'qualification_id': qualification_id,
                        'tender_id': tender.id
                    }))

            return {'data': complaint.serialize('view')}
 def patch(self):
     """Post a complaint resolution
     """
     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 complaint in current ({}) tender status'.format(tender.status))
         self.request.errors.status = 403
         return
     if self.context.status not in ['draft', 'claim', 'answered', 'pending']:
         self.request.errors.add('body', 'data', 'Can\'t update complaint in current ({}) status'.format(self.context.status))
         self.request.errors.status = 403
         return
     data = self.request.validated['data']
     # complaint_owner
     if self.request.authenticated_role == 'complaint_owner' and self.context.status in ['draft', 'claim', 'answered', 'pending'] and data.get('status', self.context.status) == 'cancelled':
         apply_patch(self.request, save=False, src=self.context.serialize())
         self.context.dateCanceled = get_now()
     elif self.request.authenticated_role == 'complaint_owner' and tender.status in ['active.enquiries', 'active.tendering'] and self.context.status == 'draft' and data.get('status', self.context.status) == self.context.status:
         apply_patch(self.request, save=False, src=self.context.serialize())
     elif self.request.authenticated_role == 'complaint_owner' and tender.status in ['active.enquiries', 'active.tendering'] and self.context.status == 'draft' and data.get('status', self.context.status) == 'claim':
         apply_patch(self.request, save=False, src=self.context.serialize())
         self.context.dateSubmitted = get_now()
     elif self.request.authenticated_role == 'complaint_owner' and self.context.status == 'answered' and data.get('status', self.context.status) == self.context.status:
         apply_patch(self.request, save=False, src=self.context.serialize())
     elif self.request.authenticated_role == 'complaint_owner' and self.context.status == 'answered' and data.get('satisfied', self.context.satisfied) is True and data.get('status', self.context.status) == 'resolved':
         apply_patch(self.request, save=False, src=self.context.serialize())
     elif self.request.authenticated_role == 'complaint_owner' and self.context.status == 'answered' and data.get('satisfied', self.context.satisfied) is False and data.get('status', self.context.status) == 'pending':
         apply_patch(self.request, save=False, src=self.context.serialize())
         self.context.type = 'complaint'
         self.context.dateEscalated = get_now()
     # tender_owner
     elif self.request.authenticated_role == 'tender_owner' and self.context.status == 'claim' and data.get('status', self.context.status) == self.context.status:
         apply_patch(self.request, save=False, src=self.context.serialize())
     elif self.request.authenticated_role == 'tender_owner' and self.context.status == 'claim' and data.get('resolution', self.context.resolution) and data.get('resolutionType', self.context.resolutionType) and data.get('status', self.context.status) == 'answered':
         if len(data.get('resolution', self.context.resolution)) < 20:
             self.request.errors.add('body', 'data', 'Can\'t update complaint: resolution too short')
             self.request.errors.status = 403
             return
         apply_patch(self.request, save=False, src=self.context.serialize())
         self.context.dateAnswered = get_now()
     elif self.request.authenticated_role == 'tender_owner' and self.context.status == 'pending':
         apply_patch(self.request, save=False, src=self.context.serialize())
     # reviewers
     elif self.request.authenticated_role == 'reviewers' and self.context.status == 'pending' and data.get('status', self.context.status) == self.context.status:
         apply_patch(self.request, save=False, src=self.context.serialize())
     elif self.request.authenticated_role == 'reviewers' and self.context.status == 'pending' and data.get('status', self.context.status) in ['resolved', 'invalid', 'declined']:
         apply_patch(self.request, save=False, src=self.context.serialize())
         self.context.dateDecision = get_now()
     else:
         self.request.errors.add('body', 'data', 'Can\'t update complaint')
         self.request.errors.status = 403
         return
     if self.context.tendererAction and not self.context.tendererActionDate:
         self.context.tendererActionDate = get_now()
     if self.context.status not in ['draft', 'claim', 'answered', 'pending'] and tender.status in ['active.qualification', 'active.awarded']:
         check_tender_status(self.request)
     if save_tender(self.request):
         self.LOGGER.info('Updated tender complaint {}'.format(self.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_complaint_patch'}))
         return {'data': self.context.serialize("view")}
 def collection_post(self):
     """Post a complaint for award
     """
     tender = self.request.validated['tender']
     if tender.status not in ['active.qualification', 'active.awarded']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add complaint in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     if self.request.context.complaintPeriod and \
        (self.request.context.complaintPeriod.startDate and self.request.context.complaintPeriod.startDate > get_now() or
             self.request.context.complaintPeriod.endDate and self.request.context.complaintPeriod.endDate < get_now()):
         self.request.errors.add(
             'body', 'data', 'Can add complaint only in complaintPeriod')
         self.request.errors.status = 403
         return
     complaint_data = self.request.validated['data']
     complaint = Complaint(complaint_data)
     self.request.context.complaints.append(complaint)
     if save_tender(self.request):
         update_journal_handler_params({'complaint_id': complaint.id})
         LOGGER.info('Created tender award complaint {}'.format(
             complaint.id),
                     extra={'MESSAGE_ID': 'tender_award_complaint_create'})
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Award Complaints',
             tender_id=tender.id,
             award_id=self.request.validated['award_id'],
             complaint_id=complaint['id'])
         return {'data': complaint.serialize("view")}
 def collection_post(self):
     """Tender Award Complaint Document Upload
     """
     if self.request.validated['tender_status'] not in ['active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t add document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if any([i.status != 'active' for i in self.request.validated['tender'].lots if i.id == self.request.validated['award'].lotID]):
         self.request.errors.add('body', 'data', 'Can add document only in active lot status')
         self.request.errors.status = 403
         return
     if self.context.status not in STATUS4ROLE.get(self.request.authenticated_role, []):
         self.request.errors.add('body', 'data', 'Can\'t add document in current ({}) complaint status'.format(self.context.status))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     document.author = self.request.authenticated_role
     self.context.documents.append(document)
     if save_tender(self.request):
         LOGGER.info('Created tender award complaint document {}'.format(document.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_award_complaint_document_create'}, {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers['Location'] = self.request.current_route_url(_route_name=document_route, document_id=document.id, _query={})
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Tender Award Document Upload
     """
     if self.request.validated["tender_status"] != "active":
         self.request.errors.add(
             "body",
             "data",
             "Can't add document in current ({}) tender status".format(self.request.validated["tender_status"]),
         )
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated["award"].documents.append(document)
     if save_tender(self.request):
         LOGGER.info(
             "Created tender award document {}".format(document.id),
             extra=context_unpack(
                 self.request, {"MESSAGE_ID": "tender_award_document_create"}, {"document_id": document.id}
             ),
         )
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers["Location"] = self.request.current_route_url(
             _route_name=document_route, document_id=document.id, _query={}
         )
         return {"data": document.serialize("view")}
Beispiel #42
0
 def collection_post(self):
     """Tender Contract Document Upload
     """
     if self.request.validated['tender_status'] not in ['active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t add document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     tender = self.request.validated['tender']
     contract = self.request.validated['contract']
     if any([i.status != 'active' for i in tender.lots if i.id in [a.lotID for a in tender.awards if a.id == contract.awardID]]):
         self.request.errors.add('body', 'data', 'Can add document only in active lot status')
         self.request.errors.status = 403
         return
     if contract.status not in ['pending', 'active']:
         self.request.errors.add('body', 'data', 'Can\'t add document in current contract status')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.context.documents.append(document)
     if save_tender(self.request):
         self.LOGGER.info('Created tender contract document {}'.format(document.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_contract_document_create'}, {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers['Location'] = self.request.current_route_url(_route_name=document_route, document_id=document.id, _query={})
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Post a cancellation
     """
     tender = self.request.validated['tender']
     if tender.status in ['complete', 'cancelled', 'unsuccessful']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add cancellation in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     cancellation = self.request.validated['cancellation']
     cancellation.date = get_now()
     if cancellation.status == 'active':
         tender.status = 'cancelled'
     tender.cancellations.append(cancellation)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender cancellation {}'.format(cancellation.id),
             extra=context_unpack(
                 self.request, {'MESSAGE_ID': 'tender_cancellation_create'},
                 {'cancellation_id': cancellation.id}))
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Cancellations',
             tender_id=tender.id,
             cancellation_id=cancellation.id)
         return {'data': cancellation.serialize("view")}
 def patch(self):
     """Post a complaint resolution
     """
     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 complaint in current ({}) tender status'.format(tender.status))
         self.request.errors.status = 403
         return
     if self.request.context.status != 'pending':
         self.request.errors.add('body', 'data', 'Can\'t update complaint in current ({}) status'.format(self.request.context.status))
         self.request.errors.status = 403
         return
     if self.request.validated['data'].get('status', self.request.context.status) == 'cancelled':
         self.request.errors.add('body', 'data', 'Can\'t cancel complaint')
         self.request.errors.status = 403
         return
     apply_patch(self.request, save=False, src=self.request.context.serialize())
     if self.request.context.status == 'resolved' and tender.status != 'active.enquiries':
         for i in tender.complaints:
             if i.status == 'pending':
                 i.status = 'cancelled'
         [setattr(i, 'status', 'cancelled') for i in tender.lots]
         tender.status = 'cancelled'
     elif self.request.context.status in ['declined', 'invalid'] and tender.status == 'active.awarded':
         check_tender_status(self.request)
     if save_tender(self.request):
         LOGGER.info('Updated tender complaint {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_complaint_patch'}))
         return {'data': self.request.context.serialize("view")}
    def post(self):
        tender = self.request.validated['tender']
        data = self.request.validated['ownership_data']

        if tender.transfer_token == sha512(data['transfer']).hexdigest():
            location = self.request.route_path('Tender', tender_id=tender.id)
            location = location[len(ROUTE_PREFIX):]  # strips /api/<version>
            transfer = extract_transfer(self.request, transfer_id=data['id'])
            if transfer.get('usedFor') and transfer.get('usedFor') != location:
                self.request.errors.add('body', 'transfer', 'Transfer already used')
                self.request.errors.status = 403
                return
        else:
            self.request.errors.add('body', 'transfer', 'Invalid transfer')
            self.request.errors.status = 403
            return

        update_ownership(tender, transfer)
        self.request.validated['tender'] = tender

        transfer.usedFor = location
        self.request.validated['transfer'] = transfer
        if save_transfer(self.request):
            self.LOGGER.info('Updated transfer relation {}'.format(transfer.id),
                             extra=context_unpack(self.request, {'MESSAGE_ID': 'transfer_relation_update'}))

            if save_tender(self.request):
                self.LOGGER.info('Updated ownership of tender {}'.format(tender.id),
                                extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_ownership_update'}))

                return {'data': tender.serialize('view')}
Beispiel #46
0
 def collection_post(self):
     """Tender Document Upload"""
     if self.request.authenticated_role != 'auction' and self.request.validated['tender_status'] != 'active.enquiries' or \
        self.request.authenticated_role == 'auction' and self.request.validated['tender_status'] not in ['active.auction', 'active.qualification']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['tender'].documents.append(document)
     if save_tender(self.request):
         update_journal_handler_params({'document_id': document.id})
         LOGGER.info('Created tender document {}'.format(document.id),
                     extra={'MESSAGE_ID': 'tender_document_create'})
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace(
             "collection_", "")
         self.request.response.headers[
             'Location'] = self.request.current_route_url(
                 _route_name=document_route,
                 document_id=document.id,
                 _query={})
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Post a complaint
     """
     tender = self.context
     if tender.status not in ['active.enquiries', 'active.tendering']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add complaint in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     complaint = self.request.validated['complaint']
     if complaint.status == 'claim':
         complaint.dateSubmitted = get_now()
     else:
         complaint.status = 'draft'
     set_ownership(complaint, self.request)
     tender.complaints.append(complaint)
     if save_tender(self.request):
         LOGGER.info(
             'Created tender complaint {}'.format(complaint.id),
             extra=context_unpack(self.request,
                                  {'MESSAGE_ID': 'tender_complaint_create'},
                                  {'complaint_id': complaint.id}))
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Complaints',
             tender_id=tender.id,
             complaint_id=complaint.id)
         return {
             'data': complaint.serialize("view"),
             'access': {
                 'token': complaint.owner_token
             }
         }
 def collection_post(self):
     """Post a complaint for award
     """
     tender = self.request.validated['tender']
     if tender.status not in ['active.qualification', 'active.awarded']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add complaint in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     if any([
             i.status != 'active' for i in tender.lots
             if i.id == self.context.lotID
     ]):
         self.request.errors.add(
             'body', 'data', 'Can add complaint only in active lot status')
         self.request.errors.status = 403
         return
     if self.context.complaintPeriod and \
        (self.context.complaintPeriod.startDate and self.context.complaintPeriod.startDate > get_now() or
             self.context.complaintPeriod.endDate and self.context.complaintPeriod.endDate < get_now()):
         self.request.errors.add(
             'body', 'data', 'Can add complaint only in complaintPeriod')
         self.request.errors.status = 403
         return
     complaint = self.request.validated['complaint']
     complaint.date = get_now()
     complaint.relatedLot = self.context.lotID
     if complaint.status == 'claim':
         complaint.dateSubmitted = get_now()
     elif complaint.status == 'pending':
         complaint.type = 'complaint'
         complaint.dateSubmitted = get_now()
     else:
         complaint.status = 'draft'
     complaint.complaintID = '{}.{}{}'.format(
         tender.tenderID, self.server_id,
         self.complaints_len(tender) + 1)
     set_ownership(complaint, self.request)
     self.context.complaints.append(complaint)
     if save_tender(self.request):
         self.LOGGER.info(
             'Created tender award complaint {}'.format(complaint.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_award_complaint_create'},
                 {'complaint_id': complaint.id}))
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Award Complaints',
             tender_id=tender.id,
             award_id=self.request.validated['award_id'],
             complaint_id=complaint['id'])
         return {
             'data': complaint.serialize("view"),
             'access': {
                 'token': complaint.owner_token
             }
         }
 def collection_post(self):
     """Post a contract for award
     """
     tender = self.request.validated['tender']
     if tender.status not in ['active.awarded', 'complete']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t add contract in current ({}) tender status'.format(
                 tender.status))
         self.request.errors.status = 403
         return
     contract_data = self.request.validated['data']
     contract = Contract(contract_data)
     contract.awardID = self.request.validated['award_id']
     self.request.validated['award'].contracts.append(contract)
     if save_tender(self.request):
         update_journal_handler_params({'contract_id': contract.id})
         LOGGER.info('Created tender award contract {}'.format(contract.id),
                     extra={'MESSAGE_ID': 'tender_award_contract_create'})
         self.request.response.status = 201
         self.request.response.headers['Location'] = self.request.route_url(
             'Tender Award Contracts',
             tender_id=tender.id,
             award_id=self.request.validated['award_id'],
             contract_id=contract['id'])
         return {'data': contract.serialize()}
    def post(self):
        complaint = self.request.context
        tender = self.request.validated['tender']
        award_id = self.request.validated['award_id']
        data = self.request.validated['ownership_data']

        if complaint.transfer_token == sha512(data['transfer']).hexdigest():
            location = self.request.route_path('Tender Award Complaints', tender_id=tender.id, award_id=award_id, complaint_id=complaint.id)
            location = location[len(ROUTE_PREFIX):]  # strips /api/<version>
            transfer = extract_transfer(self.request, transfer_id=data['id'])
            if transfer.get('usedFor') and transfer.get('usedFor') != location:
                self.request.errors.add('body', 'transfer', 'Transfer already used')
                self.request.errors.status = 403
                return
        else:
            self.request.errors.add('body', 'transfer', 'Invalid transfer')
            self.request.errors.status = 403
            return

        update_ownership(complaint, transfer)

        transfer.usedFor = location
        self.request.validated['transfer'] = transfer
        if save_transfer(self.request):
            self.LOGGER.info('Updated transfer relation {}'.format(transfer.id),
                             extra=context_unpack(self.request, {'MESSAGE_ID': 'transfer_relation_update'}))

            if save_tender(self.request):
                self.LOGGER.info('Updated award {} complaint {} ownership of tender {}'.format(complaint.id, award_id, tender.id),
                                 extra=context_unpack(self.request, {'MESSAGE_ID': 'award_complaint_ownership_update'}, {'complaint_id': complaint.id, 'award_id': award_id, 'tender_id': tender.id}))

                return {'data': complaint.serialize('view')}
 def collection_post(self):
     """Post a complaint
     """
     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 add complaint in current tender status')
         self.request.errors.status = 403
         return
     complaint_data = filter_data(self.request.validated['data'])
     complaint = Complaint(complaint_data)
     src = tender.serialize("plain")
     tender.complaints.append(complaint)
     save_tender(tender, src, self.request)
     self.request.response.status = 201
     self.request.response.headers['Location'] = self.request.route_url('Tender Complaints', tender_id=tender.id, id=complaint['id'])
     return {'data': complaint.serialize("view")}
Beispiel #52
0
 def patch(self):
     """Tender Award Complaint Document Update"""
     tender = self.request.validated['tender']
     if tender.status not in ['active.qualification', 'active.awarded']:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current tender status')
         self.request.errors.status = 403
         return
     document = self.request.validated['document']
     document_data = filter_data(self.request.validated['data'])
     if document_data:
         src = tender.serialize("plain")
         document.import_data(document_data)
         save_tender(tender, src, self.request)
     return {'data': document.serialize("view")}
 def put(self):
     """Tender Bid Document Update"""
     if self.request.validated['tender_status'] not in [
             'active.tendering', 'active.qualification'
     ]:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if self.request.validated[
             'tender_status'] == 'active.qualification' and not [
                 i for i in self.request.validated['tender'].awards
                 if i.status == 'pending'
                 and i.bid_id == self.request.validated['bid_id']
             ]:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document because award of bid is not in pending state'
         )
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['bid'].documents.append(document)
     if save_tender(self.request):
         LOGGER.info('Updated tender bid document {}'.format(
             self.request.context.id),
                     extra=context_unpack(
                         self.request,
                         {'MESSAGE_ID': 'tender_bid_document_put'}))
         return {'data': document.serialize("view")}
Beispiel #54
0
 def put(self):
     """Tender Qualification Document Update"""
     if self.request.validated[
             'tender_status'] != 'active.pre-qualification':
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     qualification = self.request.validated['qualification']
     if qualification.status != 'pending':
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current qualification status')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated['qualification'].documents.append(document)
     if save_tender(self.request):
         self.LOGGER.info(
             'Updated tender qualification document {}'.format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_qualification_document_put'}))
         return {'data': document.serialize("view")}
    def patch(self):
        """Update of contract
        """
        if self.request.validated['tender_status'] not in ['active', 'complete']:
            self.request.errors.add('body', 'data', 'Can\'t update contract in current ({}) tender status'.format(self.request.validated['tender_status']))
            self.request.errors.status = 403
            return
        data = self.request.validated['data']
        if self.request.context.status == 'cancelled':
            self.request.errors.add('body', 'data', 'Can\'t update contract in current ({}) status'.format(self.request.context.status))
            self.request.errors.status = 403
            return
        if self.request.context.status != 'active' and 'status' in data and data['status'] == 'active':
            tender = self.request.validated['tender']
            award = [a for a in tender.awards if a.id == self.request.context.awardID][0]
            stand_still_end = award.complaintPeriod.endDate
            if stand_still_end > get_now():
                self.request.errors.add('body', 'data', 'Can\'t sign contract before stand-still period end ({})'.format(stand_still_end.isoformat()))
                self.request.errors.status = 403
                return

        contract_status = self.request.context.status
        apply_patch(self.request, save=False, src=self.request.context.serialize())
        if contract_status != self.request.context.status and contract_status != 'pending' and self.request.context.status != 'active':
            self.request.errors.add('body', 'data', 'Can\'t update contract status')
            self.request.errors.status = 403
            return

        check_tender_status(self.request)
        if save_tender(self.request):
            LOGGER.info('Updated tender contract {}'.format(self.request.context.id),
                        extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_contract_patch'}))
            return {'data': self.request.context.serialize()}
 def put(self):
     """Tender Bid Document Update"""
     if self.request.validated['tender_status'] not in ['active.tendering', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     tender = self.request.validated['tender']
     if self.request.validated['tender_status'] == 'active.tendering' and (tender.tenderPeriod.startDate and get_now() < tender.tenderPeriod.startDate or get_now() > tender.tenderPeriod.endDate):
         self.request.errors.add('body', 'data', 'Document can be updated only during the tendering period: from ({}) to ({}).'.format(tender.tenderPeriod.startDate and tender.tenderPeriod.startDate.isoformat(), tender.tenderPeriod.endDate.isoformat()))
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] == 'active.qualification' and not [i for i in self.request.validated['tender'].awards if i.status == 'pending' and i.bid_id == self.request.validated['bid_id']]:
         self.request.errors.add('body', 'data', 'Can\'t update document because award of bid is not in pending state')
         self.request.errors.status = 403
         return
     bid = getattr(self.context, "__parent__")
     if bid and bid.status in ['invalid', 'unsuccessful', 'deleted']:
         self.request.errors.add('body', 'data', 'Can\'t update document in \'{}\' bid'.format(bid.status))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     getattr(self.request.validated['bid'], self.container).append(document)
     if self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].modified = False
     if save_tender(self.request):
         self.LOGGER.info('Updated tender bid document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_bid_document_put'}))
         return {'data': document.serialize("view")}
 def put(self):
     """Tender Complaint Document Update"""
     if self.request.authenticated_role != self.context.author:
         self.request.errors.add('url', 'role',
                                 'Can update document only author')
         self.request.errors.status = 403
         return
     if self.request.validated['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'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if self.request.validated['complaint'].status not in STATUS4ROLE.get(
             self.request.authenticated_role, []):
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) complaint status'.
             format(self.request.validated['complaint'].status))
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     document.author = self.request.authenticated_role
     self.request.validated['complaint'].documents.append(document)
     if save_tender(self.request):
         LOGGER.info('Updated tender complaint document {}'.format(
             self.request.context.id),
                     extra=context_unpack(
                         self.request,
                         {'MESSAGE_ID': 'tender_complaint_document_put'}))
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Tender Bid Document Upload
     """
     if self.request.validated['tender_status'] not in ['active.tendering', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t add document in current ({}) tender status'.format(self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     tender = self.request.validated['tender']
     if self.request.validated['tender_status'] == 'active.tendering' and (tender.tenderPeriod.startDate and get_now() < tender.tenderPeriod.startDate or get_now() > tender.tenderPeriod.endDate):
         self.request.errors.add('body', 'data', 'Document can be added only during the tendering period: from ({}) to ({}).'.format(tender.tenderPeriod.startDate and tender.tenderPeriod.startDate.isoformat(), tender.tenderPeriod.endDate.isoformat()))
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] == 'active.qualification' and not [i for i in self.request.validated['tender'].awards if i.status == 'pending' and i.bid_id == self.request.validated['bid_id']]:
         self.request.errors.add('body', 'data', 'Can\'t add document because award of bid is not in pending state')
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.context.documents.append(document)
     if self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].modified = False
     if save_tender(self.request):
         self.LOGGER.info('Created tender bid document {}'.format(document.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_bid_document_create'}, {'document_id': document.id}))
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers['Location'] = self.request.current_route_url(_route_name=document_route, document_id=document.id, _query={})
         return {'data': document.serialize("view")}
 def collection_post(self):
     """Tender Award Complaint Document Upload
     """
     if self.request.validated["tender_status"] not in ["active.qualification", "active.awarded"]:
         self.request.errors.add(
             "body",
             "data",
             "Can't add document in current ({}) tender status".format(self.request.validated["tender_status"]),
         )
         self.request.errors.status = 403
         return
     document = upload_file(self.request)
     self.request.validated["complaint"].documents.append(document)
     if save_tender(self.request):
         update_journal_handler_params({"document_id": document.id})
         LOGGER.info(
             "Created tender award complaint document {}".format(document.id),
             extra={"MESSAGE_ID": "tender_award_complaint_document_create"},
         )
         self.request.response.status = 201
         document_route = self.request.matched_route.name.replace("collection_", "")
         self.request.response.headers["Location"] = self.request.current_route_url(
             _route_name=document_route, document_id=document.id, _query={}
         )
         return {"data": document.serialize("view")}