diff --git a/ted_sws/notice_packager/services/metadata_transformer.py b/ted_sws/notice_packager/services/metadata_transformer.py index eeb7de887..cf08db01f 100644 --- a/ted_sws/notice_packager/services/metadata_transformer.py +++ b/ted_sws/notice_packager/services/metadata_transformer.py @@ -13,6 +13,7 @@ import datetime +from ted_sws.core.model.metadata import NormalisedMetadata from ted_sws.notice_metadata_processor.model.metadata import ExtractedMetadata from ted_sws.notice_packager.model.metadata import PackagerMetadata, METS_TYPE_CREATE, LANGUAGE, REVISION, BASE_WORK, \ BASE_TITLE, METS_DMD_HREF, METS_DMD_ID, METS_TMD_ID, METS_TMD_HREF, METS_FILE_ID, METS_NOTICE_FILE_HREF @@ -28,7 +29,7 @@ class MetadataTransformer: - def __init__(self, notice_metadata: ExtractedMetadata): + def __init__(self, notice_metadata: NormalisedMetadata): self.notice_metadata = notice_metadata def template_metadata(self, action: str = METS_TYPE_CREATE) -> PackagerMetadata: @@ -50,12 +51,11 @@ def normalize_value(cls, value: str) -> str: return value.replace(DENORMALIZED_SEPARATOR, NORMALIZED_SEPARATOR) @classmethod - def from_notice_metadata(cls, notice_metadata: ExtractedMetadata) -> PackagerMetadata: + def from_notice_metadata(cls, notice_metadata: NormalisedMetadata) -> PackagerMetadata: _date = datetime.datetime.now() _revision = REVISION metadata = PackagerMetadata() - # NOTICE metadata.notice.id = cls.normalize_value(notice_metadata.notice_publication_number) metadata.notice.public_number_document = publication_notice_number(metadata.notice.id) @@ -63,19 +63,20 @@ def from_notice_metadata(cls, notice_metadata: ExtractedMetadata) -> PackagerMet notice_metadata) + filled_ojs_issue_number(notice_metadata.ojs_issue_number) # WORK - publication_date = datetime.datetime.strptime(notice_metadata.publication_date, '%Y%m%d').strftime('%Y-%m-%d') + publication_date = datetime.datetime.fromisoformat(notice_metadata.publication_date).strftime('%Y-%m-%d') metadata.work.identifier = publication_work_identifier(metadata.notice.id, notice_metadata) metadata.work.oj_identifier = publication_work_oj_identifier(metadata.notice.id, notice_metadata) metadata.work.cdm_rdf_type = PROCUREMENT_PUBLIC metadata.work.resource_type = PROCUREMENT_NOTICE metadata.work.date_document = publication_date metadata.work.uri = publication_notice_uri(metadata.notice.id, notice_metadata) - title_search = [t.title.text for t in notice_metadata.title if t.title.language == LANGUAGE.upper()] + # TODO: If no title found in english get a random one + title_search = [title.text for title in notice_metadata.title if title.language == LANGUAGE.upper()] if len(title_search) > 0: metadata.work.title = {LANGUAGE: title_search[0]} metadata.work.dataset_version = _date.strftime('%Y%m%d') + '-' + _revision metadata.work.procurement_public_issued_by_country = notice_metadata.country_of_buyer - metadata.work.procurement_public_url_etendering = notice_metadata.uri_list + # metadata.work.procurement_public_url_etendering = notice_metadata.uri_list # EXPRESSION metadata.expression.identifier = f"{metadata.work.identifier}.MUL" @@ -118,7 +119,7 @@ def from_notice_metadata(cls, notice_metadata: ExtractedMetadata) -> PackagerMet def publication_notice_year(notice_metadata): - return datetime.datetime.strptime(notice_metadata.publication_date, '%Y%m%d').strftime('%Y') + return str(datetime.datetime.fromisoformat(notice_metadata.publication_date).year) def publication_notice_number(notice_id): diff --git a/tests/test_data/notices/eform-622690-2023.json b/tests/test_data/notices/eform-622690-2023.json new file mode 100644 index 000000000..75cf1325e --- /dev/null +++ b/tests/test_data/notices/eform-622690-2023.json @@ -0,0 +1,50 @@ +{ + "AA": [ + "la" + ], + "CY": [ + "FIN" + ], + "DD": "2023-10-26", + "DI": "32014L0024", + "DS": "2023-10-12", + "DT": [ + "2023-11-14" + ], + "MA": [ + "gen-pub" + ], + "NC": [ + "services" + ], + "ND": "622690-2023", + "OC": [ + "92000000", + "92600000", + "92610000" + ], + "OJ": "198/2023", + "OL": "fi", + "OY": [ + "FI1", + "FI1C", + "FI1C1", + "FIN", + "spcy" + ], + "PC": [ + "92000000", + "92600000", + "92610000" + ], + "PD": "2023-10-13", + "PR": "open", + "RC": [ + "FI1", + "FI1C", + "FI1C1", + "FIN", + "spcy" + ], + "content": "<?xml version="1.0" encoding="UTF-8" standalone="no"?><ContractNotice xmlns="urn:oasis:names:specification:ubl:schema:xsd:ContractNotice-2" xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2" xmlns:efac="http://data.europa.eu/p27/eforms-ubl-extension-aggregate-components/1" xmlns:efbc="http://data.europa.eu/p27/eforms-ubl-extension-basic-components/1" xmlns:efext="http://data.europa.eu/p27/eforms-ubl-extensions/1" xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2">
  <ext:UBLExtensions>
    <ext:UBLExtension>
      <ext:ExtensionContent>
        <efext:EformsExtension>
          <efbc:TransmissionDate>2023-10-12+00:00</efbc:TransmissionDate>
          <efbc:TransmissionTime>12:42:18+00:00</efbc:TransmissionTime>
          <efac:NoticeSubType>
            <cbc:SubTypeCode listName="notice-subtype">16</cbc:SubTypeCode>
          </efac:NoticeSubType>
          <efac:Organizations>
            <efac:Organization>
              <efbc:AcquiringCPBIndicator>false</efbc:AcquiringCPBIndicator>
              <efbc:AwardingCPBIndicator>false</efbc:AwardingCPBIndicator>
              <efac:Company>
                <cbc:WebsiteURI>http://www.salo.fi</cbc:WebsiteURI>
                <cac:PartyIdentification>
                  <cbc:ID schemeName="organization">ORG-0001</cbc:ID>
                </cac:PartyIdentification>
                <cac:PartyName>
                  <cbc:Name languageID="FIN">Salon kaupunki</cbc:Name>
                </cac:PartyName>
                <cac:PostalAddress>
                  <cbc:StreetName>PL 77</cbc:StreetName>
                  <cbc:CityName>Salo</cbc:CityName>
                  <cbc:PostalZone>24101</cbc:PostalZone>
                  <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
                  <cac:Country>
                    <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
                  </cac:Country>
                </cac:PostalAddress>
                <cac:PartyLegalEntity>
                  <cbc:CompanyID schemeID="002">0139533-1</cbc:CompanyID>
                </cac:PartyLegalEntity>
                <cac:Contact>
                  <cbc:Name>Liikuntapalvelut</cbc:Name>
                  <cbc:Telephone>+358 27781</cbc:Telephone>
                  <cbc:ElectronicMail>kirjaamo@salo.fi</cbc:ElectronicMail>
                </cac:Contact>
              </efac:Company>
            </efac:Organization>
            <efac:Organization>
              <efac:Company>
                <cbc:WebsiteURI>http://www.oikeus.fi/markkinaoikeus</cbc:WebsiteURI>
                <cac:PartyIdentification>
                  <cbc:ID schemeName="organization">ORG-0002</cbc:ID>
                </cac:PartyIdentification>
                <cac:PartyName>
                  <cbc:Name languageID="FIN">Markkinaoikeus</cbc:Name>
                </cac:PartyName>
                <cac:PostalAddress>
                  <cbc:StreetName>Radanrakentajantie 5</cbc:StreetName>
                  <cbc:CityName>Helsinki</cbc:CityName>
                  <cbc:PostalZone>00520</cbc:PostalZone>
                  <cbc:CountrySubentityCode listName="nuts">FI1B1</cbc:CountrySubentityCode>
                  <cac:Country>
                    <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
                  </cac:Country>
                </cac:PostalAddress>
                <cac:PartyLegalEntity>
                  <cbc:CompanyID schemeID="002">3006157-6</cbc:CompanyID>
                </cac:PartyLegalEntity>
                <cac:Contact>
                  <cbc:Telephone>+358 295643300</cbc:Telephone>
                  <cbc:ElectronicMail>markkinaoikeus@oikeus.fi</cbc:ElectronicMail>
                </cac:Contact>
              </efac:Company>
            </efac:Organization>
            <efac:Organization>
              <efac:Company>
                <cbc:WebsiteURI>http://hankintailmoitukset.fi</cbc:WebsiteURI>
                <cac:PartyIdentification>
                  <cbc:ID schemeName="organization">ORG-0003</cbc:ID>
                </cac:PartyIdentification>
                <cac:PartyName>
                  <cbc:Name languageID="FIN">Hansel Oy (Hilma)</cbc:Name>
                </cac:PartyName>
                <cac:PostalAddress>
                  <cbc:StreetName>Mannerheiminaukio 1a</cbc:StreetName>
                  <cbc:CityName>Helsinki</cbc:CityName>
                  <cbc:PostalZone>00100</cbc:PostalZone>
                  <cbc:CountrySubentityCode listName="nuts">FI1B1</cbc:CountrySubentityCode>
                  <cac:Country>
                    <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
                  </cac:Country>
                </cac:PostalAddress>
                <cac:PartyLegalEntity>
                  <cbc:CompanyID schemeID="002">0988084-1</cbc:CompanyID>
                </cac:PartyLegalEntity>
                <cac:Contact>
                  <cbc:Name>eSender</cbc:Name>
                  <cbc:Telephone>029 55 636 30</cbc:Telephone>
                  <cbc:ElectronicMail>tekninen@hankintailmoitukset.fi</cbc:ElectronicMail>
                </cac:Contact>
              </efac:Company>
            </efac:Organization>
          </efac:Organizations>
        <efac:Publication><efbc:NoticePublicationID schemeName="ojs-notice-id">00622690-2023</efbc:NoticePublicationID><efbc:GazetteID schemeName="ojs-id">198/2023</efbc:GazetteID><efbc:PublicationDate>2023-10-13Z</efbc:PublicationDate></efac:Publication></efext:EformsExtension>
      </ext:ExtensionContent>
    </ext:UBLExtension>
  </ext:UBLExtensions>
  <cbc:UBLVersionID>2.3</cbc:UBLVersionID>
  <cbc:CustomizationID>eforms-sdk-1.7</cbc:CustomizationID>
  <cbc:ID schemeName="notice-id">e7d406f3-0ba2-4cc8-8152-e1bd0e0d0aa3</cbc:ID>
  <cbc:ContractFolderID>7450a31d-7e21-44bb-ac95-032d37241638</cbc:ContractFolderID>
  <cbc:IssueDate>2023-10-12+00:00</cbc:IssueDate>
  <cbc:IssueTime>12:41:50+00:00</cbc:IssueTime>
  <cbc:VersionID>01</cbc:VersionID>
  <cbc:RegulatoryDomain>32014L0024</cbc:RegulatoryDomain>
  <cbc:NoticeTypeCode listName="competition">cn-standard</cbc:NoticeTypeCode>
  <cbc:NoticeLanguageCode>FIN</cbc:NoticeLanguageCode>
  <cac:ContractingParty>
    <cac:ContractingPartyType>
      <cbc:PartyTypeCode listName="buyer-legal-type">la</cbc:PartyTypeCode>
    </cac:ContractingPartyType>
    <cac:ContractingActivity>
      <cbc:ActivityTypeCode listName="authority-activity">gen-pub</cbc:ActivityTypeCode>
    </cac:ContractingActivity>
    <cac:Party>
      <cac:PartyIdentification>
        <cbc:ID schemeName="organization">ORG-0001</cbc:ID>
      </cac:PartyIdentification>
      <cac:ServiceProviderParty>
        <cbc:ServiceTypeCode listName="organisation-role">ted-esen</cbc:ServiceTypeCode>
        <cac:Party>
          <cac:PartyIdentification>
            <cbc:ID schemeName="organization">ORG-0003</cbc:ID>
          </cac:PartyIdentification>
        </cac:Party>
      </cac:ServiceProviderParty>
    </cac:Party>
  </cac:ContractingParty>
  <cac:TenderingTerms>
    <cac:TendererQualificationRequest>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">bankr-nat</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on kansalliseen lainsäädäntöön ja kansallisiin määräyksiin perustuen yllämainittuja tilanteita vastaavassa samankaltaisessa menettelyssä. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">bankruptcy</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on konkurssissa. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">corruption</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle tai mille tahansa henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen tai jolla on siinä päätös-, edustus- tai valvontavaltaa, annettu lahjonnasta lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">cred-arran</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalla on järjestelyjä velkojien kanssa. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">crime-org</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle tai henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen tai jolla on siinä päätös-, edustus- tai valvontavaltaa, on annettu rikollisjärjestön toimintaan osallistumisesta lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">distorsion</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on tehnyt muiden kanssa sopimuksia, joilla pyritään vääristämään kilpailua. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">envir-law</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on rikkonut ympäristölainsäädännön mukaisia velvoitteitaan. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">finan-laund</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle itselleen tai mille tahansa henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen tai jolla on siinä päätös-, edustus- tai valvontavaltaa, on annettu rahanpesusta tai terrorismin rahoituksesta lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">fraud</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle tai mille tahansa henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen, on annettu petoksesta lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">human-traffic</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle itselleen tai mille tahansa henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen tai jolla on siinä päätös-, edustus- tai valvontavaltaa, on annettu lapsityövoiman käytöstä tai muista ihmiskaupan muodoista lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">insolvency</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan osalta on käynnistetty maksukyvyttömyys- tai likvidaatiomenettely. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">labour-law</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on rikkonut työlainsäädännön mukaisia velvoitteitaan. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">liq-admin</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan varat ovat selvitysmiehen tai tuomioistuimen hallinnassa. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">misrepresent</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan aikaisempia hankintasopimuksia tai käyttöoikeussopimuksia on irtisanottu ennenaikaisesti tai kyseisen aikaisemman sopimuksen yhteydessä on vaadittu vahingonkorvauksia tai määrätty muita vastaavia seuraamuksia. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">nati-ground</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan hallinto-, johto- tai valvontaelimen jäsen tai edustus-,päätös- tai valvontavaltaa käyttävä henkilö on rikosrekisteristä ilmenevällä lainvoimaisella tuomiolla tuomittu työturvallisuusrikoksesta, työaikasuojelurikoksesta, työsyrjinnästä, kiskonnantapaisesta työsyrjinnästä, työntekijöiden järjestäytymisvapauden loukkaamisesta tai luvattoman ulkomaisen työvoiman käytöstä. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">partic-confl</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan osallistumisesta hankintamenettelyyn aiheutuu eturistiriitoja. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">prep-confl</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja tai tarjoajaan liittyvä yritys on antanut ostajalle neuvoja tai muulla tavoin osallistunut hankintamenettelyn valmisteluun. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">prof-misconduct</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on syyllistynyt ammatin harjoittamiseen liittyvään vakavaan virheeseen. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">sanction</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan aikaisempia hankintasopimuksia tai käyttöoikeussopimuksia on irtisanottu ennenaikaisesti tai kyseisen aikaisemman sopimuksen yhteydessä on vaadittu vahingonkorvauksia tai määrätty muita vastaavia seuraamuksia. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">socsec-law</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on rikkonut sosiaalilainsäädännön mukaisia velvoitteitaan. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">socsec-pay</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on rikkonut sosiaaliturvamaksujen maksamiseen liittyviä velvoitteitaan sijoittumismaassaan tai ostajan maassa. Hankintayksikön on suljettava tarjouskilpailusta ehdokas tai tarjoaja, joka on lainvoimaisella päätöksellä tai tuomiolla todettu laiminlyöneen velvollisuutensa maksaa Suomen tai sijoittautumismaansa veroja tai sosiaaliturvamaksuja. Edellä säädettyä ei kuitenkaan sovelleta, jos ehdokas tai tarjoaja on maksanut verot tai sosiaaliturvamaksut taikka sopinut sitovasta järjestelystä niiden maksamista varten (hankintalain 80 §).</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">susp-act</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajan liiketoiminta on keskeytetty. Hankintayksikkö voi sulkea pois tarjoajan, jota koskee jokin hankintalain 81 §:ssä mainituista asioista.</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">tax-pay</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoaja on rikkonut verojen maksamiseen liittyviä velvoitteitaan sijoittumismaassaan tai ostajan maassa. Hankintayksikön on suljettava tarjouskilpailusta ehdokas tai tarjoaja, joka on lainvoimaisella päätöksellä tai tuomiolla todettu laiminlyöneen velvollisuutensa maksaa Suomen tai sijoittautumismaansa veroja tai sosiaaliturvamaksuja. Edellä säädettyä ei kuitenkaan sovelleta, jos ehdokas tai tarjoaja on maksanut verot tai sosiaaliturvamaksut taikka sopinut sitovasta järjestelystä niiden maksamista varten (hankintalain 80 §).</cbc:Description>
      </cac:SpecificTendererRequirement>
      <cac:SpecificTendererRequirement>
        <cbc:TendererRequirementTypeCode listName="exclusion-ground">terr-offence</cbc:TendererRequirementTypeCode>
        <cbc:Description languageID="FIN">Tarjoajalle itselleen tai mille tahansa henkilölle, joka on sen hallinto-, johto- tai valvontaelimen jäsen tai jolla on siinä päätös-, edustus- tai valvontavaltaa, annettu terrorismirikoksesta tai terroritoimintaan liittyvästä rikoksesta lainvoimainen tuomio, joka on annettu enintään viisi vuotta sitten tai jolla suoraan vahvistettu poissulkeminen on edelleen voimassa. Hankintayksiköllä on velvollisuus sulkea tarjouskilpailusta tarjoaja, joka on syyllistynyt hankintalain (1397/2016) 80 §:n mukaisiin rikoksiin.</cbc:Description>
      </cac:SpecificTendererRequirement>
    </cac:TendererQualificationRequest>
  </cac:TenderingTerms>
  <cac:TenderingProcess>
    <cbc:ProcedureCode listName="procurement-procedure-type">open</cbc:ProcedureCode>
  </cac:TenderingProcess>
  <cac:ProcurementProject>
    <cbc:ID schemeName="InternalID">4710/02.08.00.05/2023 (478755)</cbc:ID>
    <cbc:Name languageID="FIN">Eteläisen Salon liikuntapaikkojen hoidon hankinta</cbc:Name>
    <cbc:Description languageID="FIN">Salon kaupungin liikuntapalvelut (jäljempänä Hankintayksikkö tai Tilaaja) pyytää tarjouksia kaupungin eteläisen osan liikuntapaikkojen kesä- ja talvihoidosta vuosille 2024-2025 tämän tarjouspyynnön ja sen liitteiden mukaisesti. Lisäksi tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. 

