def patch(self):
     """Contract Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated contract document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'contract_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 2
0
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info(
             "Updated tender bid document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_bid_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated tender award document {}'.format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_award_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction 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['auction_status'] not in [
             'active.tendering', 'active.auction', 'active.qualification',
             'active.awarded'
     ]:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) auction status'.format(
                 self.request.validated['auction_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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated auction complaint document {}'.format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'auction_complaint_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 5
0
 def patch(self):
     """Auction Award Complaint Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction award complaint document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_award_complaint_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if self.request.validated['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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info(
             'Updated tender award contract document {}'.format(
                 self.request.context.id),
             extra={'MESSAGE_ID': 'tender_award_contract_document_patch'})
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if self.request.validated['tender_status'] != 'active.tendering' and 'confidentiality' in self.request.validated['data']:
         if self.context.confidentiality != self.request.validated['data']['confidentiality']:
             self.request.errors.add('body', 'data', 'Can\'t update document confidentiality in current ({}) tender status'.format(self.request.validated['tender_status']))
             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 data for \'{}\' bid'.format(bid.status))
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender bid document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 8
0
 def patch(self):
     """Tender Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender bid document {}'.format(
             self.request.context.id),
                     extra=context_unpack(
                         self.request,
                         {'MESSAGE_ID': 'tender_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 10
0
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated tender qualification document {}'.format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_qualification_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     if self.apply(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated {} document {}".format(self.context_pretty_name, self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "{}_document_patch".format(self.context_name)}),
         )
         return {"data": self.request.context.serialize("view")}
 def patch(self):
     """Auction Award Document Update"""
     if not self.validate_award_document('update'):
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction award document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_award_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 13
0
 def patch(self):
     """Tender Award Complaint Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender award complaint document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_award_complaint_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
 def patch(self):
     """Tender Cancellation Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender cancellation document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_cancellation_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 15
0
 def patch(self):
     """Auction Contract Document Update"""
     if not validate_contract_document(self.request, 'update'):
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction contract document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_contract_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Document Update"""
     if not self.validate_update_tender('update'):
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Complaint Document Update"""
     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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender complaint document {}'.format(self.request.context.id), extra={'MESSAGE_ID': 'tender_complaint_document_patch'})
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Cancellation Document Update"""
     if self.request.validated['tender_status'] in ['complete', 'cancelled', 'unsuccessful']:
         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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender cancellation document {}'.format(self.request.context.id), extra={'MESSAGE_ID': 'tender_cancellation_document_patch'})
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     document = self.request.context
     if apply_patch(self.request):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated inspection document {}'.format(document.id),
             extra=context_unpack(
                 self.request, {'MESSAGE_ID': 'inspection_document_patch'},
                 {'DOCUMENT_ID': document.id}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 20
0
 def patch(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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender award document {}'.format(self.request.context.id), extra={'MESSAGE_ID': 'tender_award_document_patch'})
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 21
0
 def patch(self):
     """Tender Contract Document Update"""
     if not self.validate_contract_document("update"):
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender contract document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_contract_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 22
0
 def patch(self):
     """Auction Award Document Update"""
     if self.request.authenticated_role != self.request.context.author:
         self.request.errors.add('url', 'role', 'Can update document only author')
         self.request.errors.status = 403
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction award document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_award_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction Cancellation Document Update"""
     if self.request.validated['auction_status'] in ['complete', 'cancelled', 'unsuccessful']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) auction status'.format(self.request.validated['auction_status']))
         self.request.errors.status = 403
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction cancellation document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_cancellation_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Document Update"""
     if not self.validate_update_tender('update'):
         return
     if self.request.authenticated_role == 'tender_owner' and self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].invalidate_bids_data()
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 25
0
 def patch(self):
     """Auction Bid Document Update"""
     if not self.validate_bid_document('update'):
         return
     if self.request.validated['auction_status'] == 'active.tendering':
         self.request.validated['auction'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction bid document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction Bid Document Update"""
     if not self.validate_bid_document('update'):
         return
     if self.request.validated['auction_status'] == 'active.tendering':
         self.request.validated['auction'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction bid document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction Document Update"""
     if self.request.authenticated_role != 'auction' and self.request.validated['auction_status'] != 'active.enquiries' or \
        self.request.authenticated_role == 'auction' and self.request.validated['auction_status'] not in ['active.auction', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) auction status'.format(self.request.validated['auction_status']))
         self.request.errors.status = 403
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if self.request.validated[
             'tender_status'] != 'active.tendering' and 'confidentiality' in self.request.validated[
                 'data']:
         if self.context.confidentiality != self.request.validated['data'][
                 'confidentiality']:
             self.request.errors.add(
                 'body', 'data',
                 'Can\'t update document confidentiality in current ({}) tender status'
                 .format(self.request.validated['tender_status']))
             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 data for \'{}\' bid'.format(
                 bid.status))
         self.request.errors.status = 403
         return
     if self.request.validated['tender_status'] == 'active.tendering':
         self.request.validated['tender'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender bid document {}'.format(
             self.request.context.id),
                          extra=context_unpack(
                              self.request,
                              {'MESSAGE_ID': 'tender_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Award Complaint Document Update"""
     if not self.validate_complaint_document('update'):
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated tender award complaint document {}'.format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request,
                 {'MESSAGE_ID': 'tender_award_complaint_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 30
0
 def patch(self):
     """Tender Bid Document Update"""
     if self.request.validated["tender_status"] == "active.tendering":
         self.request.validated["tender"].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender bid document {}".format(
                 self.request.context.id),
             extra=context_unpack(
                 self.request, {"MESSAGE_ID": "tender_bid_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 31
0
 def patch(self):
     """Tender Bid Document Update"""
     tender_status = self.request.validated['tender_status']
     self._upload_permission(tender_status)
     if tender_status == 'active.tendering':
         self.request.validated['tender'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender bid document {}'.format(
             self.request.context.id),
                          extra=context_unpack(
                              self.request,
                              {'MESSAGE_ID': 'tender_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 32
0
 def patch(self):
     """Tender Document Update"""
     tender = self.request.validated["tender"]
     status = self.request.validated["tender_status"]
     if self.request.authenticated_role == "tender_owner" and status == "active.tendering":
         tender.invalidate_bids_data()
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender document {}".format(self.request.context.id),
             extra=context_unpack(self.request,
                                  {"MESSAGE_ID": "tender_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 33
0
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender bid document {}'.format(self.request.context.id), extra={'MESSAGE_ID': 'tender_bid_document_patch'})
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if self.request.validated['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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender award contract document {}'.format(self.request.context.id), extra={'MESSAGE_ID': 'tender_award_contract_document_patch'})
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 35
0
 def patch(self):
     """Tender Document Update"""
     if not self.validate_update_tender():
         raise error_handler(self.request.errors)
     if self.request.authenticated_role == 'tender_owner' and self.request.validated[
             'tender_status'] == 'active.tendering':
         self.request.validated['tender'].invalidate_bids_data()
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             'Updated tender document {}'.format(self.request.context.id),
             extra=context_unpack(self.request,
                                  {'MESSAGE_ID': 'tender_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender award document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_award_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 37
0
 def patch(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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender award document {}'.format(
             self.request.context.id),
                     extra={'MESSAGE_ID': 'tender_award_document_patch'})
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 38
0
 def patch(self):
     """Tender Document Update"""
     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 update document in current ({}) tender status'.format(
                 self.request.validated['tender_status']))
         self.request.errors.status = 403
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender document {}'.format(
             self.request.context.id),
                     extra={'MESSAGE_ID': 'tender_document_patch'})
         return {'data': self.request.context.serialize("view")}
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender qualification document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_qualification_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction Bid Document Update"""
     if self.request.validated['auction_status'] not in [
             'active.tendering', 'active.qualification'
     ]:
         self.request.errors.add(
             'body', 'data',
             'Can\'t update document in current ({}) auction status'.format(
                 self.request.validated['auction_status']))
         self.request.errors.status = 403
         return
     auction = self.request.validated['auction']
     if self.request.validated['auction_status'] == 'active.tendering' and (
             auction.tenderPeriod.startDate
             and get_now() < auction.tenderPeriod.startDate
             or get_now() > auction.tenderPeriod.endDate):
         self.request.errors.add(
             'body', 'data',
             'Document can be updated only during the tendering period: from ({}) to ({}).'
             .format(
                 auction.auctionPeriod.startDate
                 and auction.auctionPeriod.startDate.isoformat(),
                 auction.auctionPeriod.endDate.isoformat()))
         self.request.errors.status = 403
         return
     if self.request.validated[
             'auction_status'] == 'active.qualification' and not [
                 i for i in self.request.validated['auction'].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
     if self.request.validated['auction_status'] == 'active.tendering':
         self.request.validated['auction'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction bid document {}'.format(
             self.request.context.id),
                          extra=context_unpack(
                              self.request,
                              {'MESSAGE_ID': 'auction_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Tender Award Complaint Document Update"""
     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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info(
             "Updated tender award complaint document {}".format(self.request.context.id),
             extra={"MESSAGE_ID": "tender_award_complaint_document_patch"},
         )
         return {"data": self.request.context.serialize("view")}
 def patch(self):
     """Tender Award Document Update"""
     if self.request.validated["tender_status"] != "active":
         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 apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info(
             "Updated tender award document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_award_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 43
0
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(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_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 44
0
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         LOGGER.info('Updated tender complaint document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_complaint_document_patch'}))
         return {'data': self.request.context.serialize("view")}
    def patch(self):
        """Contract Document Update"""
        if self.request.validated['contract'].status != 'active':
            self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) contract status'.format(
                self.request.validated['contract'].status))
            self.request.errors.status = 403
            return

        data = self.request.validated['data']
        if "relatedItem" in data and data.get('documentOf') == 'change':
            if not [1 for c in self.request.validated['contract'].changes if c.id == data['relatedItem'] and c.status == 'pending']:
                self.request.errors.add('body', 'data', 'Can\'t add document to \'active\' change')
                self.request.errors.status = 403
                return

        if apply_patch(self.request, src=self.request.context.serialize()):
            update_file_content_type(self.request)
            self.LOGGER.info('Updated contract document {}'.format(self.request.context.id),
                        extra=context_unpack(self.request, {'MESSAGE_ID': 'contract_document_patch'}))
            return {'data': self.request.context.serialize("view")}
 def patch(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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info(
             "Updated tender award complaint document {}".format(self.request.context.id),
             extra=context_unpack(self.request, {"MESSAGE_ID": "tender_award_complaint_document_patch"}),
         )
         return {"data": self.request.context.serialize("view")}
Ejemplo n.º 47
0
 def patch(self):
     """Tender Contract Document Update"""
     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
     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 update 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 update document in current contract status')
         self.request.errors.status = 403
         return
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated tender contract document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'tender_contract_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction Bid Document Update"""
     if self.request.validated['auction_status'] not in ['active.tendering', 'active.qualification']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) auction status'.format(self.request.validated['auction_status']))
         self.request.errors.status = 403
         return
     auction = self.request.validated['auction']
     if self.request.validated['auction_status'] == 'active.tendering' and (auction.tenderPeriod.startDate and get_now() < auction.tenderPeriod.startDate or get_now() > auction.tenderPeriod.endDate):
         self.request.errors.add('body', 'data', 'Document can be updated only during the tendering period: from ({}) to ({}).'.format(auction.auctionPeriod.startDate and auction.auctionPeriod.startDate.isoformat(), auction.auctionPeriod.endDate.isoformat()))
         self.request.errors.status = 403
         return
     if self.request.validated['auction_status'] == 'active.qualification' and not [i for i in self.request.validated['auction'].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
     if self.request.validated['auction_status'] == 'active.tendering':
         self.request.validated['auction'].modified = False
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction bid document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_bid_document_patch'}))
         return {'data': self.request.context.serialize("view")}
 def patch(self):
     """Auction 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['auction_status'] not in ['active.qualification', 'active.awarded']:
         self.request.errors.add('body', 'data', 'Can\'t update document in current ({}) auction status'.format(self.request.validated['auction_status']))
         self.request.errors.status = 403
         return
     if any([i.status != 'active' for i in self.request.validated['auction'].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
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self.LOGGER.info('Updated auction award complaint document {}'.format(self.request.context.id),
                     extra=context_unpack(self.request, {'MESSAGE_ID': 'auction_award_complaint_document_patch'}))
         return {'data': self.request.context.serialize("view")}
Ejemplo n.º 50
0
 def patch(self):
     """Plan Document Update"""
     if apply_patch(self.request, src=self.request.context.serialize()):
         update_file_content_type(self.request)
         self._patch_document_log()
         return {"data": self.request.context.serialize("view")}