Liikuntapaikkojen hoidolla tarkoitetaan Salon kaupungin liikuntapaikkojen hoitoa, kunnossapitoa sekä erilaisia liikuntapaikkojen ylläpitoon liittyviä tehtäviä, jotka on määritelty yksityiskohtaisesti kohteittain liitteessä 1. Hankinnan vaatimukset ja palvelukuvaus. Kohteet sijaitsevat Perniössä, Kiskossa ja Muurlassa. </cbc:Description>
    <cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
    <cbc:Note languageID="FIN">Sopimuksen alkamisaika on arvio, joka voi muuttua. 

Ilmoitettu tarjousten avausajankohta ei ole hankintayksikköä sitova. Tarjoukset voidaan avata myös muuna ajankohtana tarjousten vastaanottamiselle asetetun määräajan umpeuduttua. Avaustilaisuus ei ole julkinen.</cbc:Note>
    <cac:MainCommodityClassification>
      <cbc:ItemClassificationCode listName="cpv">92610000</cbc:ItemClassificationCode>
    </cac:MainCommodityClassification>
    <cac:RealizedLocation>
      <cac:Address>
        <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
        <cac:Country>
          <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
        </cac:Country>
      </cac:Address>
    </cac:RealizedLocation>
  </cac:ProcurementProject>
  <cac:ProcurementProjectLot>
    <cbc:ID schemeName="Lot">LOT-0001</cbc:ID>
    <cac:TenderingTerms>
      <ext:UBLExtensions>
        <ext:UBLExtension>
          <ext:ExtensionContent>
            <efext:EformsExtension>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">ef-stand</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">sui-act</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">tp-abil</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
            </efext:EformsExtension>
          </ext:ExtensionContent>
        </ext:UBLExtension>
      </ext:UBLExtensions>
      <cbc:FundingProgramCode listName="eu-funded">no-eu-funds</cbc:FundingProgramCode>
      <cbc:RecurringProcurementIndicator>true</cbc:RecurringProcurementIndicator>
      <cbc:MultipleTendersCode listName="permission">allowed</cbc:MultipleTendersCode>
      <cac:CallForTendersDocumentReference>
        <cbc:ID>Linkki hankinta-asiakirjoihin</cbc:ID>
        <cbc:DocumentType>non-restricted-document</cbc:DocumentType>
        <cac:Attachment>
          <cac:ExternalReference>
            <cbc:URI>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:URI>
          </cac:ExternalReference>
        </cac:Attachment>
      </cac:CallForTendersDocumentReference>
      <cac:TendererQualificationRequest>
        <cac:SpecificTendererRequirement>
          <cbc:TendererRequirementTypeCode listName="reserved-procurement">none</cbc:TendererRequirementTypeCode>
        </cac:SpecificTendererRequirement>
      </cac:TendererQualificationRequest>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="einvoicing">required</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="reserved-execution">no</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="ecatalog-submission">not-allowed</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:AwardingTerms>
        <cac:AwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>60</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">price</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Kokonaisvertailuhinta</cbc:Name>
            <cbc:Description languageID="FIN">Halvin tarjottu tarjouspyynnön mukainen kokonaishinta saa vertailussa enimmäispisteet 60. Muiden tarjoajien pistemäärä muodostuu suorassa suhteessa halvimpaan (halvin / vertailtava hinta x enimmäispisteet).</cbc:Description>
          </cac:SubordinateAwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>40</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">quality</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Laatupisteet</cbc:Name>
            <cbc:Description languageID="FIN">Laatupisteytys ja -kriteeri ovat seuraavat:
1. Tarjoajan henkilöstön (ilman vastaavaa työnjohtajaa) kokemus vastaavista ulkoliikuntapaikkojen kesähoidon palvelutehtävistä, 10 % eli enintään 10 pistettä. 
2. Tarjoajan tämän osa-alueen liikuntapaikkojen hoitoon käytettävissä olevan henkilöstön koulutus, 15 % eli 15 pistettä.
3. Vastaavan työnjohtajan kokemus ulkoliikuntapaikkojen kesähoidon palvelutehtävistä 15 % eli 15 pistettä.</cbc:Description>
          </cac:SubordinateAwardingCriterion>
        </cac:AwardingCriterion>
      </cac:AwardingTerms>
      <cac:TenderRecipientParty>
        <cbc:EndpointID>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:EndpointID>
      </cac:TenderRecipientParty>
      <cac:TenderValidityPeriod>
        <cbc:DurationMeasure unitCode="DAY">120</cbc:DurationMeasure>
      </cac:TenderValidityPeriod>
      <cac:AppealTerms>
        <cac:AppealReceiverParty>
          <cac:PartyIdentification>
            <cbc:ID schemeName="organization">ORG-0002</cbc:ID>
          </cac:PartyIdentification>
        </cac:AppealReceiverParty>
      </cac:AppealTerms>
      <cac:Language>
        <cbc:ID>FIN</cbc:ID>
      </cac:Language>
      <cac:PostAwardProcess>
        <cbc:ElectronicOrderUsageIndicator>false</cbc:ElectronicOrderUsageIndicator>
        <cbc:ElectronicPaymentUsageIndicator>true</cbc:ElectronicPaymentUsageIndicator>
      </cac:PostAwardProcess>
    </cac:TenderingTerms>
    <cac:TenderingProcess>
      <cbc:SubmissionMethodCode listName="esubmission">required</cbc:SubmissionMethodCode>
      <cbc:GovernmentAgreementConstraintIndicator>true</cbc:GovernmentAgreementConstraintIndicator>
      <cac:TenderSubmissionDeadlinePeriod>
        <cbc:EndDate>2023-11-15+02:00</cbc:EndDate>
        <cbc:EndTime>12:00:00+02:00</cbc:EndTime>
      </cac:TenderSubmissionDeadlinePeriod>
      <cac:AdditionalInformationRequestPeriod>
        <cbc:EndDate>2023-10-26+03:00</cbc:EndDate>
        <cbc:EndTime>16:00:00+03:00</cbc:EndTime>
      </cac:AdditionalInformationRequestPeriod>
      <cac:OpenTenderEvent>
        <cbc:OccurrenceDate>2023-11-15+02:00</cbc:OccurrenceDate>
        <cbc:OccurrenceTime>12:30:00+02:00</cbc:OccurrenceTime>
      </cac:OpenTenderEvent>
      <cac:AuctionTerms>
        <cbc:AuctionConstraintIndicator>false</cbc:AuctionConstraintIndicator>
      </cac:AuctionTerms>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="dps-usage">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="framework-agreement">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
    </cac:TenderingProcess>
    <cac:ProcurementProject>
      <cbc:ID schemeName="InternalID">1.</cbc:ID>
      <cbc:Name languageID="FIN">1. Perniön kaupunginosa, kesähoito</cbc:Name>
      <cbc:Description languageID="FIN">Hankinnan kohteena on Perniön kaupunginosan liikuntapaikkojen kesähoito tarjouspyynnön ja liitteen 1. Hankinnan vaatimukset ja palvelukuvaus mukaisesti. Lisäksi tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
      <cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
      <cbc:SMESuitableIndicator>true</cbc:SMESuitableIndicator>
      <cac:MainCommodityClassification>
        <cbc:ItemClassificationCode listName="cpv">92610000</cbc:ItemClassificationCode>
      </cac:MainCommodityClassification>
      <cac:RealizedLocation>
        <cac:Address>
          <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
          <cac:Country>
            <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
          </cac:Country>
        </cac:Address>
      </cac:RealizedLocation>
      <cac:PlannedPeriod>
        <cbc:StartDate>2024-01-01+02:00</cbc:StartDate>
        <cbc:EndDate>2025-12-31+02:00</cbc:EndDate>
      </cac:PlannedPeriod>
      <cac:ContractExtension>
        <cbc:MaximumNumberNumeric>2</cbc:MaximumNumberNumeric>
        <cac:Renewal>
          <cac:Period>
            <cbc:Description languageID="FIN">Tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
          </cac:Period>
        </cac:Renewal>
      </cac:ContractExtension>
    </cac:ProcurementProject>
  </cac:ProcurementProjectLot>
  <cac:ProcurementProjectLot>
    <cbc:ID schemeName="Lot">LOT-0002</cbc:ID>
    <cac:TenderingTerms>
      <ext:UBLExtensions>
        <ext:UBLExtension>
          <ext:ExtensionContent>
            <efext:EformsExtension>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">ef-stand</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">sui-act</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">tp-abil</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
            </efext:EformsExtension>
          </ext:ExtensionContent>
        </ext:UBLExtension>
      </ext:UBLExtensions>
      <cbc:FundingProgramCode listName="eu-funded">no-eu-funds</cbc:FundingProgramCode>
      <cbc:RecurringProcurementIndicator>true</cbc:RecurringProcurementIndicator>
      <cbc:MultipleTendersCode listName="permission">allowed</cbc:MultipleTendersCode>
      <cac:CallForTendersDocumentReference>
        <cbc:ID>Linkki hankinta-asiakirjoihin</cbc:ID>
        <cbc:DocumentType>non-restricted-document</cbc:DocumentType>
        <cac:Attachment>
          <cac:ExternalReference>
            <cbc:URI>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:URI>
          </cac:ExternalReference>
        </cac:Attachment>
      </cac:CallForTendersDocumentReference>
      <cac:TendererQualificationRequest>
        <cac:SpecificTendererRequirement>
          <cbc:TendererRequirementTypeCode listName="reserved-procurement">none</cbc:TendererRequirementTypeCode>
        </cac:SpecificTendererRequirement>
      </cac:TendererQualificationRequest>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="einvoicing">required</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="reserved-execution">no</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="ecatalog-submission">not-allowed</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:AwardingTerms>
        <cac:AwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>60</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">price</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Kokonaisvertailuhinta</cbc:Name>
            <cbc:Description languageID="FIN">Halvin tarjottu tarjouspyynnön mukainen kokonaishinta saa vertailussa enimmäispisteet 60. Muiden tarjoajien pistemäärä muodostuu suorassa suhteessa halvimpaan (halvin / vertailtava hinta x enimmäispisteet).</cbc:Description>
          </cac:SubordinateAwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>40</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">quality</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Laatupisteet</cbc:Name>
            <cbc:Description languageID="FIN">Laatupisteytys ja -kriteeri ovat seuraavat:
1. Tarjoajan henkilöstön (ilman vastaavaa työnjohtajaa) kokemus vastaavista ulkoliikuntapaikkojen talvihoidon palvelutehtävistä, 10 % eli enintään 10 pistettä. 
2. Tarjoajan tämän osa-alueen liikuntapaikkojen hoitoon käytettävissä olevan henkilöstön koulutus, 15 % eli 15 pistettä.
3. Vastaavan työnjohtajan kokemus ulkoliikuntapaikkojen talvihoidon palvelutehtävistä 15 % eli 15 pistettä.</cbc:Description>
          </cac:SubordinateAwardingCriterion>
        </cac:AwardingCriterion>
      </cac:AwardingTerms>
      <cac:TenderRecipientParty>
        <cbc:EndpointID>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:EndpointID>
      </cac:TenderRecipientParty>
      <cac:TenderValidityPeriod>
        <cbc:DurationMeasure unitCode="DAY">120</cbc:DurationMeasure>
      </cac:TenderValidityPeriod>
      <cac:AppealTerms>
        <cac:AppealReceiverParty>
          <cac:PartyIdentification>
            <cbc:ID schemeName="organization">ORG-0002</cbc:ID>
          </cac:PartyIdentification>
        </cac:AppealReceiverParty>
      </cac:AppealTerms>
      <cac:Language>
        <cbc:ID>FIN</cbc:ID>
      </cac:Language>
      <cac:PostAwardProcess>
        <cbc:ElectronicOrderUsageIndicator>true</cbc:ElectronicOrderUsageIndicator>
        <cbc:ElectronicPaymentUsageIndicator>true</cbc:ElectronicPaymentUsageIndicator>
      </cac:PostAwardProcess>
    </cac:TenderingTerms>
    <cac:TenderingProcess>
      <cbc:SubmissionMethodCode listName="esubmission">required</cbc:SubmissionMethodCode>
      <cbc:GovernmentAgreementConstraintIndicator>true</cbc:GovernmentAgreementConstraintIndicator>
      <cac:TenderSubmissionDeadlinePeriod>
        <cbc:EndDate>2023-11-15+02:00</cbc:EndDate>
        <cbc:EndTime>12:00:00+02:00</cbc:EndTime>
      </cac:TenderSubmissionDeadlinePeriod>
      <cac:AdditionalInformationRequestPeriod>
        <cbc:EndDate>2023-10-26+03:00</cbc:EndDate>
        <cbc:EndTime>16:00:00+03:00</cbc:EndTime>
      </cac:AdditionalInformationRequestPeriod>
      <cac:OpenTenderEvent>
        <cbc:OccurrenceDate>2023-11-15+02:00</cbc:OccurrenceDate>
        <cbc:OccurrenceTime>12:30:00+02:00</cbc:OccurrenceTime>
      </cac:OpenTenderEvent>
      <cac:AuctionTerms>
        <cbc:AuctionConstraintIndicator>false</cbc:AuctionConstraintIndicator>
      </cac:AuctionTerms>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="dps-usage">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="framework-agreement">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
    </cac:TenderingProcess>
    <cac:ProcurementProject>
      <cbc:ID schemeName="InternalID">2.</cbc:ID>
      <cbc:Name languageID="FIN">2. Perniön kaupunginosa, talvihoito</cbc:Name>
      <cbc:Description languageID="FIN">Hankinnan kohteena on Perniön kaupunginosan liikuntapaikkojen talvihoito tarjouspyynnön ja liitteen 1. Hankinnan vaatimukset ja palvelukuvaus mukaisesti. Lisäksi tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
      <cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
      <cbc:SMESuitableIndicator>true</cbc:SMESuitableIndicator>
      <cac:MainCommodityClassification>
        <cbc:ItemClassificationCode listName="cpv">92610000</cbc:ItemClassificationCode>
      </cac:MainCommodityClassification>
      <cac:RealizedLocation>
        <cac:Address>
          <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
          <cac:Country>
            <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
          </cac:Country>
        </cac:Address>
      </cac:RealizedLocation>
      <cac:PlannedPeriod>
        <cbc:StartDate>2024-01-01+02:00</cbc:StartDate>
        <cbc:EndDate>2025-12-31+02:00</cbc:EndDate>
      </cac:PlannedPeriod>
      <cac:ContractExtension>
        <cbc:MaximumNumberNumeric>2</cbc:MaximumNumberNumeric>
        <cac:Renewal>
          <cac:Period>
            <cbc:Description languageID="FIN">Tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
          </cac:Period>
        </cac:Renewal>
      </cac:ContractExtension>
    </cac:ProcurementProject>
  </cac:ProcurementProjectLot>
  <cac:ProcurementProjectLot>
    <cbc:ID schemeName="Lot">LOT-0003</cbc:ID>
    <cac:TenderingTerms>
      <ext:UBLExtensions>
        <ext:UBLExtension>
          <ext:ExtensionContent>
            <efext:EformsExtension>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">ef-stand</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">sui-act</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">tp-abil</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
            </efext:EformsExtension>
          </ext:ExtensionContent>
        </ext:UBLExtension>
      </ext:UBLExtensions>
      <cbc:FundingProgramCode listName="eu-funded">no-eu-funds</cbc:FundingProgramCode>
      <cbc:RecurringProcurementIndicator>true</cbc:RecurringProcurementIndicator>
      <cbc:MultipleTendersCode listName="permission">allowed</cbc:MultipleTendersCode>
      <cac:CallForTendersDocumentReference>
        <cbc:ID>Linkki hankinta-asiakirjoihin</cbc:ID>
        <cbc:DocumentType>non-restricted-document</cbc:DocumentType>
        <cac:Attachment>
          <cac:ExternalReference>
            <cbc:URI>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:URI>
          </cac:ExternalReference>
        </cac:Attachment>
      </cac:CallForTendersDocumentReference>
      <cac:TendererQualificationRequest>
        <cac:SpecificTendererRequirement>
          <cbc:TendererRequirementTypeCode listName="reserved-procurement">none</cbc:TendererRequirementTypeCode>
        </cac:SpecificTendererRequirement>
      </cac:TendererQualificationRequest>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="einvoicing">required</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="reserved-execution">no</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="ecatalog-submission">not-allowed</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:AwardingTerms>
        <cac:AwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>60</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">price</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Kokonaisvertailuhinta</cbc:Name>
            <cbc:Description languageID="FIN">Halvin tarjottu tarjouspyynnön mukainen kokonaishinta saa vertailussa enimmäispisteet 60. Muiden tarjoajien pistemäärä muodostuu suorassa suhteessa halvimpaan (halvin / vertailtava hinta x enimmäispisteet).</cbc:Description>
          </cac:SubordinateAwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>40</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">quality</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Laatupisteet</cbc:Name>
            <cbc:Description languageID="FIN">Laatupisteytys ja -kriteeri ovat seuraavat:
1. Tarjoajan henkilöstön (ilman vastaavaa työnjohtajaa) kokemus vastaavista ulkoliikuntapaikkojen kesähoidon palvelutehtävistä, 10 % eli enintään 10 pistettä. 
2. Tarjoajan tämän osa-alueen liikuntapaikkojen hoitoon käytettävissä olevan henkilöstön koulutus, 15 % eli 15 pistettä.
3. Vastaavan työnjohtajan kokemus ulkoliikuntapaikkojen kesähoidon palvelutehtävistä 15 % eli 15 pistettä.</cbc:Description>
          </cac:SubordinateAwardingCriterion>
        </cac:AwardingCriterion>
      </cac:AwardingTerms>
      <cac:TenderRecipientParty>
        <cbc:EndpointID>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:EndpointID>
      </cac:TenderRecipientParty>
      <cac:TenderValidityPeriod>
        <cbc:DurationMeasure unitCode="DAY">120</cbc:DurationMeasure>
      </cac:TenderValidityPeriod>
      <cac:AppealTerms>
        <cac:AppealReceiverParty>
          <cac:PartyIdentification>
            <cbc:ID schemeName="organization">ORG-0002</cbc:ID>
          </cac:PartyIdentification>
        </cac:AppealReceiverParty>
      </cac:AppealTerms>
      <cac:Language>
        <cbc:ID>FIN</cbc:ID>
      </cac:Language>
      <cac:PostAwardProcess>
        <cbc:ElectronicOrderUsageIndicator>true</cbc:ElectronicOrderUsageIndicator>
        <cbc:ElectronicPaymentUsageIndicator>true</cbc:ElectronicPaymentUsageIndicator>
      </cac:PostAwardProcess>
    </cac:TenderingTerms>
    <cac:TenderingProcess>
      <cbc:SubmissionMethodCode listName="esubmission">required</cbc:SubmissionMethodCode>
      <cbc:GovernmentAgreementConstraintIndicator>true</cbc:GovernmentAgreementConstraintIndicator>
      <cac:TenderSubmissionDeadlinePeriod>
        <cbc:EndDate>2023-11-15+02:00</cbc:EndDate>
        <cbc:EndTime>12:00:00+02:00</cbc:EndTime>
      </cac:TenderSubmissionDeadlinePeriod>
      <cac:AdditionalInformationRequestPeriod>
        <cbc:EndDate>2023-10-26+03:00</cbc:EndDate>
        <cbc:EndTime>16:00:00+03:00</cbc:EndTime>
      </cac:AdditionalInformationRequestPeriod>
      <cac:OpenTenderEvent>
        <cbc:OccurrenceDate>2023-11-15+02:00</cbc:OccurrenceDate>
        <cbc:OccurrenceTime>12:30:00+02:00</cbc:OccurrenceTime>
      </cac:OpenTenderEvent>
      <cac:AuctionTerms>
        <cbc:AuctionConstraintIndicator>false</cbc:AuctionConstraintIndicator>
      </cac:AuctionTerms>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="dps-usage">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="framework-agreement">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
    </cac:TenderingProcess>
    <cac:ProcurementProject>
      <cbc:ID schemeName="InternalID">3.</cbc:ID>
      <cbc:Name languageID="FIN">3. Kiskon ja Muurlan kaupunginosa, kesähoito</cbc:Name>
      <cbc:Description languageID="FIN">Hankinnan kohteena on Kiskon ja Muurlan kaupunginosan liikuntapaikkojen kesähoito tarjouspyynnön ja liitteen 1. Hankinnan vaatimukset ja palvelukuvaus mukaisesti. Lisäksi tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
      <cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
      <cbc:SMESuitableIndicator>true</cbc:SMESuitableIndicator>
      <cac:MainCommodityClassification>
        <cbc:ItemClassificationCode listName="cpv">92610000</cbc:ItemClassificationCode>
      </cac:MainCommodityClassification>
      <cac:RealizedLocation>
        <cac:Address>
          <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
          <cac:Country>
            <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
          </cac:Country>
        </cac:Address>
      </cac:RealizedLocation>
      <cac:PlannedPeriod>
        <cbc:StartDate>2024-01-01+02:00</cbc:StartDate>
        <cbc:EndDate>2025-12-31+02:00</cbc:EndDate>
      </cac:PlannedPeriod>
      <cac:ContractExtension>
        <cbc:MaximumNumberNumeric>2</cbc:MaximumNumberNumeric>
        <cac:Renewal>
          <cac:Period>
            <cbc:Description languageID="FIN">Tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
          </cac:Period>
        </cac:Renewal>
      </cac:ContractExtension>
    </cac:ProcurementProject>
  </cac:ProcurementProjectLot>
  <cac:ProcurementProjectLot>
    <cbc:ID schemeName="Lot">LOT-0004</cbc:ID>
    <cac:TenderingTerms>
      <ext:UBLExtensions>
        <ext:UBLExtension>
          <ext:ExtensionContent>
            <efext:EformsExtension>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">ef-stand</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">sui-act</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
              <efac:SelectionCriteria>
                <cbc:CriterionTypeCode listName="selection-criterion">tp-abil</cbc:CriterionTypeCode>
                <cbc:CalculationExpressionCode listName="usage">n-used</cbc:CalculationExpressionCode>
              </efac:SelectionCriteria>
            </efext:EformsExtension>
          </ext:ExtensionContent>
        </ext:UBLExtension>
      </ext:UBLExtensions>
      <cbc:FundingProgramCode listName="eu-funded">no-eu-funds</cbc:FundingProgramCode>
      <cbc:RecurringProcurementIndicator>true</cbc:RecurringProcurementIndicator>
      <cbc:MultipleTendersCode listName="permission">allowed</cbc:MultipleTendersCode>
      <cac:CallForTendersDocumentReference>
        <cbc:ID>Linkki hankinta-asiakirjoihin</cbc:ID>
        <cbc:DocumentType>non-restricted-document</cbc:DocumentType>
        <cac:Attachment>
          <cac:ExternalReference>
            <cbc:URI>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:URI>
          </cac:ExternalReference>
        </cac:Attachment>
      </cac:CallForTendersDocumentReference>
      <cac:TendererQualificationRequest>
        <cac:SpecificTendererRequirement>
          <cbc:TendererRequirementTypeCode listName="reserved-procurement">none</cbc:TendererRequirementTypeCode>
        </cac:SpecificTendererRequirement>
      </cac:TendererQualificationRequest>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="einvoicing">required</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="reserved-execution">no</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:ContractExecutionRequirement>
        <cbc:ExecutionRequirementCode listName="ecatalog-submission">not-allowed</cbc:ExecutionRequirementCode>
      </cac:ContractExecutionRequirement>
      <cac:AwardingTerms>
        <cac:AwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>60</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">price</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Kokonaisvertailuhinta</cbc:Name>
            <cbc:Description languageID="FIN">Halvin tarjottu tarjouspyynnön mukainen kokonaishinta saa vertailussa enimmäispisteet 60. Muiden tarjoajien pistemäärä muodostuu suorassa suhteessa halvimpaan (halvin / vertailtava hinta x enimmäispisteet).</cbc:Description>
          </cac:SubordinateAwardingCriterion>
          <cac:SubordinateAwardingCriterion>
            <ext:UBLExtensions>
              <ext:UBLExtension>
                <ext:ExtensionContent>
                  <efext:EformsExtension>
                    <efac:AwardCriterionParameter>
                      <efbc:ParameterCode listName="number-weight">poi-exa</efbc:ParameterCode>
                      <efbc:ParameterNumeric>40</efbc:ParameterNumeric>
                    </efac:AwardCriterionParameter>
                  </efext:EformsExtension>
                </ext:ExtensionContent>
              </ext:UBLExtension>
            </ext:UBLExtensions>
            <cbc:AwardingCriterionTypeCode listName="award-criterion-type">quality</cbc:AwardingCriterionTypeCode>
            <cbc:Name languageID="FIN">Laatupisteet</cbc:Name>
            <cbc:Description languageID="FIN">Laatupisteytys ja -kriteeri ovat seuraavat:
1. Tarjoajan henkilöstön (ilman vastaavaa työnjohtajaa) kokemus vastaavista ulkoliikuntapaikkojen talvihoidon palvelutehtävistä, 10 % eli enintään 10 pistettä. 
2. Tarjoajan tämän osa-alueen liikuntapaikkojen hoitoon käytettävissä olevan henkilöstön koulutus, 15 % eli 15 pistettä.
3. Vastaavan työnjohtajan kokemus ulkoliikuntapaikkojen talvihoidon palvelutehtävistä 15 % eli 15 pistettä.</cbc:Description>
          </cac:SubordinateAwardingCriterion>
        </cac:AwardingCriterion>
      </cac:AwardingTerms>
      <cac:TenderRecipientParty>
        <cbc:EndpointID>https://tarjouspalvelu.fi/salo?id=478755&amp;tpk=32c05b68-10f4-4cce-a6d8-f6ae2b14154b</cbc:EndpointID>
      </cac:TenderRecipientParty>
      <cac:TenderValidityPeriod>
        <cbc:DurationMeasure unitCode="DAY">120</cbc:DurationMeasure>
      </cac:TenderValidityPeriod>
      <cac:AppealTerms>
        <cac:AppealReceiverParty>
          <cac:PartyIdentification>
            <cbc:ID schemeName="organization">ORG-0002</cbc:ID>
          </cac:PartyIdentification>
        </cac:AppealReceiverParty>
      </cac:AppealTerms>
      <cac:Language>
        <cbc:ID>FIN</cbc:ID>
      </cac:Language>
      <cac:PostAwardProcess>
        <cbc:ElectronicOrderUsageIndicator>true</cbc:ElectronicOrderUsageIndicator>
        <cbc:ElectronicPaymentUsageIndicator>true</cbc:ElectronicPaymentUsageIndicator>
      </cac:PostAwardProcess>
    </cac:TenderingTerms>
    <cac:TenderingProcess>
      <cbc:SubmissionMethodCode listName="esubmission">required</cbc:SubmissionMethodCode>
      <cbc:GovernmentAgreementConstraintIndicator>true</cbc:GovernmentAgreementConstraintIndicator>
      <cac:TenderSubmissionDeadlinePeriod>
        <cbc:EndDate>2023-11-15+02:00</cbc:EndDate>
        <cbc:EndTime>12:00:00+02:00</cbc:EndTime>
      </cac:TenderSubmissionDeadlinePeriod>
      <cac:AdditionalInformationRequestPeriod>
        <cbc:EndDate>2023-10-26+03:00</cbc:EndDate>
        <cbc:EndTime>16:00:00+03:00</cbc:EndTime>
      </cac:AdditionalInformationRequestPeriod>
      <cac:OpenTenderEvent>
        <cbc:OccurrenceDate>2023-11-15+02:00</cbc:OccurrenceDate>
        <cbc:OccurrenceTime>12:30:00+02:00</cbc:OccurrenceTime>
      </cac:OpenTenderEvent>
      <cac:AuctionTerms>
        <cbc:AuctionConstraintIndicator>false</cbc:AuctionConstraintIndicator>
      </cac:AuctionTerms>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="dps-usage">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
      <cac:ContractingSystem>
        <cbc:ContractingSystemTypeCode listName="framework-agreement">none</cbc:ContractingSystemTypeCode>
      </cac:ContractingSystem>
    </cac:TenderingProcess>
    <cac:ProcurementProject>
      <cbc:ID schemeName="InternalID">4.</cbc:ID>
      <cbc:Name languageID="FIN">4. Kiskon kaupunginosa, talvihoito</cbc:Name>
      <cbc:Description languageID="FIN">Hankinnan kohteena on Kiskon kaupunginosan liikuntapaikkojen talvihoito tarjouspyynnön ja liitteen 1. Hankinnan vaatimukset ja palvelukuvaus mukaisesti. Lisäksi tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
      <cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
      <cbc:SMESuitableIndicator>true</cbc:SMESuitableIndicator>
      <cac:MainCommodityClassification>
        <cbc:ItemClassificationCode listName="cpv">92610000</cbc:ItemClassificationCode>
      </cac:MainCommodityClassification>
      <cac:RealizedLocation>
        <cac:Address>
          <cbc:CountrySubentityCode listName="nuts">FI1C1</cbc:CountrySubentityCode>
          <cac:Country>
            <cbc:IdentificationCode listName="country">FIN</cbc:IdentificationCode>
          </cac:Country>
        </cac:Address>
      </cac:RealizedLocation>
      <cac:PlannedPeriod>
        <cbc:StartDate>2024-01-01+02:00</cbc:StartDate>
        <cbc:EndDate>2025-12-31+02:00</cbc:EndDate>
      </cac:PlannedPeriod>
      <cac:ContractExtension>
        <cbc:MaximumNumberNumeric>2</cbc:MaximumNumberNumeric>
        <cac:Renewal>
          <cac:Period>
            <cbc:Description languageID="FIN">Tilaaja varaa mahdollisuuden kahteen optiovuoteen 2026 ja 2027. Optiolla tarkoitetaan mahdollisuutta sopimuksen jatkamiseen alkuperäisin ehdoin. Optioiden käytöstä ja kestosta päätetään erikseen. </cbc:Description>
          </cac:Period>
        </cac:Renewal>
      </cac:ContractExtension>
    </cac:ProcurementProject>
  </cac:ProcurementProjectLot>
</ContractNotice>" +} diff --git a/tests/unit/notice_metadata_processor/test_eligibility.py b/tests/unit/notice_metadata_processor/test_eligibility.py index 328af67a8..db094e48b 100644 --- a/tests/unit/notice_metadata_processor/test_eligibility.py +++ b/tests/unit/notice_metadata_processor/test_eligibility.py @@ -1,20 +1,20 @@ from ted_sws.core.model.notice import NoticeStatus from ted_sws.data_manager.adapters.mapping_suite_repository import MappingSuiteRepositoryInFileSystem -from ted_sws.notice_metadata_processor.services.metadata_normalizer import MetadataNormaliser +from ted_sws.notice_metadata_processor.services.metadata_normalizer import normalise_notice from ted_sws.notice_metadata_processor.services.notice_eligibility import check_package, \ notice_eligibility_checker, notice_eligibility_checker_by_id def test_non_eligibility_by_notice(notice_eligibility_repository_path, indexed_notice): mapping_suite_repository = MappingSuiteRepositoryInFileSystem(repository_path=notice_eligibility_repository_path) - MetadataNormaliser(notice=indexed_notice).normalise_metadata() + normalise_notice(notice=indexed_notice) notice_eligibility_checker(notice=indexed_notice, mapping_suite_repository=mapping_suite_repository) assert indexed_notice.status == NoticeStatus.INELIGIBLE_FOR_TRANSFORMATION def test_eligibility_by_notice(notice_eligibility_repository_path, notice_2020): mapping_suite_repository = MappingSuiteRepositoryInFileSystem(repository_path=notice_eligibility_repository_path) - MetadataNormaliser(notice=notice_2020).normalise_metadata() + normalise_notice(notice=notice_2020) notice_checker = notice_eligibility_checker(notice=notice_2020, mapping_suite_repository=mapping_suite_repository) notice_id, mapping_suite_identifier = notice_checker assert notice_id == "408313-2020" @@ -23,7 +23,7 @@ def test_eligibility_by_notice(notice_eligibility_repository_path, notice_2020): def test_eligibility_by_notice_id(notice_eligibility_repository_path, notice_2020, notice_repository): - MetadataNormaliser(notice=notice_2020).normalise_metadata() + normalise_notice(notice=notice_2020) notice_repository.add(notice_2020) mapping_suite_repository = MappingSuiteRepositoryInFileSystem(repository_path=notice_eligibility_repository_path) notice_checker = notice_eligibility_checker_by_id(notice_id="408313-2020", @@ -52,5 +52,4 @@ def test_check_mapping_suite(notice_eligibility_repository_path, normalised_meta normalised_metadata_object.eforms_subtype = "88" is_valid = check_package(mapping_suite=mapping_suite_repository.get("test_package"), notice_metadata=normalised_metadata_object) - print(is_valid) - assert not is_valid + assert not is_valid \ No newline at end of file diff --git a/tests/unit/notice_metadata_processor/test_metadata_extractor.py b/tests/unit/notice_metadata_processor/test_metadata_extractor.py index 1b9ed7635..92b321a87 100644 --- a/tests/unit/notice_metadata_processor/test_metadata_extractor.py +++ b/tests/unit/notice_metadata_processor/test_metadata_extractor.py @@ -10,10 +10,10 @@ def test_metadata_extractor(indexed_notice): metadata_extractor = DefaultNoticeMetadataExtractor( xml_manifestation=indexed_notice.xml_manifestation).extract_metadata() - extracted_metadata_dict = metadata_extractor.model_dump() + extracted_metadata_dict = metadata_extractor.dict() assert isinstance(metadata_extractor, ExtractedMetadata) - assert extracted_metadata_dict.keys() == ExtractedMetadata.model_fields.keys() + assert extracted_metadata_dict.keys() == ExtractedMetadata.__fields__.keys() assert "extracted_form_number", "xml_schema" in extracted_metadata_dict.keys() assert "067623-2022" in extracted_metadata_dict["notice_publication_number"] assert "http://publications.europa.eu/resource/schema/ted/R2.0.8/publication TED_EXPORT.xsd" in \ @@ -25,9 +25,9 @@ def test_metadata_extractor_2016(notice_2016): metadata_extractor = DefaultNoticeMetadataExtractor( xml_manifestation=notice_2016.xml_manifestation).extract_metadata() - extracted_metadata_dict = metadata_extractor.model_dump() + extracted_metadata_dict = metadata_extractor.dict() assert isinstance(metadata_extractor, ExtractedMetadata) - assert extracted_metadata_dict.keys() == ExtractedMetadata.model_fields.keys() + assert extracted_metadata_dict.keys() == ExtractedMetadata.__fields__.keys() assert notice_2016.ted_id in extracted_metadata_dict["notice_publication_number"] @@ -35,9 +35,9 @@ def test_metadata_extractor_2015(notice_2015): metadata_extractor = DefaultNoticeMetadataExtractor( xml_manifestation=notice_2015.xml_manifestation).extract_metadata() - extracted_metadata_dict = metadata_extractor.model_dump() + extracted_metadata_dict = metadata_extractor.dict() assert isinstance(metadata_extractor, ExtractedMetadata) - assert extracted_metadata_dict.keys() == ExtractedMetadata.model_fields.keys() + assert extracted_metadata_dict.keys() == ExtractedMetadata.__fields__.keys() assert notice_2015.ted_id in extracted_metadata_dict["notice_publication_number"] @@ -45,9 +45,9 @@ def test_metadata_extractor_2018(notice_2018): metadata_extractor = DefaultNoticeMetadataExtractor( xml_manifestation=notice_2018.xml_manifestation).extract_metadata() - extracted_metadata_dict = metadata_extractor.model_dump() + extracted_metadata_dict = metadata_extractor.dict() assert isinstance(metadata_extractor, ExtractedMetadata) - assert extracted_metadata_dict.keys() == ExtractedMetadata.model_fields.keys() + assert extracted_metadata_dict.keys() == ExtractedMetadata.__fields__.keys() assert notice_2018.ted_id in extracted_metadata_dict["notice_publication_number"] @@ -108,10 +108,10 @@ def test_get_normalised_namespaces(indexed_notice): def test_metadata_eform_extractor(eform_notice_622690): metadata_extractor = EformsNoticeMetadataExtractor( xml_manifestation=eform_notice_622690.xml_manifestation).extract_metadata() - extracted_metadata_dict = metadata_extractor.model_dump() + extracted_metadata_dict = metadata_extractor.dict() print(extracted_metadata_dict) assert isinstance(metadata_extractor, ExtractedMetadata) - assert extracted_metadata_dict.keys() == ExtractedMetadata.model_fields.keys() + assert extracted_metadata_dict.keys() == ExtractedMetadata.__fields__.keys() assert "extracted_form_number", "xml_schema" in extracted_metadata_dict.keys() assert "00622690-2023" in extracted_metadata_dict["notice_publication_number"] assert "competition" in extracted_metadata_dict["extracted_eform_type"] diff --git a/tests/unit/notice_packager/test_metadata_transformer.py b/tests/unit/notice_packager/test_metadata_transformer.py index 68e30aba4..768b8b33e 100644 --- a/tests/unit/notice_packager/test_metadata_transformer.py +++ b/tests/unit/notice_packager/test_metadata_transformer.py @@ -6,17 +6,17 @@ # Email: kalean.bl@gmail.com """ """ - +from ted_sws.core.model.metadata import NormalisedMetadata from ted_sws.notice_metadata_processor.model.metadata import ExtractedMetadata from ted_sws.notice_packager.services.metadata_transformer import MetadataTransformer, publication_notice_uri, \ publication_notice_year, publication_work_identifier, publication_notice_number, NORMALIZED_SEPARATOR -def test_notice_metadata(notice_sample_metadata: ExtractedMetadata): - assert isinstance(notice_sample_metadata, ExtractedMetadata) +def test_notice_metadata(notice_sample_metadata: NormalisedMetadata): + assert isinstance(notice_sample_metadata, NormalisedMetadata) -def test_metadata_transformer(notice_sample_metadata: ExtractedMetadata): +def test_metadata_transformer(notice_sample_metadata: NormalisedMetadata): metadata_transformer = MetadataTransformer(notice_sample_metadata) template_metadata = metadata_transformer.template_metadata() diff --git a/tests/unit/notice_packager/test_notice_packager.py b/tests/unit/notice_packager/test_notice_packager.py index a3725b859..11241af47 100644 --- a/tests/unit/notice_packager/test_notice_packager.py +++ b/tests/unit/notice_packager/test_notice_packager.py @@ -9,11 +9,14 @@ from ted_sws.core.model.manifestation import RDFManifestation from ted_sws.core.model.notice import NoticeStatus +from ted_sws.notice_metadata_processor.services.metadata_normalizer import normalise_notice from ted_sws.notice_packager.model.metadata import METS_TYPE_CREATE from ted_sws.notice_packager.services.notice_packager import package_notice, NoticePackager def test_notice_packager_with_notice(notice_2018, rdf_content): + notice_2018._status = NoticeStatus.INDEXED + normalise_notice(notice=notice_2018) rdf_manifestation = RDFManifestation(object_data=rdf_content) notice_2018._status = NoticeStatus.ELIGIBLE_FOR_PACKAGING notice_2018._rdf_manifestation = rdf_manifestation